OpenLLM-France/wikimedia huggingface dataset:
# Common Lisp/Basic topics/Lists

    This module is far from finished. Improvements are welcome.
Lists in common lisp are built up from pairs called cons cells. Each cell has two parts, historically named car (for the first part) and cdr (for the remainder).
Lists are implemented with cons cells by having the cdr of the first cell point to another cons cell.
The empty list is also known as nil, it's written representation is either the literal nil or the empty list:.
You can create a list by using cons to construct a new cons cell with a left and right hand part:
Keep in mind that it is possible to create a cons cell which is not a list:
This is called a dotted list. To be a proper list, the final cdr in the chain of cons cells must point to the empty list (nil). You can also create a list with the function list:
which is equivalent to:
You can access the members of a list with the functions car (or first) and cdr (or rest):
Common Lisp also defines the functions second, third and fourth (on up to tenth). Note that second is not the same as cdr or rest. cdr and rest both return the remaining list after the first element, while second returns the second item in the list:
Lists are sequences, so functions that operate on sequences also operate on lists:
The function nth also allows you to retrieve selected items from a list:
Note that the first item in a list is the 0th. Common Lisp also has several forms (functions and macros) for operating on the contents of lists. mapcar can be used to process each element of a list one at a time to build up a new list:
In that example, we were mapping over a single list so we used a unary function (a function of one argument). The #' is a special way to pass a function as an argument into a function. We will talk more about it in the next chapter. It is also possible to map over more than one list - the function must then take the same number of arguments as there are lists:
# Common Lisp/Advanced topics/Numbers/Example 1

Problem: given a function f defined on complex numbers and a square area that contains only one root of the function, find this root.
We will use residue theorem for the function 1/f(x). First we need to be able to calculate integrals on a square path.
The main loop could be made more concise with the use of extended loop syntax. The above function is very procedural in nature. You would use the same algorithm in C-like programming languages. Still, Lisp has a little advantage due to its native complex number support and the fact that case returns value, unlike switch in C.
Note the use of float function that converts the result of division to float. Without it, Lisp would operate with rational numbers, and the result won't be pretty (unless you find rationals with 1000-digit denominators pretty). As soon as the function is loaded into Lisp, you can test it:
This correlates with the theory that predicts 2πi being the result.
Now, the corollary of the residue theorem states that there is a pole in the area iff the path integral that goes around that area is not zero. We can write a simple function on top of the previous one that provides what we need:
The return value would be useful in the recursion-terminating case of the next function, which divides a square into 4 smaller squares and uses indirect recursion to complete its task.
Now, this is an example how functional programming can save lines of code. We define a small helper function that uses its lexical environment to know the values of f, start, h and precision, so the only thing we need to pass to it is the upper-right corner of the square. The power of or macro saved some superfluous branching as well. This function, while elegant, is quite hard to understand. It's a good exercise to work out what do check-pole and find-pole return in different situations and how their return values affect the control flow.
Finally, to find a root of function f we need to find a pole of 1/f. This is quite easy to do.
Let's test it. f(x)=x²+2 has two complex roots: ±sqrt(2)*i. Let's see if our program can find the upper one:
Looks like the right answer!
# Common Lisp/Advanced topics/Packages

Packages are a facility in Common Lisp to divide the namespace. Packages allow one to isolate all of their function, macro, and variable definitions from the rest of the system. This reduces the number of problems that occur with name collisions, or two people using the same name for different things.
A symbol has the printed form PACKAGE-NAME::SYMBOL-NAME, however, if we are currently in package PACKAGE-NAME, then the printer will just print SYMBOL-NAME. The dynamic variable *PACKAGE* always specifies the current package. When interned, a symbol is interned in the package that *PACKAGE* names, unless the package name is specified via the ‘::’ notation.
A package is defined with DEFPACKAGE. A package may EXPORT any of its symbols in which case they may be designated by PACKAGE-NAME:SYMBOL-NAME, i.e. only one ‘:’. A package may also IMPORT a symbol from any other package. If a symbol is imported that has the same name as a different symbol that was already interned in the package, then an error occurs. You will have to choose one symbol. USE-PACKAGE helps one import the API from a package. The symbols that a package exports and the packages that a package uses may be specified via DEFPACKAGE.

