OpenLLM-France/wikimedia huggingface dataset:
# Music/Software/Ableton Live
## Introduction

This course is aimed at getting participants producing music using Ableton's 'Live' software within ten core modules. Following the core modules will be a series of skill development modules accompanied by appropriate theory, practical exercises and example projects.
The core modules with brief outlines are as follows:
/Setting Up - This module covers installation, setup, file organization and some basics on music production software in general.
/Navigation (GUI) - This module outlines the Graphical User Interface and builds familiarization with the program layout.
/Audio - This module demonstrates how to record, edit and manipulate audio within 'Live'.
/MIDI - This module provides an introduction to MIDI (Musical Instrument Digital Interface) including how to record, edit and manipulate it within 'Live'.
/Virtual Instruments - This module takes a look at the range of virtual instruments in 'Live', demonstrates their various capabilities and proposes some ideas on their use.
Plug-ins - This module covers the purpose, use and manipulation of both audio and MIDI Plug-Ins within 'Live'.
Session View - This module deals with the unique 'Clip' view in 'Live', looking at how it can be used to organize, manipulate and perform components of a song.
Arrange View - This module looks at how to turn your song components into an arrangement.
Editing - This module outlines the core techniques for editing arrangements in 'Live'.
Live - The final core module demonstrates how to make the most of the unique features and work environment which 'Live' offers.
Throughout the core classes students will be encouraged to assimilate their new learning and practical skills into a musical project. On completion of the ten modules participants will have created a piece of music and be capable of producing further work using the software.
The extended modules and brief outlines are as follows:
# Multivariate statistics

This statistics resource is a "stub". Learn how you can help Wikiversity to develop it.
Multivariate statistics involve three of more variables.
Examples of commonly-used multivariate statistical techniques are:
* factorial ANOVAs
* multiple linear regression.
# Pragmatics/History/1910s

* Before
* 1600s
* 1700s
* 1800s
* 1900s
* 1910s
* 1920s
* 1930s
* 1940s
* 1950s
* 1960s
* 1970s
* 1980s
* 1990s
* 2000s
* 2010s

## 1910s
### 1911 Welby

* Welby, Victoria Lady (1911). Significs and Language: The Articulate Form of Our Expressive and Interpretive Resources. H. Walter Schmitz, ed., John Benjamins, 1985. $^{[^]}$

### 1916 Saussure

* Literature/1916/Saussure $^{[^]}$
# Pragmatics/History/1600s

* Before
* 1600s
* 1700s
* 1800s
* 1900s
* 1910s
* 1920s
* 1930s
* 1940s
* 1950s
* 1960s
* 1970s
* 1980s
* 1990s
* 2000s
* 2010s

## 1600s
### Locke

   Men content themselves with the same words other people use, as if the very sound carried the same meaning.
This is included in the opening quotations of 1923/Ogden.
This could be such an allusion that:
   Men content themselves with the same words other people use, as if the very sound (say, of the bible) carried the same meaning.
# Pragmatics/History/1700s
## 1700s
### 1706 Locke

* Of the Conduct of the Understanding
   Whether it be a love of that which brings the first light and information to their minds and want of vigor and industry to enquire, or else that men content themselves with any appearance of knowledge, right or wrong, which when they have once got they will hold fast, this is visible, that many men give themselves up to the first anticipations of their minds and are very tenacious of the opinions that first possess them. They are often as fond of their first conceptions as of their first born, and will by no means recede from the judgment they have once made or any conjecture or conceit which they have once entertained. This is a fault in the conduct of the understanding, since this firmness or rather stiffness of the mind is not from an adherence to truth but a submission to prejudice. It is an unreasonable homage paid to prepossession, whereby we show a reverence not to (what we pretend to seek) truth, but what by haphazard we chance to light one be it what it will. This is visibly a preposterous use of our faculties and is a downright prostituting of the mind to resign it thus and put it under the power of the first comer. This can never be allowed or ought to be followed as a right way to knowledge, till the understanding (whose business it is to conform itself to what it finds on the objects without) can by its own opiniatrety change that and make the unalterable nature of things comply with its own hasty determinations, which will never be. Whatever we fancy, things keep their course, and their habitudes, correspondences and relations keep the same to one another.
   — From Anticipation
