OpenLLM-France/wikimedia huggingface dataset:
# Historical Rhetorics/Sophists Old and New/Rivers, Nathaniel.

Rivers, Nathaniel A. “Some Assembly Required: The Latourian Collective and the Banal Work of Technical and Professional Communication.” Journal of Technical Writing and Communication 38.3 (2008): 189–206.
Rivers argues that the popular television show, Mythbusters, serves as an illustration of Latour's argument that the abolishment of dichotomies – nature/culture, politics/science, human/nonhuman – will foster actionable results. Mythbusters demonstrates this theory with its inclusion of humans (actors, building team, television crew, folklorist) and nonhumans (the tools used, such as Buster the test dummy). Technical and professional communication, then, should no longer see themselves as the messengers between those within the cave (politicians) and those without (scientists); instead, technical and professional writers should collect sensitivities and propositions and articulate them, knowing that science is no longer the only means of solving our greatest problems. This article gives a summary of Latour's terminology in Politics of Nature and applies that language to Mythbusters while arguing for a new means of professional and technical communication.
Quotes:
“The Discovery Channel, in the last several years, has converted science into performance art [Mythbusters] . . . These mythbusters, in the very run of their lives, blur the line between the science of laboratories and the performance of recording studios . . . By positioning itself as performative, Mythbusters tacitly resists the view that scientists are, as Descartes would have them, ‘brains in a vat’ (189-90).
“Rather than bridging the gap between the real and the shadow of the real, professional and technical communicators create alternate spaces, new houses of government, unburdened by the self-defeating hope for a savior in a lab coat. This is, then, the new work of collecting collaborative assemblages between humans and nonhumans and of connecting the common world and the common good” (191).
“When Latour uses the word collective, he refers not to ‘an already-established unit, but a procedure for collecting associations of humans and nonhumans.’ Collecting, I am arguing, is the primary rhetorical task of technical and professional communication. Briefly, we can see professional communication as the assembling of humans with nonhumans such as businesses, industries, documents (genres), numbers, money, products, and demographics. Technical communication is, then, the assembling of humans with nonhumans including designs, schematics, computers, interfaces, equipment, and various other technologies” (197).
# HydroGeoSphere/Intermittent Conditions

Boundary conditions can be turned on and off by assigning special NODATA values instead of normal input in the time-value, time-raster and time-file tables. For example, the default NODATA value is -99999., and the following table:
would apply the specified head of 100 from time 0.0 to time 1000.0 and then allow the node to revert to an unconstrained condition until time 2000.0, when a specified head of 100.0 would again be applied for the duration of the simulation.
For rasters and files, the default NODATA value is the string 'none'.
If for some reason you need to change the default NODATA value you can use:

## Nodata value

* nodata_value The value that indicates there is no data.
The following instructions are used to change the NODATA values used for rasters and files :
       nodata raster
       nodata file
# HydroGeoSphere/Interpolation

Time-varying boundary conditions change abruptly from value bc_val(i) to value bc_val(i+1) at time bc_time(i+1). To have HydroGeoSphere use linear interpolation to smooth the values used between time panel endpoints use:

## Interpolate

This command causes time-varying values to be interpolated between panel values for the boundary condition currently being defined. This results in a smoother application of the time-varying function.
# Lotus Series
## CPU

* CPU:

## Memory

* Memory:
* Memory Type:

## Video Graphics Display

* Video Graphics Chipset: Nvidia GeForce 9800M GTX (???MB)
* Screen Size:
* Maximum Screen Resolution:

## Audio

* Audio Chipset:

## Pointing Device

* Pointing Device Type: Touchpad
# Nine Series
## CPU

* CPU:

## Memory

* Memory:
* Memory Type:

## Video Graphics Display

* Video Graphics Chipset: Nvidia Dual GeForce 9800M GTX (???MB)
* Screen Size:
* Maximum Screen Resolution:

## Audio

* Audio Chipset:

## Pointing Device

* Pointing Device Type: Touchpad
# Laptop Computer Models/Malibal

    Lotus Series
    Nine Series
    Satori Series
# Knowledge Management Cases in Asia/Implementation of Knowledge Management in Asia's Beverage Industry/Conclusions

KM project is involved in technology, process, as well as people of the organisation. Even the perfect system is built up, without embedding it into working process and the support from the top management and all users, or vice versa, KM project can not be successful.
From the literature review section and the case study, we can see that KM tools and strategies can be various to be used to implement KM in beverage industry. The consideration is that if they are suitable to particular company's requirements. Therefore, fully understanding of the industry, company as well as the users are very important before designing KM project. Otherwise, it is unquestionably self-defeating action on implementing or promoting KM concept to staff, especially in Asia that sharing is not a common norm.
Even it is still facing plenty of obstacles like reluctant in culture changes or behaviour changes, there are many experts in Asia, who have already realised the situation in Asia, devoted to promote KM and gain trust from lots of top management. With their support and promotion, we believe that KM concept in Asia beverage industry, or even other industrty, can be widely accepted from the top management to all levels of staff.
# Knowledge Management Cases in Asia/Implementation of Knowledge Management in Asia's Beverage Industry/Introduction

