OpenLLM-France/wikimedia huggingface dataset:
# Rhetoric and Composition/Teacher's Handbook/Narration
## Parts of a Narrative
### Setting the Scene:

Setting the scene is a great place to talk about sensory detail. Try introducing the topic with a short literary story or by asking students to describe the classroom using all their senses. Using detail can be fun, and it can be a good way to foreshadow the upcoming story.

### Introducing the Complication:

One interesting way to map the story arc is using storyboards. Have the students read part of a graphic novel, such as Persepolis, and then have students turn their stories into a graphic novel style storyboard. After setting the scene, something out of the ordinary, that presents a problem for the characters, is usually the next step in the arc.

### Evaluating the Options:

In many narratives, there is a moment when the characters stop and evaluate what has just happened. This gives the writer an opportunity to establish the character's feelings, foreshadow upcoming action, and show different characteristics of each character. To practice, have students get into groups and tell a story about something that happened to them. Often, the moment just after the complication has been introduced, is full of interesting introspection.

### Resolving the Problem:

This step, though obvious, can present a problem for students. Many students do not feel comfortable without a "wrap up" moment at the end of a story. Remind them that in the real world, not all stories are ended neatly. Perhaps the resolution is the lack of a resolution, or maybe the resolution is negative.

### The Coda:

This is where an argument, moral, or lesson can come in. If you are pairing an argument with the narrative, this is generally where the argument comes into play.

## Sample Lesson Plan

Narrative Argument and Podcast Assignment
Due: Monday, 10/5 Length: 700 words Submission: Paper Copy, burned CD
Because of the many ways people make arguments, it is important to learn how to use available technology. Podcasts have become a popular way to reach a variety and large number of people.
In this assignment, you should use a narrative argument to make a point about something people are afraid of. The narrative will probably be a memoir based on something that happened in your life. You can use the scary story you wrote as the basis, or you can tell a completely different. A narrative argument tends to follow this pattern: Set a scene Introduce a complication Evaluation Resolution Coda (a lesson, though this does not have to be the typical, heavy-handed lesson)
Once you have completed your final draft, you will turn your essay into a podcast. In pairs, go to the Digital Learning Collaboratory (HICKS library). Together, follow the How To: Podcasting handout to create podcasts of your and your partner’s paper. Then burn the podcasts to a burnable CD. You will submit the CD along with the narrative essay.
# Rhetoric and Composition/Teacher's Handbook/Teaching Sentence Structure/Exercises
## Basic Sentence Models

Students are to copy the model sentence and then write 2 or 3 (or more, if you choose) sentences using the same structure—no more, no less. I teach ELL students, so I also insist on keeping the given verb tense, because I want them working on past tense irregular verbs or –ed endings or –s endings in present tense.

## Basic Sentence Models: Intransitive

Pattern: N – V; Adj – N – V; Adj – N – Adv – V; Adj – N – Adv – V - PP; add “free modifiers”, compound subject; compound verb
1. The convict escaped.
2. The dangerous convict escaped.
3. The dangerous convict narrowly escaped.
4. The dangerous convict narrowly escaped through the window.
5. The dangerous convict, quiet as a mouse, narrowly escaped through the window.
6. The dangerous convict, young and quick, narrowly escaped through the window.
7. The dangerous convict, serving time for murder, narrowly escaped through the window.
8. The dangerous convict, who had beaten up a guard, narrowly escaped through a window.
9. The dangerous convict, who had beaten up a guard, and his hostage narrowly escaped through a window.
10. The dangerous convict, serving time for murder, beat up a guard and narrowly escaped through a window.

## Basic Sentence Models: Linking Verbs

Sentence Patterns: N/P – V – Adj; N/P – V – N; N/P – V – Adj – N; N/P – V – N – N; N/P – N/P – V – Adj; N/P – V – V – VP; free modifiers
1. She was brilliant
2. She was a student.
3. She was a brilliant student.
4. She was a brilliant student and a kind friend.
5. Her sister and she were brilliant students.
6. She was a brilliant student and expected to go to college.
7. She was a brilliant student but did not expect to go to college.
8. A brilliant student, she expected to go to college.
9. Mary, a brilliant student, expected to go to college.
10. She was a brilliant student who expected to go to college.
11. Moua and I remained hungry.
12. Moua and I remained hungry and tired.
13. Moua and I remained hungry and tired, but we worked hard.
14. Moua and I remained hungry and tired, but we still worked hard.

## Basic Sentence Models: Transitive Verbs