# Pragmatics/History/1900s

* Before
* 1600s
* 1700s
* 1800s
* 1900s
* 1910s
* 1920s
* 1930s
* 1940s
* 1950s
* 1960s
* 1970s
* 1980s
* 1990s
* 2000s
* 2010s

## 1900s
### 1903 Welby

* Literature/1903/Welby $^{[^]}$

### 1905 Russell

* Russell, Bertrand (1905). "On Denoting." Mind, vol. 14, pp. 479-493. $^{[^]}$
# Software Design/Truthfulness

Truthfulness and trustworthiness are interface and software qualities that reflect the accuracy of names of operations: do they always do what their names say?
If the software (a library or a framework) is known to have a lot of bugs, developers who code against it may stop trusting it performs its functions correctly and apply techniques of defensive programming when interacting with it.

## Relations to other qualities

* Cognitive load
* Security
* Mistake tolerance
# Software Design/Use class instead of primitive type

Checklist questions:

## Why

The greater apparency of semantics of function parameter declarations, variable declarations, and function return types.
The smaller probability to make a programming mistake by passing a wrong argument to the function (interface robustness), or returning a wrong variable from the function, or using a wrong variable in an expression (code robustness).
Certain operations on quantities sensitive to the accuracy can be prohibited or fail fast: for example, when a money amount cannot be divided without a remainder by the specified value, or when a single 64-bit value cannot hold the requested amount without integer overflow, an exception could be raised. Equivalent functions could be defined on the primitive numeric types as well (or already present in the standard library), but it may be not possible to enforce their usage even with static analysis rules within the existing static analysis frameworks.

## Why not

In languages that don't support type aliases (for example, Java), using objects instead of primitive types negatively affects the performance and memory usage of the program.
In languages that don't support operator overloading manipulating with variables of quantity classes instead of primitive numeric variables can reduce the clarity and the naturality of the expression.

## Related

* Add unit suffix to variable name
# Software Freedom/Computation

The goal of this section is to introduce students to the idea of software and hardware and to the basic concepts and practice of computation and programming.

## Explorations and Activities

The following activities or explorations might help students explore and discover key concepts in this section. Each is framed in terms of the key questions it raises.
Large parts of this process can be skipped or augmented if the students already have a programming background through other means.

### Exploration: What Are Computers?

An introductory activity or discussion that asks students to define and discuss computers.
Students should be asked to discuss their preconceptions (and misconceptions) of computers as as group. Discussion might be prompted with questions including any of the following:
* What do computers do? What do they not do?
* What can computers do? What can't they do?
* How are computes similar to and different from other types of machines?
* How are computers similar to or different from calculators?
Ideally, this discussion should lead students to identify computers with information processing. It should lead them to think critically about the role of computers as information storage, processing, and control machines.

### Activity: First Steps In Programming

An activity that walks students through the use of a simple programming tool.
Rather than writing yet another Introduction to Programming curriculum, this set of activities will be best served by borrowing from and using another curriculum.
Ideal programming environments and curriculum should be simple, short, an accessible. Many students without programming experience will be best suited by a visual programming tool. The ultimate goal is to introduce students to the concepts and practice of computation and programming and not the concepts of source code, object code, or the mechanics of writing in a particular language. Ideal choices of languages and environments might include any of the following:
* Squeak
* Scratch
* StarLogo
In addition the process of teaching the students the first steps of writing a computer program, students should be asked to present and compare their projects to the class. Discussion on these programs should be encouraged and students should be prompted to connect their work to the practice of programming and computers more generally -- as discussed in the exploration above.

## Key Concepts

Students should be able to connect work in this section to their previous explorations of information. Additionally, they should walk away from this section with:
* The ability to write a simple program in a programming language like Squeak, Scratch or StarLogo.
* Some introductory skill or familiarity at using the tools and methods of computation and programming.
* Knowledge and awareness by each student that they have reprogrammed their computer to do something that it could not do before or without their intervention. In other words, knowledge of the computer as a computing machine and their own ability to become the director of that machine.
# Software Freedom/Context