This chapter will focus on knowledge management (KM) in beverage industry. In the literature review section, we provide an in-depth study on various organizations in the industry, and the KM tools and strategies employed by the organizations as well as the problems have been solved by employing such. In the last part of the review, we turn the focus on discussing the development trend of KM in the beverage industry.
In the core part of the chapter, we study a real case on KM. We have interviewed a consulting firm (Consultancy A) to collect information on one of their KM projects. In that KM project, Consultancy A works as a consultant and later a cooperator with one of the beverage companies (Company B) in Asia. Our study is focus on what KM tools and strategies are employed by the company, and how such can be used to improve its knowledge retention as well as the impacts may bring to the company.
Finally, through the literature review and the case study, we can see how the enhancement of KM concepts influences the organizations and their business. Moreover, the chapter also provides an important insight into the development trend of the industry.
# Knowledge Management Cases in Asia/Implementation of Knowledge Management in Asia's Beverage Industry/Research Methods
## Literature Reviews

To know more about the environment, KM behaviour in the industry, we have gathered journal opinions about KM in food and beverage industry. In addition, cases from different multinational companies are studied to see what problems they faced and how they solved them when applying KM projects.

## Interviews

To gather information of Company B's KM project, we have conducted two interviews with Mr. Cheung, the consultant from Consultancy A, who is responsible for this project. Both interviews have lasted for an hour.
In the first interview, we obtained preliminary information of the background of Consultancy A and Company B. We also knew more about the environment and trend on applying KM in the industry.
In the second interview, we focus more on the KM project that will be implemented in Company B such as the details of the phases, the application of KM tools and strategies as well as change management.
# Living in a Connected World 2018
## Preamble

This is the opening page to the Living in a Connected World 2018 Wikibook.
As the title suggests, this is a book which seeks to record contributions to the understanding of a specific set of topics, loosely grouped under the subject area of "Digital Culture", of particular salience to 2018.
It is put together through the combined talents and efforts of a cohort of students taking the new graduate level module CMCPP10 during the Autumn of 2018 at the University of Stirling in Scotland, UK. It is an assessed educational project. We would like to thank the Wikibooks community for assistance given in the course of this project, and also encourage leniency in dealing with our work - we are all beginners in the world of wiki here, but are keen to learn!
The aim of this educational project is, firstly, for students to record the content of their learning and their contributions to this book will reflect their studies on one of the featured themes. This will appear in the form of a series of Collaborative Essays, and therefore this Wikibook is a sort of edited collection or anthology, much like examples found in academic publishing. However, secondly and most importantly, the hope is that students will learn the values associated with working at different levels as individual researchers, as research teams, and as research communities on Wikimedia and other open knowledge platforms. That is to say: producing knowledge; collaboration and sharing; and peer-reviewing the work of others for the good of the community Wikimedia, but in particular on Wikibooks.
Students will thus gain hands-on experience of a wiki environment, and what it is like to be part of a knowledge-building community, within the auspices of one of Wikimedia's large projects (i.e. Wikibooks) and make something that adds to currents in the academic field of digital media and society.
Note that while this is a class project, anyone may contribute as Wikibooks does not permit "ownership" of material.

## Table of Contents

In what ways do social platforms like Twitter impact on user emotional intelligence?
In what ways does Instagram and Instagram culture flatten out cultural specificity?
What categories of data can benefit merchants to improve their sale profit?

## List of Contributors

This Wikibook is being put together as an on-going a collaborative class project by the following Wikimedian contributors. Together, they form a cohort of students studying Living in a Connected World as part of their graduate degree programme in the Division of Communications, Media and Culture, University of Stirling, Scotland, UK. Doubtless, there are other contributors within the Wikibooks and Wikipedia community who have contributed advice, support, suggestions and content in collaboration with these students. Your help and advice is most appreciated. Thank you!
       Contributors, please feel free to sign your username on the contributors page here

## Glossary

A list of definitions of key terms to be found in this Wikibook, student contribs from all project groups welcome. See here.
# Living in a Connected World 2018/Contributors

* GregXenon01 (discuss • contribs)
* Zamzam (discuss • contribs)
* Min1996 (discuss • contribs)
* Just improvise mate (discuss • contribs)
* Dmedia14 (discuss • contribs)
* Cecila123 (discuss • contribs)
* Awesooome92 (discuss • contribs)
* Melsperspective (discuss • contribs)
# Learning Clojure/Multimethods and polymorphism
## Multimethods and polymorphism