Sentence Patterns: N-V-DO; Adj-N-V-DO; Adj-N-Adv-V-DO; Adj-N-Adv-V-DO-PP;Adj-N-V-Conj-Adv-V-PP
1. The girl kicked the dog.
2. The young girl kicked the dog
3. The young girl viciously kicked the dog.
4. The young girl viciously kicked the dog down the stairs.
5. The young girl and her brother viciously kicked the dog down the stairs.
6. The young girl and her brother viciously kicked the dog down the stairs and laughed.
7. The young girl and her brother viciously kicked the dog down the stairs and laughed nervously.
8. The young girl felt threatened and viciously kicked the dog down the stairs.
9. The young girl, feeling threatened, viciously kicked the dog down the stairs.
10. Feeling threatened, the young girl viciously kicked the dog down the stairs.
11. Toua broke his leg when his car hit the tree.
12. Mai Houa bought her dress after she fought with her mother.
13. Xai brought his mother before Bou made dinner.
# Rhetoric and Composition/Teacher's Handbook/Teaching Grammar
## Introduction

No matter how intelligently designed or unique you make the writing assignments for your students to do, the issue of grammar will most likely be a a subject you will have to address in your class. Depending on the struggles students may have with grammar at this level, you can probably expect to include some grammar instruction in your classroom. However, with limited face-time with your class and a plethora of individual issues to cover, what are the most effective ways to deal with the grammatical errors that you may see your students making? The amount of grammar you cover will be entirely up to you, but the following ideas are meant to aid you in using this book in order to help students improve their writing skills as much as possible.

## Step 1

Using a Diagnostic
You may decide to use a grammar or writing diagnostic to determine the level of grammatical proficiency in your class, and from there decide how much class time you will want to spend focusing on grammar. The diagnostics will help tell you the pervasive problem areas and patterns that students exhibit, and this will help you develop a plan for what aspects to teach. For example, if most students have problems with verb tense, fragments, and parallelism, then these areas might be lessons you can actively teach the entire class about. If, however, only a few students use fragmented sentences in their writing, then other strategies may be needed.

## Step 2

Ideas to Help Teach Grammar
Glossing
This technique called "glossing" is one way to help students individually focus on one to three problem areas at a time. Once students turn in a paper to you, the easiest way to use this technique is to highlight the grammatical errors that you see them making over and over in their paper. Let's say that you have a student named Jackie who continually uses run on sentences, forgets to use commas after introductory clauses and switches verb tenses througout her paper. Highlight the grammatical errors you see in her paper (Focus on 3-5 only, or it will be overwhelming for her), label the highlighted portions as "run-on," "verb tense," etc...and then give her these instructions:
* Using the Rhetorical Composition Handbook, go to the section entitled, "Writer's Handbook."
* Look up the rules that apply to run-ons, verb tense and commas.
* Type three of the errors that were highlighted in your paper on a separate document, and then copy and paste the rules from the Writer's Handbook that will help you correct these errors.
* Type a corrected version of your glossed sentences to show that you recognize the grammatical errors that you made and understand the rule(s) that show you how to fix them.
# Monkey/Modules/Box2d

A port of the Box2D physics library to the Monkey language.

## Download

http://code.google.com/p/monkeybox2d/
# Monkey/Language/Lists
## What are Lists?

In Monkey, lists are a set of objects that are encapsulated in an object, and read in a set sequential order. Lists have the power to be read forwards, backwards, traversed object-by-object, sorted, and offer a node-level access for insertion and queries.
Example:
A list is created like any other object with the 'NEW' keyword. It differs from other objects because it requires a type specifier. Type specifiers (or type parameters) are defined using the greater than-less than signs: < and >. In the above example, the list 'mylist' is a list of 'Obj's, which is a class of three fields: x, y, and z.
'EachIn' will automatically iterate through a list, assigning the object to the iterating variable. EachIn will exit the loop when a NULL is reached, signaling the end of the list.

## What are Nodes?

Syntax for a list's node:
Nodes are also created when an object is added to a list:
Nodes can return a value from the list:
Nodes can be used to iterate through a list backwards:
Nodes can insert a value into a list, using the Node constructor (the New command):
Nodes can remove a value from a list, although be sure to be done with that node before you remove it:
# Monkey/Language/Maps
## What are Maps?

Maps are lists that require a key-value relationship.

## How to Create a Map?

Maps in monkey are created by extending the Map class. The extended map class *MUST* implement the Compare method.
Maps are able to use any type, including objects.
The Compare method in Monkey returns a "0" if the values are equal, a "1" or greater if the values are higher, or a "-1" or less if the values are lower. Some objects are difficult to compare, but the method must return a value for each field needed in the key.
Maps are used with Get and Set methods.
Monkey includes built-in maps which offer use for setting objects, by using integer, floats, and strings as keys: IntMap, FloatMap, StringMap
# Mongolian/Numerals and Fractions