The goal of this section is to encourage students to think of computation as a tool that has built their computer system and that, now that is demystified and -- to some extent -- brought under student's control, has demystified their system more generally.

## Explorations and Activities

The following activies or explorations might help the students explore and discover the key concepts in this section. Each is framed in terms of the key questions it raises.

### Exploration: What is Software?

A project or discussion that prompts students to discuss "software" and its role on their computer.
Questions might include:
* What is software? What is hardware? How do the two differ?
* What is an Operating System? What are applications?
* Is the software that runs on their computer fundamentally different than the software they wrote in Squeak in Software Freedom/Computation? Why or why not?

### Exploration: Extending Software

An activity where students are shown how to script, build upon, or change an element or set of elements of their operating system and its applications. Students should be allowed some time to work on this then should present their modifications of their system to class.
Ideally, the students should be able to transfer and share their changes with other students. One intriguing possibility is to create a space fo iterative development where students can improve on each others projects and ideas and work together to combine creations with important synthetic possibilities.
At some point (perhaps in a different activity), the instructor should explain and demonstrate the way that all software in a computer can be changed via this method -- although access to change somethings can be turned off. The details (e.g., source code, binary code, compilation, obfuscation, etc.) need not be dealt with explicitly.
Students should be encouraged to discuss the limits of what they can and cannot change about their system.

## Key Concepts

Students could walk away from this section with:
* Hands on experience changing something about their computer that, normally, they would assume as static.
* The ability to imagine themselves taking a design role in their operating system and in taking over some important piece of development.
* Reflection, on some level, of the fact that they have transcended their role as the "consumer" of software.
# Software Design/Use compound operations on map objects

Checklist questions:
Maps (dictionaries, associative containers) in many programming languages support compound operations that replace sequences of "primitive" operations like getting a value by a key, putting a value for a key, and removing a key from the map.
* In Java, there are Map.putIfAbsent, compute, merge, etc.
* In C#, there are IDictionary.TryAdd and Remove(key, value).
* In C++, there are emplace, try_emplace, insert_or_assign, etc. in map and unordered_map containers.

## Why

Using compound map operations results in shorter, clearer and less error-prone code because the key is passed as an argument only once:
The semantics of a compound map operation are more apparent than the semantics of a series of "primitive" map operations.
Compound operations might also be faster than equivalent series of "primitive" operations because the implementations can perform only a single lookup in the map during the compound operation.
In concurrent code, using compound, "atomic" updates to a map becomes not just a matter of good style but also of the correctness of the program. For example, see a corresponding item in the Java concurrency checklist.

## Why not

Some compound operations on maps accept function objects (see, for example, Map.compute in Java). These function objects may be allocated on heap and may later need to be cleaned up by the garbage collector. This may be undesirable in some applications, e. g. those targeting nearly zero garbage allocation rate.

## Static enforcement
### Structural search in IDEs on the IntelliJ platform (Java, C#, C++)

Structural search in IDEs on the IntelliJ platform allows to catch series of map operations which could be replaced by compound operations.
Pattern to find code replaceable with Map.putIfAbsent or computeIfAbsent in Java:
It's possible to turn a structural search pattern into an inspection.
# Software Design/Validate data during object construction

Checklist questions:

## Why

Don't allow bad data to silently propagate through (and outside of) the system: be written to a database, sent to another service, which has the potential to destabilize the system and thus making it less mistake tolerant and fault tolerant. Allowing erroneous data to stay in the system for longer also undermines debuggability of the code and traceability of (faulty) behavior in the system.

## Why not

Data validation consumes CPU resources, while the data validation might be already validated elsewhere if the object is created within the trust boundary for the data. The compromise solution, in this case, may be to use assertions to avoid validating data repetitively in the production environment, but retaining an option to enable them during testing or a debugging session.

## Related

* Expose static factory functions instead of constructors
# Software Design/Use a single term to point to a concept

Checklist questions:

## Why