Most languages treat encapsulation and implementation inheritance as the primary features of object-oriented programming, but Clojure thinks these things are overrated. The real virtue of OOP, Clojure says, is polymorphism---encapsulation and inheritance are simply straight-jackets holding back polymorphism's potential.
When doing object-oriented programming in Clojure, we simply use structmaps in place of objects while, in place of traditional encapsulated methods, we use what Clojure calls multimethods, functions which pass on their arguments to other functions based on some criteria of the arguments, such as the number and/or type of the arguments.
A multimethod is made up of three things: a dispatch function, a set of methods, and a set of values associated with those methods. Calling a multimethod calls the dispatch function, and the value returned determines which method to call. A multimethod is created with clojure/defmulti and methods added to it by the macro clojure/defmethod. Here's a reductively simple multimethod with just two methods:
Note that the methods' arities must match the multimethod arity because the dispatch function calls the methods by passing on its arguments. (Also note the stylistic inconsistency: defmulti expects a function argument whereas defmethod imitates the defn form.)
Multimethods can be used to imitate traditional single- and multiple-inheritance polymorphism as well as more flexible kinds of polymorphism.
# Learning Clojure/REPL

Part of the power of languages in the Lisp family comes from the way that you can alter the code of a running program. Traditionally, languages in the Lisp family offer a type of command-line shell environment called the REPL, which stands for Read, Evaluate, Print Loop. This refers to the fact that the REPL first reads an expression from the user, evaluates that expression, and prints out the result before looping back to the beginning. The REPL will continue allowing you to execute expressions until it receives an EOF (Ctrl-D) or is otherwise killed.
# Learning Clojure/Operations

Lisp source code is executed in two phases:
* The source is read by the reader, which parses the source into a data structure.
* Then the evaluator traverses this data structure, interpreting the data into action according to a simple set of rules.
While the source of just about all languages is processed by first translating it into a data structure---an Abstract Syntax Tree (AST)---Lisp is unique in that it keeps this data structure and the evaluation rules simple enough for you, the programmer using the language, to understand the details of this process in full. Once you understand how the reader and evaluator "think", you'll understand Lisp.
Like other dynamic languages, Lisp can be used in an interactive command-line mode. Lisp calls this mode the Read Evaluate Print Loop (REPL): each time a command is typed at the REPL, it is read and then evaluated, and then the value returned by evaluation is printed. The REPL is useful as a calculator, for quick experiments, or for inspecting or modifying a running program (such as when a break is triggered when debugging).
Programs, however, are of course written as source code files. You might expect the reader to read a whole source file up front before handing off to the evaluator, but this is not the case: in some Lisp dialects, the behavior of the reader can be modified by evaluated code, so the reader hands off each chunk of usable code to the evaluator as it reads them, thereby allowing code to modify how code below it will be read. In Clojure, the reader's behavior is currently not modifiable, but Clojure follows this traditional read-evaluate pattern anyway. (In the future, Clojure may allow reader modification.)

## The Reader

