OpenLLM-France/wikimedia huggingface dataset:
# Bicycles/Maintenance and Repair/Tools and Supplies/Cable Cutter

Brake and derailleur cables are extremely difficult to cut with a standard pair of wire cutters (sometimes called side or diagonal cutters); when it is finally accomplished, this process usually leaves a frayed mess of the inner cable, which is impossible to slip through the cable housing or the hole in a fastening bolt. In addition, the jaws of these cutters are made for cutting copper electrical wire, and will become notched when cutting steel bicycle cables.
Cable cutters specifically designed for steel cable, on bicycles or elsewhere, are available at prices low enough to eliminate this nuisance. They are generally similar to regular cutters or scissors, but have extra-hard jaws, each of which carries a v-shaped notch. When cutting a cable, the notches overlap, trapping the cable in a diamond shaped hole with sharp edges, which becomes smaller as the handle is compressed, thereby cutting the cable easily without fraying and with no damage to the tool. They are also useful for cutting the cable housing, although they often close the inner sleeve, and it needs to be re-opened with a piece of cable or other means. Sometimes their use leaves a small burr on the housing which may need to be filed off.
# Bicycles/Maintenance and Repair/Shifters/Rapidfire Shifter Lubrication

Chapters: 01. Introduction 02. What Style of Riding is for Me 03. Equipment and Accessories
04. Riding tips and safety tips 05. Guide to safety 06. Maintenance and repair 07. Modifications External Links
This is for the Shimano A20 "rapidfire" shifter switch (on the handlebars) but a similar situation may exist for other brands/models. The shifter consists of two levers and an enclosed ratchet mechanism with pawls. If pushing on the lever fails to move the idler wheels of the derailleur (on the chain), then a likely cause is lack of lubrication. If the old lubricant gets hard, the pawls will stick.
So remove the switch and then remove a cover. Push-pull the pawl that's giving trouble with a small screwdriver and watch what happens. The pawls have tiny springs that push them into contact with a lugged wheel. If a pawl fails to maintain contact with the lugged (or notched) wheel, then, if the spring isn't broken, it can be fixed by lubing the pivot point of the pawl. Work the pawl back and forth with a small screwdriver, etc. right after applying a drop or two of lube oil. When the spring freely moves the pawl into contact with the lugged wheel, it's fixed.
# Bicycles/Maintenance and Repair/Tools and Supplies/Bottom Bracket Tapping and Facing Tool

This tool serves two purposes. First of all to recut and clean the threads in the bottom bracket shell of the frame. Secondly to face the edge of the bottom bottom bracket shell to ensure an even interface with the bottom bracket.
# Bicycles/Maintenance and Repair/Suspension/Front suspension lubrication

Chapters: 01. Introduction 02. What Style of Riding is for Me 03. Equipment and Accessories
04. Riding tips and safety tips 05. Guide to safety 06. Maintenance and repair 07. Modifications External Links
It is best to go to the webpage of your fork's manufacturer and look there for specific information regarding your model and type of suspension fork. If you don't want too much hassle, rather take your bicycle to qualified bicycle mechanic.
# Ad Hoc Data Analysis From The Unix Command Line/Standard Input, Standard Output, Redirection and Pipes

"This is the Unix philosophy: Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface."—Doug McIlroy, the inventor of Unix pipes
The commands I'm going to talk about here are called filters. Data passes through them and they modify it a bit on the way. These commands read data from their "standard input" and write data to their "standard output." By default, standard input is your keyboard and standard output is your screen. For example, the tr command is a filter that translates one set of characters to another. This invocation of tr turns all lower case characters to upper case characters:
Ctrl-d is how you tell the command from the keyboard that you're done entering input.
You can tell your shell to connect standard output to a file instead of your screen using the ">" operator. The term for this is "redirection". One would talk about "redirecting" tr's output to a file. Later you can use the cat command to write the file to your screen.
Many Unix commands that take a file as an argument will read from standard input if not given a file. For example, the grep command searches a file for a string and prints the lines that match. If I wanted to find my entry in the password file I might say:
But I could also redirect a file to grep's standard input using "<" operator. You can see that the "<" and ">" operators are like little arrows that indicate the flow of data.
You can use the pipe "|" operator to connect the standard output of one command to the standard input of the next. The cat command reads a file and writes it to its standard output, so yet another way to find my entry in the password file is:
For a slightly more interesting example, the mail command will send a message it reads from standard input. Let's send my entry in the password file to me in an email.