* Easiness of change (easier to find all places related to the concept that may need to be changed)
* Discoverability (easier to find all places related to the concept in the codebase)
* Apparency of semantics, structuredness, and steepness of learning curve: readers identify the concept quicker
# Software Engineering Process

    This description does not account for any software engineering standards, like IEEE, RUP, CMM, CMMI, etc. For a more complete description, see the Wikipedia description.
School of Computer Science > Software Engineering Process
Many people think that the creation of software should take place (or does take place) according to a process. A process is a series of steps or a way of going about something.
A number of software engineering processes have been suggested or articulated. Some of them are:
* extreme programming
* agile methods
* OO design
* hacking
* top down design
* test driven development
* waterfall model
* spiral model
* prototyping
* high production
* pinexse

## Readings
### Wikipedia

* Software development process
* Software development
* Software engineering
* History of software engineering
* Outline of software engineering
* Software architecture
* Computer programming
* Software design
* Software construction
* Software testing
* Program analysis
* Software maintenance
* Software engineering demographics
* Software craftsmanship
* List of software engineering conferences
* Software Engineering Institute
* Bachelor of Software Engineering

### Wikibooks

* Introduction to Software Engineering

### External

* Software Engineering Processes
* U.S. Department of Education's list of recognized institutions offering a degree program in Computer Software Engineering
# Open subscheme/Affine and extended ideal/Finitely generated/Fact/Proof

We only give a sketch. (1). There always exists a natural scheme morphism
    $U\longrightarrow \operatorname {Spec} {\left(\Gamma (U,{\mathcal {O}}_{X})\right)},$
and $U$ is affine if and only if this morphism is an isomorphism. It is always an open embedding (because it is an isomorphism on the $D(f)$, $f\in {\mathfrak {a}}$), and the image is $D({\mathfrak {a}}\Gamma (U,{\mathcal {O}}_{X}))$. This is everything if and only if the extended ideal is the unit ideal.
(2). We write $1=q_{1}f_{1}+\cdots +q_{n}f_{n}$ and consider the natural morphism
    $U\longrightarrow \operatorname {Spec} {\left(R[q_{1},\ldots ,q_{n}]\right)}$
corresponding to the ring inclusion $R[q_{1},\ldots ,q_{n}]\subseteq \Gamma (U,{\mathcal {O}}_{X})$. This morphism is again an open embedding and its image is everything.
# Open web publishing
## Concepts

* Open Source
* World Wide Web
* Publishing
A medium like web publishing has practically no barriers to entry and anybody can publish anything. There's a multitude of tools, platforms and networks which support open web publishing. Many free web hosted services have come to be known as Web 2.0 technologies, a second generation of web applications that enable any person to publish online with relative ease, form social networks and participate in open web environments with people all over the world. It's largely due to the success of free and easy to use tools that has led to wide adoption of open web publishing including but not limited to literary works, musical works, software and other works dealing with information, including electronic media.

## Copyright

Works published on the open web are protected by national and international copyright laws. Works are usually owned by the author or publisher. Open web publishing has empowered people to publish their own works, and it is common for the author to be the publisher. With many people wanting to share their creativity and allow their work to be reused, remixed and built upon, there is a choice of copyright licenses.
Widely used copyright licenses for publishing on the open web:
* Creative commons
* GNU Licenses
* Public domain

## Examples of open web publishing services

* Wikipedia - free encyclopedia that anyone can edit
* YouTube - video sharing website
* Blogger - blog creation and hosting service
* Del.icio.us - social bookmarking web service
* Digg - non-hierarchical, democratic editorial control

## Examples of web based publishing FOSS

Some popular examples of web based publishing tools available as free web hosted services and available as FOSS for download to run on your own server.
* WordPress - Blogging platform
* MediaWiki - Wiki platform
* Plone - Content managment system
* Moodle - learning managment system

## Related news

* April 11, 2007 - PLoS calls for volunteers...
* July 31, 2008 - Open Access Doesn’t Drive Citations
# Open university