In Clojure, the reader ignores ";" and everything after it on the line.
Whitespace is required to separate "atoms" (symbols, keywords, number literals, and string literals, etc.) from each other but is otherwise ignored. The , character is considered whitespace, which is useful stylistically for creating a clearer visual separation between atoms:
But in string literals, of course, whitespace, ;, and , are treated as themselves.
Otherwise, the reader basically sees source as a bunch of literals. For instance:
The reader parses this into a list containing the symbol def, then the symbol jerry, and last a vector with the Integers 1, 2, and 3. Because this list is at the "top level" of code (it isn't contained in another collection), it is passed off to the evaluator immediately once it is fully read.
The behavior of the reader can be modified by special prefixes on literals called reader macros, but these are pretty much just convenience features, so we'll discuss them later.
# Java Programming/Random numbers

* Navigate Language Fundamentals topic: ( v • d • e )
* Statements
* Conditional blocks
* Loop blocks
* Boolean expressions
* Variables
* Primitive Types
* Arithmetic expressions
* Literals
* Methods
* String
* Objects
* Packages
* Arrays
* Mathematical functions
* Large numbers
* Random numbers
* Unicode
* Comments
* Keywords
* Coding conventions
* Lambda expressions
To generate random numbers the Math.random method can be used, which returns a double, greater than or equal to 0.0 and less than 1.0.
The following code returns a random integer between n and m (where n <= randomNumber < m):
* Code section 3.30: A random integer.
* int randomNumber = n + (int)(Math.random * ( m - n ));
Alternatively, the java.util.Random class provides methods for generating random booleans, bytes, floats, ints, longs and 'Gaussians' (doubles from a normal distribution with mean 0.0 and standard deviation 1.0). For example, the following code is equivalent to that above:
* Code section 3.31: A random integer with Gaussian.
* Random random = new Random;
* int randomNumber = n + random.nextInt(m - n);
As an example using random numbers, we can make a program that uses a Random object to simulate flipping a coin 20 times:
* Code listing 3.25: CoinFlipper.java
* import java.util.Random;
* public class CoinFlipper {
* public static void main(String args) {
* // The number of times to flip the coin
* final int TIMES_TO_FLIP = 20;
* int heads = 0;
* int tails = 0;
* // Create a Random object
* Random random = new Random;
* for (int i = 0; i < TIMES_TO_FLIP; i++) {
* // 0 or 1
* int result = random.nextInt(2);
* if (result == 1) {
* System.out.println("Heads");
* heads++;
* } else {
* System.out.println("Tails");
* tails++;
* System.out.println("There were "
* + heads
* + " heads and "
* + tails
* + " tails");
* Possible output for code listing 3.25
* Heads
* Tails
* Tails
* Tails
* Heads
* Tails
* Heads
* Heads
* Heads
* Heads
* Heads
* Heads
* Tails
* Tails
* Tails
* Tails
* Heads
* Tails
* Tails
* Tails
* There were 9 heads and 11 tails
Of course, if you run the program you will probably get different results.

## Truly random numbers

Both Math.random and the Random class produce pseudorandom numbers. This is good enough for a lot of applications, but remember that it is not truly random. If you want a more secure random number generator, Java provides the java.security.SecureRandom package. What happens with Math.random and the Random class is that a 'seed' is chosen from which the pseudorandom numbers are generated. SecureRandom increases the security to ensure that the seed which is used by the pseudorandom number generator is non-deterministic — that is, you cannot simply put the machine in the same state to get the same set of results. Once you have created a SecureRandom instance, you can use it in the same way as you can the Random class.
If you want truly random numbers, you can get a hardware random number generator or use a randomness generation service.
# Java Programming/Reflection/Accessing Private Features with Reflection

* Navigate Reflection topic: ( v • d • e )
* Reflection Overview
* Dynamic Class Loading
* Dynamic Method Invocation
* Accessing Private Features with Reflection
All features of a class can be obtained via reflection, including access to private methods & variables. But not always see . Let us look at the following example:
* Code listing 10.3: Secret.java
* public class Secret {
* private String secretCode = "It's a secret";
* private String getSecretCode {
* return secretCode;
Although the field and method are marked private, the following class shows that it is possible to access the private features of a class:
* Code listing 10.4: Hacker.java
* import java.lang.reflect.Field;
* import java.lang.reflect.InvocationTargetException;
* import java.lang.reflect.Method;
* public class Hacker {
* private static final Object EMPTY =;
* public void reflect throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
* Secret instance = new Secret;
* Class<?> secretClass = instance.getClass;
* // Print all the method names & execution result
* Method methods = secretClass.getDeclaredMethods;
* System.out.println("Access all the methods");
* for (Method method : methods) {
* System.out.println("Method Name: " + method.getName);
* System.out.println("Return type: " + method.getReturnType);
* method.setAccessible(true);
* System.out.println(method.invoke(instance, EMPTY) + "\n");
* // Print all the field names & values
* Field fields = secretClass.getDeclaredFields;
* System.out.println("Access all the fields");
* for (Field field : fields) {
* System.out.println("Field Name: " + field.getName);
* field.setAccessible(true);
* System.out.println(field.get(instance) + "\n");
* public static void main(String args) {
* Hacker newHacker = new Hacker;
* try {
* newHacker.reflect;
* } catch (Exception e) {
* e.printStackTrace;
* Console for Code listing 10.4
* Access all the methods
* Method Name: getSecretCode
* Return type: class java.lang.String
* It's a secret
* Access all the fields
* Field Name: secretCode
* It's a secret

### JUnit - Test Private methods

JUnit's are unit test cases, used to test the Java programs. Now you know how to test a private method using Reflection in JUnit. There's a long-standing debate on whether testing private members is a good habit;There are cases where you want to make sure a class exhibited the right behavior while not making the fields that need checking to assert that public (as it's generally considered bad practice to create accessors to a class just for the sake of a unit test). There are also cases when you can greatly simplify a test case by using reflection to test all smaller private methods (and their various branches), then test the main function. With dp4j it is possible to test private members without directly using the Reflection API but simply accessing them as if they were accessible from the testing method; dp4j injects the needed Reflection code at compile-time.
* ↑ What's the best way of unit testing private methods?, March 7, 2011
* ↑ Reflection API injected at compile-time
# Java Programming/Reflection

* Navigate Reflection topic: ( v • d • e )
* Reflection Overview
* Dynamic Class Loading
* Dynamic Method Invocation
* Accessing Private Features with Reflection
Reflection is a new concept in Java, and did not exist in classical compiled languages like C, and C++. The idea is to discover an object's attributes and its methods programmatically.