# Using output with headers

In many situations, you end up with output that has a first line that is a header describing the data, and subsequent lines that are the data. An example is ps:
If you wish to manipulate the data but not the header use tail with -n switch to start at line 2. For example:
This output shows only "bash" processes (because of grep)
← Preliminaries · Counting Part 1 - grep and wc →
# Ad Hoc Data Analysis From The Unix Command Line/Rewriting The Data With Inline perl
## Command Line perl

A tutorial on perl is beyond the scope of this document; if you don't know perl, you should learn at least a little bit. If you invoke perl like perl -n -e '#a perl statement' the -n option causes perl to wrap your -e argument in a implicit while loop like this:
This loop reads standard input a line at a time into the variable $_, and then executes the statement(s) give by the -e argument. Given -p instead of -n, perl to adds a print statement to the loop as well:

## Example - Using perl to create an indicator variable

Education level is recorded in columns 53-54 as ordered set of categories, where 11 and above indicates a college degree. Let's condense this to a single indicator variable for completed college or not. The raw data:
And once passed through the perl script:
And the final result:
About 36% of Washingtonians have a college degree.

## Example - computing conditional probability of membership in two sets

Let's look at the relationship between education level and whether or not people ride their bikes to work. People's mode of transportation to work is encoded as a series of categories in columns 191-192, where category 9 indicates a bicycle. We'll use an inline perl script to rewrite both education level and mode of transportation:
55/(55+36447) = 0.15% of non college educated people ride their bike to work. 111/(111+20219) = 0.56% of college educated people ride their bike to work.
Sociological interpretation is left as an exercise for the reader.

## Example - A histogram with custom bucket size

Suppose we wanted to take a look at distribution of personal incomes. The normal trick of sort and uniq would work, but the personal income in the census data has resolution down to the $10 level, so the output would be very long and it would be hard to quickly see the pattern. We can use perl to round the income data down to the nearest $10,000 on the fly. Before the inline perl script:
And after:
And finally, the distribution (up to $100,000). The extra grep [0-9] ensures that blank records are not considered in the distribution.

## Example - Finding the median (or any percentile) of a distribution

If we sort all the incomes in order and had a way to pluck out the middle number, we could easily get the median. I'll give two ways to do this. The first uses cat -n. If given the -n option, cat prepends line numbers to each line. We see that there are 46,359 non blank records, so the 23179th one in sorted order is the median.
An even simpler method, using head and tail:
The median income in Washington state in 2000 was $19,900.

## Example - Finding the average of a distribution

What about the average? One way to compute the average is to accumulate a running sum with perl, and do the division by hand at the end:
$1314603988/ 46359 = $28357.0393666818
You could also get perl to do this division with an END block which perl will execute only after it has exhausted standard input:
← Counting Part 2 - sort and uniq · Quick Plotting With gnuplot →
# Ada Programming/Ada 2022

This is an overview of the major features that are available in Ada 2022, the most recent version of the Ada standard.

## Summary of what's new
### New profile

Jorvik is a subset of the Ada tasking capabilities, similar to Ravenscar and which imposes fewer restrictions, removing the following ones compared to the Ravenscar profile:
* No_Implicit_Heap_Allocations
* No_Relative_Delay
* Simple_Barriers
* Max_Entry_Queue_Length => 1
* Max_Protected_Entries => 1
* No_Dependence => Ada.Calendar
* No_Dependence => Ada.Synchronous_Barriers

### New syntax

* Assignment target name @
* Square brackets for array aggregates
* Default initial conditions for types
* Default generic parameters
* Declare expressions
* Reduction expressions
* Iteration filters
* Generalized literals

### New keywords

* parallel

### New pragmas

* Admission_Policy
* All_Calls_Remote
* Conflict_Check_Policy
* Elaborate_Body
* Generate_Deadlines
* Preelaborable_Initialization
* Preelaborate
* Profile now supports the Jorvik profile
* Pure
* Remote_Call_Interface
* Remote_Types
* Shared_Passive

### New aspects