## Example: List all Symbols in a Package

Common Lisp provides some macros to iterate through the symbols of a package. The two most interesting are: DO-SYMBOLS and DO-EXTERNAL-SYMBOLS. DO-SYMBOLS iterates over the symbols accessible in the package and DO-EXTERNAL-SYMBOLS only iterates over the external symbols (you can see them as the real package API).
To print all exported symbols of a package named "PACKAGE", you can write:
You can also collect all these symbols in a list by writing:
Or you can do it with LOOP.
Copyright © 2002-2005 The Common Lisp Cookbook Project http://cl-cookbook.sourceforge.net/
# C++ Language/Std/Strings/CharacterCategories

There are functions for classifying a character as belonging to a category. The examples isdigit('0'), isspace(' '), and ispunct('!') all return true (in the form of a non-zero int value).
Additional information about character categories (includes interactive examples)
# C++ Language/Std/Strings/CastingNumericValues/StringToNumber

The inverse of formatted-printing can cast from a C-string into a numeric variable: sscanf("11", "&d", &iVar);.
Additional information about casting from string to number (includes interactive examples)
# C++ Language/Std/Strings/Locale

The behavior of some string functions will depend on the computer system's "locale" setting. The Win32 implementation of some functions (e.g., atoi) have a locale-sensitive alternative (atoi_l).
Additional information about locale
# C++ Language/Std/Strings/StringClass

An object-oriented approach to storing string data is C++'s std::string object, which can dynamically-grow because it implements many of the same functions as an STL vector. Instead of using '\0' to terminate string data, you can query its strVar.size function.
* Construction
* Equality
* Indexing
* Inserting Characters
* Algorithms
# C++ Language/Std/Strings/StringClass/Algorithms

A family of find query algorithms return basic_string::npos (which is -1) to indicate "pattern is not found".
Additional information about string algorithms (includes interactive examples)
# C++ Language/Std/Strings/StringClass/Construction

A std::string object can be treated as a value (e.g., passing it into some function as a parameter value), because copy-construction has been provided.
Initializing a string as std::string strVar("abc"); is equivalent to std::string strVar = {'a', 'b', 'c'};.
Additional information about string construction (includes interactive examples)
# C++ Language/Std/Strings/CastingNumericValues

A common task is the conversion of some number between two forms: its representation in a numeric data type, and a string using characters between '0' and '9'.
* Number to String
* String to Number
# C++ Language/Std/Strings/CastingNumericValues/NumberToString

Formatted-printed by sprintf(pcBuffer, "%d", 11); is an easy way to cast from a number into a string.
The more modern std::format("1+2= and 4+5=", 3, 9) outputs its formatted-string as a std::string object.
Additional information about casting from number to string (includes interactive examples)
# C++ Language/Std/Strings/RegularExpressions

The std::regex_match function compares an input string against the regular expression pattern stored in a std::regex object. The result of that matching is output into a std::cmatch object (which can be converted into a std::string by str).
Additional information about regular expressions (includes interactive examples)
# C++ Language/Std/Strings/StringClass/Equality

The == operator exists for comparing the data inside two std::string objects.
Additional information about string equality (includes interactive examples)
# Conhistory/Peoples/Barbarians

Barbarians are a touchy subject. When the term is used correctly, they are semi-nomadic, lack a visible set of laws, and raid and pillage for their livelihood. When it isn't used correctly, they are cultures that have less developed technology and different standards of beauty, law, social expectation, and so on. We will be talking of barbarians of the first kind.
Barbarians have two reasons for raiding and pillaging. The first one is purely empirical: the need for material objects. To this end, their ruthless tactics might be explained by "gaining reputation," so as to frighten the villagers when they attack and make the battle that much easier. Their other reason is not so well supported: the desire to create an "Empire." Everyone hates insults about them, for example, a male will not be happy while listening to a radical feminist tirade about the worse qualities of men and how this makes them inferior. To this end, Barbarians hate being degraded as barbarians, and, in some small way, want to make the folk tales of them being demons end. They want to join the civilized world, and they think that only if they conquer enough civilizations, then they'll become civilized.
Barbarians have a distinct culture. Often, their religion is a violent one, where the gods demand human sacrifices. Additionally, laws are most often written by the sword or as a 'code of honor'.
# Conhistory/The Future World

We don't know the future, but we can guess what it may be like. It may be our idea of paradise (like the Culture) or our idea of hell (like 1984). A conworld set in the future has much less to go on than one set in the past. That may be one of the main reasons that futuristic conworlds are rarely seen, though there are certainly other factors.

## Further Reading

* Futurology
* Space Transport and Engineering Methods
# Conic Sections
## Contents
### Conic Sections Introduction
### Types of Conic Sections

* General Conic Sections
* The Circle
* The Ellipse
* The Parabola
* The Hyperbola
* Lines and Points: Degenerate Conic Sections

### Features of Conic Sections

* Foci of Conic Sections
* Conic Sections as Loci
* Eccentricity

### Conic Sections as Algebraic Relations

* Intercepts of Conic Sections
* Translation of Axes
* Rotation of Axes
* Rotation of Axes (examples)
* Slopes of Conic Sections

### Other Systems

* Conic Sections in Polar Coordinates
* Parametric Forms of Conic Sections

### Example Problems

* The Ellipse
* The Parabola
* The Hyperbola
* Identifying Conics
* Rotating Conics

### Conclusion

* Concluding Remarks
* Acknowledgements and Further Reading
# Conhistory/Cultures/Art

You can't become a great artist if you have to work all day. Thus, art in earlier periods reflects the interest of the upper classes. A secular monarch may pay portraits and stories about great wars or the life of his family, priests may pay for religious art, which might be restricted in form (e.g. no pictures of god).
# Conic Sections/Circle

The circle is the simplest and best known conic section. As a conic section, the circle is the intersection of a plane perpendicular to the cone's axis.
The geometric definition of a circle is the locus of all points a constant distance $r$ from a point $(h,k)$ and forming the circumference (C). The distance $r$ is the radius (R) of the circle, and the point $O=(h,k)$ is the circle's center also spelled as centre. The diameter (D) is twice the length of the radius.

## Equations
#### Standard Form

The standard equation for a circle with center $(h,k)$ and radius $r$ is
$(x-h)^{2}+(y-k)^{2}=r^{2}$
In the simplest case of a circle whose center is at the origin, the equation is simply a restatement of the Pythagorean Theorem:
$x^{2}+y^{2}=r^{2}$

#### General form

The general form of a circle equation is
$x^{2}+y^{2}+2gx+2fy+c=0$
<-g,-f> is the center of the circle.

#### Polar Coordinates

In the case of a circle centered at the origin, the polar equation of a circle is very simple because polar coordinates are essentially based on circles. For a circle with radius $a$,
$r=a$
In the more complicated case of a circle with an arbitrary location, the equation is
$r^{2}-2rr_{0}\cos(\theta -\varphi )+r_{0}^{2}=a^{2}$
$r_{0}$
$\varphi$
There are many cases that allow the equation to be simplified. If a point on the circle is touching the origin, its polar equation may consist of a single trig function.

#### Parametric Equations

When the circle's equation is parametrized with respect to $t$, the equation becomes
$x=h+r\cos t$
$y=k+r\sin t$

## Example