The Free Software Foundation (FSF; initiated by Students for Free Culture (SFC)) define an open university as one in which:
* The research produced is open access;
* The course materials are open educational resources;
* The university embraces free software and open standards;
* The university’s patents are readily licensed for free software, essential medicine, and the public good;
* The university’s network reflects the open nature of the Internet.
The FSF goes further, to list specific criteria for each of these open university principles and university-rankings based on their degree of openness: Open University Report Cards.
# Open subscheme/Affine and extended ideal/Finitely generated/Fact

Let $R$ be a noetherian ring and $U=D({\mathfrak {a}})\subseteq \operatorname {Spec} {\left(R\right)}$ an open subset. Then the following hold.
* $U$ is an affine scheme if and only if ${\mathfrak {a}}\Gamma (U,{\mathcal {O}}_{X})=(1)$.
* If this holds, and $q_{1}f_{1}+\cdots +q_{n}f_{n}=1$ with $f_{1},\ldots ,f_{n}\in {\mathfrak {a}}$ and $q_{i}\in \Gamma (U,{\mathcal {O}}_{X})$, then $\Gamma (U,{\mathcal {O}}_{X})=R[q_{1},\ldots ,q_{n}]$. In particular, the ring of global sections over $U$ is finitely generated over $R$.
# Open subscheme/Affineness/Varying with base/Introduction/Section

We consider a base scheme $B$ and a morphism
    $Z\longrightarrow B$
together with an open subscheme $W\subseteq Z$. For every base point $b\in B$ we get the open subset
    $W_{b}\subseteq Z_{b}\,$
inside the fiber $Z_{b}$. It is a natural question to ask how properties of $W_{b}$ vary with $b$. In particular, we may ask how the cohomological dimension of $W_{b}$ varies and how the affineness (the cohomological dimension of a scheme $X$ is the maximal number $i$ such that $H^{i}(X,{\mathcal {F}})\neq 0$ for some quasicoherent sheaf ${\mathcal {F}}$. A noetherian scheme is affine if and only if its cohomological dimension is $0$. Tight closure can be characterized by the cohomological dimension of torsors.). may vary.
In the algebraic setting, we have a commutative $K$-algebra $D$, a commutative $D$-algebra $S$ and an ideal ${\mathfrak {a}}\subseteq S$ (so $B=\operatorname {Spec} {\left(D\right)}$, $Z=\operatorname {Spec} {\left(S\right)}$ and $W=D({\mathfrak {a}})$) which defines for every prime ideal ${\mathfrak {p}}\in \operatorname {Spec} {\left(D\right)}$ the extended ideal ${\mathfrak {a}}_{\mathfrak {p}}$ in $S\otimes _{D}\kappa ({\mathfrak {p}})$. Then in this situation, $D({\mathfrak {a}}_{\mathfrak {p}})\subseteq \operatorname {Spec} {\left(S\otimes _{D}\kappa ({\mathfrak {p}})\right)}$ is the fiber over ${\mathfrak {p}}$.
This question is already interesting when $B=\operatorname {Spec} {\left(D\right)}$ is an affine one-dimensional integral scheme, in particular in the following two situations.
* $B=\operatorname {Spec} {\left(\mathbb {Z} \right)}$. Then we speak of an arithmetic deformation and want to know how affineness varies with the characteristic and what the relation is to characteristic zero.
* $B={\mathbb {A} }_{K}^{1}=\operatorname {Spec} {\left(K[t]\right)}$, where $K$ is a field. Then we speak of a geometric deformation and want to know how affineness varies with the parameter $t$, in particular how the behavior over the special points where the residue class field is algebraic over $K$ is related to the behavior over the generic point.
It is fairly easy to show that if the open subset in the generic fiber is affine, then also the open subsets are affine for almost all special points.
# Open teaching
## Suggested readings

* Visualing open/networked teaching, Alec Courosa, Feb 19, 2009
* Visualing open/networked teaching revisited, Alec Courosa, May 4, 2009
# Pump's free delivery

In pumps a specific flow rate is called pump's free delivery.
It will occur when pump's net head is zero.
This flow rate is the maximum flow rate through a pump.

## Question

* At what pump head value, maximum volume flow rate will occur?
* Does pump's free delivery is a name to indicate a specific flow rate?

## Answers

* At net head of pump = 0
* Yes