* Aggregate
* Allows_Exit
* Default_Initial_Condition
* Dispatching
* Elaborate_Body
* Full_Access_Only
* Global
* Global'Class
* Integer_Literal
* Iterator_View
* Max_Entry_Queue_Length
* No_Controlled_Parts
* No_Return (for functions)
* Nonblocking
* Parallel_Calls
* Parallel_Iterator
* Preelaborable_Initialization
* Put_Image
* Real_Literal
* Relative_Deadline
* Stable_Properties
* Stable_Properties'Class
* Static
* Static_Predicate
* String_Literal
* Synchronization
* Use_Formal
* Yield

### New attributes

* 'Enum_Rep
* 'Enum_Val
* 'Index
* 'Object_Size
* 'Parallel_Reduce
* 'Preelaborable_Initialization
* 'Put_Image
* 'Reduce
* 'Relative_Deadline

### New packages

* Atomic_Operations:
** System.Atomic_Operations.Exchange
** System.Atomic_Operations.Test_And_Set
** System.Atomic_Operations.Integer_Arithmetic
** System.Atomic_Operations.Modular_Arithmetic
* Big Numbers:
** Ada.Numerics.Big_Numbers.Big_Integers
** Ada.Numerics.Big_Numbers.Big_Reals
* Containers:
** Ada.Containers.Bounded_Indefinite_Holders

## See also
### Wikibook

* Ada Programming/Ada 83
* Ada Programming/Ada 95
* Ada Programming/Ada 2005
* Ada Programming/Ada 2012
# Ada Programming/Ada 80