Find the center and the radius of the following circle: x$^2$+y$^2$+8x-10y+20=0 find by:
x$^2$+y$^2$+8x-10y+20=0
x$^2$+y$^2$+8x-10y= - 20 (x$^2$+8x)+(y$^2$-10y)= - 20 +16 +25 +16+25 (x$^2$+8x+16)+(y$^2$-10y+25)=21 (x+4)$^2$+(y-5)$^2$=21
Thus: C(-4,5) radius=$radical(21)$
# Conhistory/Peoples/Push and Pull

The Push and Pull factors in Conworlding are things that 'Push' people away from an area of land and 'pull' them towards a new one. For example if an area of land was to change from lush savannah to inhospitable desert much like the Sahara did then that would pull large amounts of people away from that land to a more fertile and forgiving environment much like the Nile Valley in the Sahara. As you may be able to guess this is how the Egyptian Civilization began to form, from migrating Saharan peoples who found the land in the Nile Valley more habitable than the Sahara which at that period in time was drying up very fast.
The Push and Pull factors often cause people to migrate and have caused such incidents as the Founding of Egypt, Mongol Invasions, Colonization of the Americas and the Polynesian Migration across the Pacific. The Push and Pull affect does have a real and large presence in the History of Earth.
# Debian for beginners

This book is for people who do not know much about computers or software. It teaches the basics of downloading, installing and using Debian.
Keep in mind:
* Use basic english
* The user does not know much about computers
* Pictures are very helpful

## Contents

* Before install
** What installation image do I choose?
** Recording installation image
** Backup data
* Installation
** Partitions
** Desktop Environment
* First boot
** Customizing the system
** Installing apps and Flatpak
* Glossary
# Defence in Depth for Securing Computer Systems/The Technology

Defence-in-Depth is an approach used by many leading organisations to protect information, data and people. Utilising a mix of key technologies, organisations look to multiple vendors to deploy both internal and parameter security.
# Debian for beginners/Before install

To install Debian you first need to download and record it on a installation medium (USB flash drive, CD, DVD).

### What installation image do I choose?
#### Types

* CD images (or Network installs)
** up to 700MB
** only the basic installer and a basic system, no desktop environment
** installing desktop environments and programs needs an internet connection
** old installer
* DVD/USB images
** up to 4.7GB
** functioning system
** optional programs
** old installer
* Live install images
** up to 3.4GB
** run the system from your installation medium
** functioning system
** friendly installer
** can test it without installing
*** do the same things you do on an installed system
*** no files or settings are saved

#### Architecture (64-bits or 32-bits)

Before downloading the installation image, check if your system is 64 or 32 bit. It is likely to be 64-bit but in the case you don't know, check it in your motherboard's BIOS. Remember that live images are only for 64-bit PCs.
* 32-bit – download i386
* 64-bit – download amd64

#### Download image

Download the live image. If your computer is 32-bit, install the 32-bit DVD image. If the memory of your storage device is below 3.5GB, download the CD image. You can also buy official Debian CDs, DVDs and USB drives from a vendor.

### Recording installation image

You need to record (or flash) the image on your installation medium. To do that you need to install a special program. We will use Rufus.

### Backup data

Before installing Debian, copy any important files, from your target drive, to another drive.

### Glossary
#### desktop environment

    a visual representation of your system, how your system will look, like KDE Plasma or GNOME

#### installation image

    a computer file that has everything to record on your installation medium

#### iso image

    see installation image

#### target drive

    the storage device you will install Debian on, like a HDD or SSD

#### installation medium

    the storage device you will record the installation image on and install Debian from, like a CD, DVD or USB drive

#### drive

    a storage medium, like a hard disk drive (HDD), soft state drive (SSD) or USB drive

#### to flash

    to record an iso image on an USB drive

#### to burn

    to record an iso image on a CD or DVD, sometimes permamently
# Defence in Depth for Securing Computer Systems

(Apr 30, 2006)
But a lot of businesses out there don't see the return on investment, they look at it as a liability, and until they can understand that proactive security actually returns, gives them a return on investment, it's still a hard sell for people.
The concept of Defence in Depth is going to cost your organisation money. It is not cheap to implement, and it is something you have to feed money into every day to maintain. So why do you do it? The simple answer is to protect the business. Business of today is no longer just bricks and mortar. It is no longer just buildings and street addresses. The heart of business today is information. Take away the information and the bricks and mortar will be sold off eventually at bankruptcy auction.
Defence in Depth is all about protecting the information by building up a number of layers around it. It isn’t simply putting up and firewall and walking away. Defence in Depth is building a number of layers around the information that work together to provide a strong and (hopefully) impenetrable.
This book will most likely not cover a lot of new ground for you. A lot of the concepts here are standard areas you will cover working in any IT department. What is new is the aspect of integrating them into one consolidated defensive strategy.
Nine main areas will be covered. These will include:
* Preparation
* The Technology
* The Business
* The People
* The Physical
* The Policy
* Incident Handling
* Information Warfare and Operations Security
* Putting it together
# Defence in Depth for Securing Computer Systems/Configuration Control and Documentation

Defence in Depth for Security Computer Systems/Preparation/Baselining

## Configuration Control and Documentation

Now every good system administrator will have some knowledge of the systems they are responsible for in their head, or on spreadsheets, word files, homegrown database system etc. However, can you truthfully answer the following questions?
1. Is it 100% up to date?
2. Is it 100% correct?
3. Do your colleagues/boss know where it is and how to read it?
4. Is this the only copy that exists or do other system administrators keep similar systems?
These questions highlight the need for configuration control and a central and unique repository of documentation.
The best way to commence the creation of the central repository of information is to first determine what currently exists. If a system administrator is responsible for looking after a large
number of servers and switches, generally they will keep the information they need to do their job handy. Depending upon their skill with the tools available to them, this could be anything from a sophisticated spreadsheet with macros and formulas to a simple text file with a list of IP addresses. Don't discount what you currently have, but try to look at all of the various system and attempt to develop a best of breed approach. Take the various systems that already exist, adopt it organisation wide and make it mandatory for all system administrators to use that system. Once you have a standard system that is used by all system administrators, then you need to ensure that it is maintained and kept up-to-date. This is task now becomes mostly a policy and procedure function. There are two areas you need to address: 1. Changes to existing configuration 2. Additions to the network An approach that can be used here is to adopt a Configuration Control Board to handle and approve any changes and additions. This provides a solid and robust framework to ensure that all changes are documented and (possibly more importantly) that all changes are approved and reviewed before they are made.
# Delphi Programming

Delphi is both an object oriented programming language (OOP) and an Integrated Development Environment (IDE). Published by the Embarcadero company (formerly CodeGear and more formerly Borland), Delphi is an alternative to language such as Visual Basic offering development with both rapidity and good quality.
It originated from the Pascal language, which then became Object Pascal (pascal with objects support). Delphi is based on the Object Pascal language. The IDE runs on Windows, but the compiler targets Windows, macOS, iOS, Android, and Linux. Third party add-ins provide the ability compile to JavaScript for web development.
Delphi includes the RunTime Library (RTL) that provides basic functionality across all the platforms. For Windows it provides the Visual Component Library (VCL), and for cross platform development it includes FireMonkey (FMX).

## Table of Contents

* Introduction
* First application
* Delphi project files
* Reserved keywords
* Statements
* Variables and constants
* Data types
* Boolean expression
* Arithmetic expression
* Flow control
* Pointers
* Objects and classes
* Procedures and functions
* Dynamic link libraries (DLLs)
* The Debugger
* The GUI - Introduction
* The GUI - Component overview
* The GUI - Multimedia
* Creating own components
* The SysUtils unit
* The Math unit
* Assembler in Delphi

## See also

* Embarcadero Wiki
* Free Pascal/Lazarus Wiki
* Delphi on Wikia
wikiversity:fr:Delphi