| English | Монгол | Transliteration |
| Zero | ᠐ Тэг | teg |
| One | ᠑ Нэг | neg |
| Two | ᠒ Хоёр | hoyor |
| Three | ᠓ Гурав | gurav |
| Four | ᠔ Дөрөв | dorov |
| Five | ᠕ Тав | tav |
| Six | ᠖ Зургаа | zourgaa |
| Seven | ᠗ Долоо | dolo |
| Eight | ᠘ Найм | naim |
| Nine | ᠙ Ес | yus |
| Ten | ᠑᠐ Арав | arav |
| Eleven | ᠑᠑ Арван нэг | arvan neg |
| Twelve | ᠑᠒ Арван хоёр | arvan hoyor |
# Mongolian/Lesson Five
## Dialogues

| Mongolian Dialogue • Lesson Five Directions |
| Жон | 1-р дэлгүүр хаана байдаг вэ? |
| Дорж | Тэр байшингийн баруун талд. |
| Жон | Миний ном ханна байна? |
| Дорж | Мэдэгүй |
Now use the same dialogue, but instead of asking for the дэлгүүр try asking for the сургууль, эмийн сан, байр, номын дэлгүүр or шуудан.

## Vocabulary

| Mongolian Vocabulary • Lesson Five Directions |
| store | делгүүр |
| building | байшин |
| drug store | эмийн сан |
| book store | номын делгүүр |
| post office | шуудан |
| right | баруун |
| side | тал |

## Grammar Explanation

Direction and location words like баруун тал require an appropriate suffix of genitive case to be added to the main words to which it refers.
* Example:
** Тэр байшингийн баруун талд.
** what building of right side on
** On the right side of that building.
# Monkey/Language
## Language
#### Core Topics

Some of these link to the BlitzMax WikiBook, as the Monkey language is the same as BlitzMax:
   * Constants
   * Strings
   * Collections
   * Literals
   * Conditional Compiling
   * Variables
   * Comments
   * Functions
   * Expressions
   * Slices
   * Debugging
   * Arrays
   * Modules
   * Data Types
   * Objects
   * BASIC Compatibility
   * Identifiers
   * Program Flow
   * User Defined Types
# Rust for the Novice Programmer/Pattern Matching
## Pattern Matching

So we have our AngleType enum that we created previously. Let's say we wanted to print out something explaining something about the angle. To change this based on the enum variant we encounter, we can use a match statement. For example:
If the angle type is the type described in each block, then we enter that one's braces and ignore all the other braces. For example, if we had a points where the angle_type was acute, we would only print out the acute angle section. Also notice that since the right angle has a boolean value attached, we can use a variable called axis_aligned which gets set to whatever that value is. We can then use it inside the braces to print more information about the angle. Note that we match all the variants of the enum. This is a requirement of the match statement. To demonstrate this, we can match against a number in the following function:
First note I don't have the braces on the lines. This is since we only have a single line after matching a number, so we can leave them out, but we must have the comma at the end of the line. This won't compile, since it doesn't know what to do if we get a number not 1, 2 or 6. If we want it to do nothing on receiving a number that doesn't have a fact, we can explicitly say that like so:
The underscore acts as a match all, and the empty braces indicate we don't want to do anything in this case. We can use the underscore in other places as well. Remember our is_angle_right function from the last page? For reference, here's what it was before:
This isn't valid anymore, since we could have AngleType::Right(true) or AngleType::Right(false). Instead of individually matching against both of these, we can change it to:
Also, what if we want to check do something only for a specific enum variant and use the inner value(s). A convenient way to describe this pattern is using 'if let'.
This is very convenient for describing this pattern and quite easy to read as well. There are many more enum and struct patterns as well as many ways to match against those patterns but these are the basic building blocks to organise and structure data in Rust.
Next: Basics of References and Borrowing
# Rust for the Novice Programmer/Numbers
## Numbers

Computers are great at handling numbers. Here, we will see how to do basic mathematical operations in Rust.
First, let's copy the steps from the previous page to ensure we have a clean slate to begin with:
* Make a new folder in your projects folder, call it something like "numbers"
* Open a terminal inside that new folder and type 'cargo init'
* Open src/main.rs in your text editor
Now to print out a number, we have to change the println!("Hello, world!"); line. To print out a number we will change it to
If we type 'cargo run' in the terminal now, we will see 5 in the terminal.
What is this? Note there aren't "" quotes around 5, that means it is a number. However, println! expects some text(normally called a 'string') inside it, so instead we put "" where the braces are a placeholder for the next input. That next input being the 5 we put after the comma. Thus, the 5 is printed to the terminal. This might seem odd but it is helpful for doing more complex things.
Now, what maths things can we do? The most obvious things to do are the basic operations: addition, subtraction, multiplication and division.
Addition is simple: put a + between two numbers, so
will print out 9 to the terminal. Subtraction is equally simple with a - between the numbers,
will print out 4 to the terminal.
Multiplication is the same idea, but uses the * symbol:
will print out 15 to the terminal.
Division uses the / symbol but functions a little strangely:
will print out 5 to the terminal.
However,
doesn't print out 2.5 but instead prints out 2. The reason for this will be explained later, but the mechanic is that the number is rounded down to the nearest whole number.
But this is quite inconvenient to include these calculations in the println! statements, what's a better way to organise our code?
Next: Variables
# Rust for the Novice Programmer/Numbers and data types
## Numbers and data types
##### Basic explanation of number representation

One thing to keep in mind is that at a fundamental level, all computers are doing are moving 1s and 0s around. We call a single value a 'bit'. Normally, computers are built to work in sections of 8 bits at a time and each one is called a 'byte'. The specifics of this aren't relevant right now, except that the number types in Rust are built using these bytes. The default number type is 'i32'. The i stands for integer, where an integer is a whole number(positive or negative), and the 32 is the number of bits used to represent this number, which is equivalent to 4 bytes. The integer types in Rust are 'i8', 'i16', 'i32' and 'i64', for each the number corresponds to the number of bits in it. There's also what are called unsigned integers which are integers that only represent positive values(including 0). Correspondingly, they are 'u8', 'u16', 'u32' and 'u64'.
Remember earlier where we said division was a little strange? How when we did 15/6 we got 2 out instead of 2.5? This is the reason, since the two numbers involved in the division are integers, the output will be an integer too. Since an integer can only store whole numbers, the output will not store the .5 extra. If we want values that can store decimals we use what are called floating-point numbers. These are numbers that store decimal values in them. In Rust, there are two floating point types, 'f32' and 'f64'. You can get a floating point easily by adding a .0 after a number. Note that the default floating-point type will be f64 in this case
For example:
Now the output we get is 2.5 as expected.
How do we choose a specific type that we want? We can do this by adding a colon then the type after the name as shown here:
Here we are using a 16-bit integer to store the value 7 then print it.
Why do we want different types? Rust is a language that allows you as the programmer quite a lot of control over what you are doing. Using smaller number types as needed can save space since fewer bits are used.
Next: Functions
# Rust for the Novice Programmer/Variables
## Variables

What if we wanted to not have the calculation inside the println! line.
To solve this, we can use variables. Variables allow you to store values for later use.
Here's an example:
First, 'let' is a special keyword that means the thing is a variable. 'number' here is the name of the variable so we can refer to it later. '=' shows we are putting in the variable. the 5 is the value we are putting in. This means that later when we put in 'number', it will refer to the number 5. The semicolon ; is as before, indicating the end of the line.
For example
will print out the 5 we put into 'number'.
Why is this good?
The advantage of this is now we have the value separated out it is easier to change. So we could change the line to
and the println line would print out the new value of number, which is 9.

#### Changing Variables

One interesting thing about Rust is that variables are immutable by default. This means they cannot be changed after being created. However, you can set a variable as mutable(able to be changed) by using the 'mut' keyword.
This will print out the value 8 since it overrides the value 5 and in fact the value 5 does absolutely nothing here. If you run this, the compiler will tell you 'warning: value assigned to `number` is never read' since it is quite smart but also quite pedantic in checking for strange things in your code.
If you did want to put the variable earlier but put the value later you could do this:
Note that number no longer needs to have 'mut' since it is only being set to a value once so it is not being changed. However, you cannot use it before you set a value to it. For example,
This will give you an error when you run 'cargo run' on it since the compiler works out number doesn't have a value in it when you try to print it.
Here are some things you can do with changing variables:
You can do mathematical equations in order:
Here we have a variable with the name 'x'. This is shorter and easier to type, but is less descriptive so might not tell you or other people what this number is for later. Also note we are using the last value of x each time we set the next value of x. This computes x$^2$ + 5 with x = 10, which gives 105. You can change the x value and it will compute the same equation for the different values of x.
One last thing for now: that x = x * number or x = x + number is quite a common thing to do, so there is a way to shorten this:
This program does the same thing. For the basic operations, you can use them with '=' to shorten it.
Next up: Comments