Ada 80 was a preliminary version of the Ada programming language. The Military Standard reference manual was approved on December 10, 1980 (Ada Lovelace's birthday), and given the number MIL-STD-1815 in honor of Ada Lovelace's birth year.
The Ada 83 standard, MIL-STD-1815A, was later derived from Ada 80.
Ada 80 is just interesting from a historic point of view, there is no code that must conform with this standard.

## Summary of features
### Pragmas

* pragma Controlled
* pragma Include (not in Ada 83)
* pragma Inline
* pragma Interface
* pragma List
* pragma Memory_Size
* pragma Optimize
* pragma Pack
* pragma Priority
* pragma Storage_Unit
* pragma Suppress
* pragma System_Name (named System in Ada 83)
The following pragmas were not defined in Ada 80, but were later added in Ada 83:
* pragma Elaborate (Ada 83 only)
* pragma Page (Ada 83 only)
* pragma Shared (Ada 83 only)

### Attributes

* Actual_Delta (not in Ada 83)
* Address
* Base
* Bits (not in Ada 83)
* Constrained
* Count
* Delta
* Digits
* Emax
* Epsilon
* Failure (not in Ada 83)
* First
* First_Bit
* Image
* Large
* Last
* Last_Bit
* Length
* Machine_Emax
* Machine_Emin
* Machine_Mantissa
* Machine_Overflows
* Machine_Radix
* Machine_Rounds
* Mantissa
* Pos
* Position
* Pred
* Priority (not in Ada 83)
* Range
* Size
* Small
* Storage_Size
* Succ
* Terminated
* Val
* Value
The following attributes were later added to Ada 83:
* Aft (Ada 83 only)
* Callable (Ada 83 only)
* Fore (Ada 83 only)
* Safe_Emax (Ada 83 only)
* Safe_Large (Ada 83 only)
* Safe_Small (Ada 83 only)
* Width (Ada 83 only)

## See also
### Wikibook

* Ada Programming/Ada 83
* Ada Programming/Ada 95
* Ada Programming/Ada 2005
* Ada Programming/Ada 2012

## References

* DoD (1980). The Programming Language Ada Reference Manual — Proposed Standard Document United States Department of Defense. Retrieved 2008-06-06. {{cite book}}: Unknown parameter |month= ignored (help)

## External links

* History of the Ada Programming Language
* The naming of Ada (January 1983)
* The History of Ada (March 1984)
* DoD's Common Programming Language Effort
* Ada—the project: the DoD high order language working group
* Introducing Ada
* The Department of Defense software initiative—a status report
* Ada: past, present, future
* The ACM position on standardization of the Ada language
* A Language is Born: Ada, IEEE Computer (November 1981) p. 123 — Advertisement about Ada 80 books
* Ada, an analyst and a metaphysician (March 1991)
# Ad Hoc Data Analysis From The Unix Command Line/Quick Plotting With gnuplot
## Example - creating a scatter plot

Does the early bird get the worm? Let's look at the relationship between the time a person leaves for work and their income. Income is recorded in columns 297-303, and the time a person leaves for work is recorded in columns 196-198, encoded in ten minute intervals. This pipeline extracts, cleans and formats the data:
The greps knock out records for which either field is null, and the perl script inserts a space between the two columns so gnuplot can parse the columns apart. Plotting in gnuplot is simple:
And the resulting plot:
Recall that 0 on the x-axis is midnight, and 20 is 200 minutes after midnight or about 3:20am. Increased density in the beginning of the traditional 1st and 2nd shift periods is apparent. Folks who work regular business hours clearly have higher incomes. It would be interesting to compute the average income in each time bucket, but that makes a pretty hairy command line perl script. Here is it in all its gruesome glory:
You can plot the result for yourself if you're curious.

## Example - Creating a bar chart with gnuplot

Let's look at historic immigration rates among Washingtonians. Year of immigration is recorded in columns 78-81, and 0000 means the person is a native born citizen. We can apply the usual tricks with cut, grep, sort, and uniq, but it's a bit hard to see the patterns when scrolling back and forth in text output, it would nicer if we could see a plot.
Gnuplot is a fine graphing tool for this purpose, but it wants the category label to come first, and the count to come second, so we need to write a perl script to reverse uniq's output and stick the result in a file. See perlrun(1) for details on the -a and -F options to perl.
Now we can make a bar chart from the contents of the file with gnuplot.
Here's the graph gnuplot creates:
Be a bit careful interpreting this plot, only people who are still alive can be counted, so it naturally goes up and to the right (people who immigrated more recently have a better chance of still being alive). That said, there seems to have been an increase in immigration after the end of World War II, and also a spike after the end if the Vietnam war. I remain at a loss to explain the spike around 1980, consult your local historian.

## External links

* http://gnuplot.sourceforge.net/demo/
set term win; set grid;A1=-300;A2=250;n=360;z=2500;splot(x**2)/(A1**2) + (y**2)/(A2**2) - ((2*x*y)/(A1*A2))*cos(n-z) - (sin(n-z))**2
← Rewriting The Data With Inline perl · Appendices →
# A Quick Introduction to Unix/Pathnames

* Components
* Shells and subshells
* Directory Structure
* Changing Directories
* Listing Files and Directories
* Pathnames
* Files and Processes
* Wildcards
* Exercises 1
* Creating Directories
* Creating Files
* Special Directories
* Exercises 2
* Copying Files
* Moving Files
* Deleting Files
* Exercises 3
* Redirection
* Searching Text Files
* More grep examples
* Permissions on Files and Directories
* Editing Text
* Exercises 4
* My First Shell Script
* Job Control
* Links
* Environment Variables

## Pathnames
### pwd (print working directory)

Pathnames tell you where you are in the whole file-system. So, to find out the pathname to your home-directory, type cd ~ to get back to your home and then
The full pathname looks something like this -
/home/nfs/fs-i/UM0098/ccaajim
which means that ccaajim (your home directory) is in the sub-directory UM0098 (the group directory),which in turn is located in the fs-i sub-directory, which is in the nfs sub-directory, which is in the top-level root directory, called / (pronounced root) .

### Home directories and pathnames
#### Understanding pathnames

In some Unix systems (including socrates on WTS) you will find it necessary to prefix pathnames with ~ if you want to ensure that they start from your home directory rather than the current directory or the root.
First use cd to get back to your home-directory, then type
to list the contents of your mytraining directory.
Now type
You will get a message like this -
archive: No such file or directory
The reason is that archive is not in your current working directory. To use a command on a file (or directory) that is not in the current working directory, you must either cd to the correct directory, or specify its full pathname. To list the contents of your archive directory you must type
Since here the path is quite straightforward and relatively easy to type, using the full pathname will work reasonably well. It might be however, that the path is not so straightforward and then you will find the ~ abbreviation useful.

#### ~ (your home directory)

Your home directory can also be referred to by the tilde ~ character. It can be used to specify paths starting at your home directory. So typing
will list the contents of your mytraining directory, no matter where you currently are in the file system.
What do you think
would list?
# A Quick Introduction to Unix/TOC

* Components
* Shells and subshells
* Directory Structure
* Changing Directories
* Listing Files and Directories
* Pathnames
* Files and Processes
* Wildcards
* Exercises 1
* Creating Directories
* Creating Files
* Special Directories
* Exercises 2
* Copying Files
* Moving Files
* Deleting Files
* Exercises 3
* Redirection
* Searching Text Files
* More grep examples
* Permissions on Files and Directories
* Editing Text
* Exercises 4
* My First Shell Script
* Job Control
* Links
* Environment Variables
# A Quick Introduction to Unix/Searching Text Files

* Components
* Shells and subshells
* Directory Structure
* Changing Directories
* Listing Files and Directories
* Pathnames
* Files and Processes
* Wildcards
* Exercises 1
* Creating Directories
* Creating Files
* Special Directories
* Exercises 2
* Copying Files
* Moving Files
* Deleting Files
* Exercises 3
* Redirection
* Searching Text Files
* More grep examples
* Permissions on Files and Directories
* Editing Text
* Exercises 4
* My First Shell Script
* Job Control
* Links
* Environment Variables

## Searching the contents of a file
### Simple searching using less

Using less, you can search though a text file for a keyword (pattern). For example, to search through science.txt for the word science, type
This writes the first screenfull of the file to the screen. While still in less, you can type a forward slash / followed by the word to search
As you can see, less finds and highlights the keyword. Type n to search for the next occurrence of the word.
This is useful but relatively limited and inflexible. It is not hard to imagine simple situations where you might want to quickly check the contents of a file (is this the essay where I talked about left recursion?). But we often want to do just a bit more. That is where the very famous Unix utility grep comes in.

### grep

grep is one of many standard Unix utilities. It searches files for specified words or patterns. First clear the screen (type clear at the prompt), then type
As you can see, grep has printed out each line containing the word science but it is case sensitive. If we type
we see it is distinguishes between Science and science. To ignore upper/lower case distinctions, use the -i option, i.e. type
To search for a phrase or pattern (i.e. a string of characters with a space in it) you must enclose it in single quotes. For example to search for current domain, type
Some of the other options for grep are:
| grep option | effect |
| -v | display those lines that do NOT match |
| -n | precede each matching line with the line number |
| -c | print only the total count of matched lines |
Try some of them and see the different results. Don't forget, you can use more than one option at a time. For example, the number of lines without the words science or Science is
grep is one of the most powerful Unix utilities. There are extensions such as egrep as well. A good knowledge of the power of grep can make you a very productive Unix user. This is however a quick introduction and so this is all are going to cover.

### wc (word count)

A handy little utility is the wc command, short for word count. To do a word count on science.txt, type
To find out how many lines the file has, type
# To Do List for A Quick Introducton to Unix wikibook

While the individual sections of the book are near complete, some additions are called for.
* Environment Variables
* Getting Help (use of man and info etc)
* Root Access (sudo / su etc. what is root)

# To be added for RITS

Before RITS training shell, stdin stdout stderr export and shell variables basic commands file structure heredoc redirection piping text editing a .sh file
* Elaborate on the shell - variables and process. Theory/philosophy. Multiple shells.
** exporting
* Command history
* Tab completion, last argument etc.
* elaborate piping. add tee.
* $editor in .bashrc
# A Quick Introduction to Unix/Wildcards

* Components
* Shells and subshells
* Directory Structure
* Changing Directories
* Listing Files and Directories
* Pathnames
* Files and Processes
* Wildcards
* Exercises 1
* Creating Directories
* Creating Files
* Special Directories
* Exercises 2
* Copying Files
* Moving Files
* Deleting Files
* Exercises 3
* Redirection
* Searching Text Files
* More grep examples
* Permissions on Files and Directories
* Editing Text
* Exercises 4
* My First Shell Script
* Job Control
* Links
* Environment Variables

## Wildcards

A wildcard is a character that can stand for all members of some class of characters. When you use a wildcard the computer systems substitutes the members of the class for the wildcard character. The examples below will make this clearer. We will use the command ls for illustration.

### The * wildcard

The character * is a wildcard and matches zero or more character(s) in a file (or directory) name. For example, in your mytraining directory, you might type
This will list all files in the current directory starting with list.
You could type
This will list all files in the current directory ending with list.

### The ? wildcard

The character ? will match exactly one character.
So ?ouse will match files like house and mouse, but not grouse.
An example use of this syntax is: