OpenLLM-France/wikimedia huggingface dataset:
# Radiation Oncology/Physics/Photobiology

* Photobiology is the study of the effects of ultraviolet, visible and infrared radiation on living organisms
* It includes topics such as photosynthesis, vision, bioluminescence, circadian rhythms and photodynamic therapy
* The field includes the study of photophysics, photochemistry, photosynthesis, photomorphogenesis, visual processing, circadian rhythms, photomovement, bioluminescence, and ultraviolet radiation effects
* When photons come into contact with molecules, these molecules can absorb the energy in photons and become excited
* Then they can react with molecules around them and stimulate "photochemical" and "photophysical" changes of molecular structures
* Photophysics
* Photochemistry
# QEMU/Devices/Network

Network devices are somewhat special, since besides being able to add them the standard way, there's a much easier one to configure them through the -net nic parameter.
Also, please note that -device doesn't suppress the default configuration, so it might not do what you intend.

## Adding a card

Simply specifying -net nic on the command line adds an interface. You can select the hardware being emulated using the model modifier.
Example:

## Network card models

For PC emulation
| Model | Bus | Speed | Description |
| e1000 | PCI | 10/100/1000Mb/s | Intel 82540em / PRO/1000 |
| i82551 | PCI | 10/100Mb/s | Intel 10/100 Mbps Fast Ethernet |
| i82557b | PCI | 10/100Mb/s | Intel 10/100 Mbps Fast Ethernet |
| i82559er | PCI | 10/100Mb/s | Intel 10/100 Mbps Fast Ethernet |
| ne2k_pci | PCI | 10Mb/s | RTL8029 - NE2000 PCI |
| ne2k_isa | ISA | 10Mb/s | NE2000 Compatible |
| pcnet | PCI | 10/100Mb/s | AMD PCnet FAST III Ethernet |
| rtl8139 | PCI | 10/100Mb/s | Realtek Fast Ethernet |
| virtio | PCI | 1Gb/s | Virtual High Performance Ethernet card (see Virtio) |
In this command, <arch> and <model> should be replaced with the appropriate architecture and model you intend to use.
Others emulated architectures
You have to launch this command to list emulated network card
# QEMU/Cygwin

* There are pre-compiled binaries for Windows. It may save some time to use them. However as of this writing, they are out of date with respect to the source repository, by a full version number.
* Download the source code at the main website's download page.
* Running ./configure from the directory where the source archive was extracted will result in an error with Cygwin's CC. Instead use:
** ./configure --cc="gcc-3 -mno-cygwin" --host-cc=gcc-3
* Dependencies - There are several libs required that may not be installed as of yet. If configure fails complaining that one of these is missing, you may choose to either install directly from Cygwin's installer, or build them from source. Instructions for the latter can be found on MinGW. Dependencies include the following:
** zlib
** gettext
** glib 2.20 or later.
** libiconv
** pkg-config
# QBasic/What Next
## Websites

There are many good websites out there on the topic of QBasic. This is a list of the best sites:
Petes QBasic Site: This site is mostly aimed at people thinking about programming video games in QBasic.
The QBasic Page: This is a good site for getting source codes and programs for QBasic.
QBasic News: The most recent and up to date news on the QBasic community.
QBasic Programming for Kids: A good site for young people to start programming.
Qb64 : All you need to know about QB64.
Also, the QB64 IDE has an inbuilt help page, giving essential help when you don't know how to use a command. The only drawback is , it does not show any help unless you select the command and right click on it, and click on "HELP ON ...." which means, you atleast have to know the name of the command before you seek help on it.

## Further in programming

If you are learning QBasic, chances are that you are still new to programming. It is a diverse world, explore it!
A list of extremely good programming languages to continue further:
* C++
* HTML
* Java
* Javascript
* CSS
# QEMU/Devices/Storage

Storage devices can be added using -drive parameter, or with the drive_add command in the QEMU monitor.

## Media type

Several drive types can be emulated. This can be specified through the media modifier. If not specified, it defaults to disk.
Valid types are:
* disk
* cdrom
Example:

## Virtual FAT filesystem (VVFAT)

Qemu can emulate a virtual drive with a FAT filesystem. It is an easy way to share files between the guest and host.
It works by prepending fat: to a directory name. By default it's read-only, if you need to make it writable append rw: to the aforementioned prefix.
Example:
WARNING: keep in mind that QEMU makes the virtual FAT table once, when adding the device, and then doesn't update it in response to changes to the specified directory made by the host system. If you modify the directory while the VM is running, QEMU might get confused.

## Cache policies

QEMU can cache access to the disk image files, and it provides several methods to do so. This can be specified using the cache modifier.
| Policy | Description |
| unsafe | Like writeback, but without performing an fsync. |
| writethrough | Data is written to disk and cache simultaneously. (default) |
| writeback | Data is written to disk when discarded from the cache. |
| none | Disable caching. |
Example:

## Attaching drives to controller interfaces

If the drive is not attached to a controller interface (i.e. if=none), then it can be manually attached with:
| Bus | Argument |
| SCSI | -device scsi-hd,drive={id} |
| USB | -device usb-storage,drive={id} |
# QBasic/Working With Strings
## What are strings and what are they used for?

In QBASIC, a string is a contiguous sequence of ASCII encoded characters in memory. The characters are stored in memory as an 8 bit byte. Strings in QBASIC are mutable meaning they can be changed in place without allocating new memory. By now if you have read the prior chapters, you should know that strings are typically used to represent numbers, letters, and other symbols and are used to display information on screen, and getting user input. In the Files chapter you will find that strings can be saved into and read from files as well. If you get creative you can use strings for other purposes. One example is adding large numbers hundreds of digits long. In QBASIC you cannot do that with its built in numeric data types. You could however store the digits in string form and write your own function to add a couple of strings containing digits together thus overcoming some of the initial QBASIC constraints.
# QEMU/Debugging with QEMU

QEMU offers a comfortable way to do system-wide debugging; this environment is specially suited to debug operating system kernels and firmware.
You can actually connect any debugger supporting the GDB remote protocol. For the following examples however, we will be using the GNU Debugger.

# Starting a debugging session
## Preventing the CPU from starting

Starting QEMU with the -S command-line switch prevents the CPU from starting. This gives time for the debugger to connect and allows to start debugging from the very beginning, even the early platform firmware.
To start execution, you must send QEMU the "continue" command, either via the debugger or the monitor console.

## Connecting to the Debugger

The -gdb {device} command-line switch allows you to specify QEMU to wait for a connection in the specified device.
It can accept serial, socket, udp, tcp, stdio, etc. E.g. -gdb tcp::9000 to listen on port 9000, then from GDB you can connect to it with target remote localhost:9000.
The -s switch is a shorthand for -gdb tcp::1234.

## Launching QEMU from GDB

It is possible to launch QEMU from within GDB; you can conveniently save the desired commands to a file and have GDB load the script.
For example, lets suppose you have a very simple custom MBR that loads a kernel in protected mode at 0x7E00, you can debug both with something like:
Then you can start it like this: gdb -x script.gdb
More complex setups, taking into account run-time relocations are possible by scripting and setting breakpoints. This is common when debugging bootstrapping code that relocates itself before loading the next stage (e.g. standard MBR).
# QEMU/Devices

QEMU provides virtual hardware devices to the guest system, allowing it to interact with the external world, just like if it were running on real hardware.

## Adding devices

Devices can be added using the -device parameter when starting, or with the device_add command in QEMU monitor (if the operating system and bus support hotplug).
Some devices take modifiers, that may affect the device's behavior and interface.
Example:

## Supported devices by type

* Virtio (High Performance)
* USB Root Hubs
* Network
* Input
* Video
* Storage
* Audio
* Miscellaneous
# QEMU/Devices/Input
## Tablets

| Device | Bus | Description |
| usb-tablet | USB 1.x | |
| usb-wacom-tablet | | QEMU PenPartner Tablet |
# Neuroscience/Developmental Neurobiology/Neural Induction

The primary neural tissue is derived from the ectoderm, one of the three primary germ cell layers - the other two are the mesoderm and endoderm.
The notochord (also called the chordomesoderm) releases the two signaling molecules noggin and chordin, which act as inductive agents. When the notochord releases these inductive molecules, neural ectoderm is formed from the overlying surface ectoderm. Noggin and chordin antagonize the effects of Bone morphogenetic Protein 4 (BMP-4) - a growth factor in dorsal ectoderm that must be inhibited for ectoderm to become neural.
Research into the notochord has played a key role in understanding the development of the central nervous system. By transplanting and expressing a second notochord near the dorsal neural tube, 180 degrees opposite of the normal notochord location, one can induce the formation of motoneurons in the dorsal tube.
The notochord also secretes a protein called sonic hedgehog homolog (SHH), a key morphogen regulating organogenesis and having a critical role in signaling the development of motoneurons. The secretion of SHH by the notochord establishes the ventral pole of the dorsal-ventral axis in the developing embryo. As shh is secreted a gradient is formed. Different levels of shh cause different types of cells to be formed in the developing embryo. Motoneuron formation generally occurs in the ventral neural tube, while the dorsal tube generally forms sensory neurons.

## References

* ↑ Echelard, Y; Epstein, Dj; St-Jacques, B; Shen, L; Mohler, J; Mcmahon, Ja; Mcmahon, Ap (December 1993). "Sonic hedgehog, a member of a family of putative signaling molecules, is implicated in the regulation of CNS polarity". Cell. 75 (7): 1417–30. doi:10.1016/0092-8674(93)90627-3. PMID 7916661.{{cite journal}}: CS1 maint: multiple names: authors list (link)
# Neuroscience/Electrophysiology

Neurophysiology at Wikipedia
Neurophysiology historically began with Luigi Galvani in 1791 when he published the monograph "De Viribus Electricitatis in Motu Musculari Commentarius" (Commentary on the Effect of Electricity on Muscular Motion). This monograph suggested an inherent electricity exists within the living tissue.
The study of nervous system electrophysiology can occur at many different levels including: 1) Electroencephalography (EEG) 2) Local Field Potentials 3) neuron populations and 4) the electrical activity outside or inside a neuron measured by patch clamp methods. As such, the major focus of this field is on cellular communication. Frequently studied as the generation of electrical signals within neurons from the regulated flow of various ions, often in the form of an action potential. A good beginning reference is the "Physiology of the Nervous System" by David Ottoson.
This field has been intertwined with Computational Neuroscience the work of Andrew Huxley, Alan Hodgkin, and David Marr.
# Neuroscience/Computational Neurobiology

Computational neurobiology is the application of mathematical and computational models to problems in neuroscience. It seeks quantitative characterizations of molecular, single-neuron, network, and behavioral dynamics.

### Topics

* Stimulus-response systems
* Modeling neural networks
* The dynamical systems perspective
* Mathematical techniques
# Neuroscience/Developmental Neurobiology

* Activity Dependent shaping of neuronal circuitry during development
* Neural Induction
* Compartments and Segments
* Neurogenesis
* Oligodendrocyte Development
* Neuronal Migration
* Neuronal Death
* Axon Guidance
* Synapse Assembly
* Adult Neural Stem Cell Biology
* Electrical Development
# Neuroscience/Developmental Neurobiology/Activity Dependent
## Activity Dependent shaping of neuronal circuitry during development

Aaron et al (2005) have demonstrated that the brains of mice lacking a protein found on most cortical neurons, the so-called Nogo receptor, can adapt to the loss of sight in one eye long after the brains of normal mice have lost this ability. The findings represent a dramatic demonstration that this type of neural plasticity, which normally is restricted to a critical period early in life, can be extended well into adulthood.

## References

* Aaron W. McGee, Yupeng Yang, Quentin S. Fischer, Nigel W. Daw, and Stephen M. Strittmatter Experience-Driven Plasticity of Visual Cortex Limited by Myelin and Nogo Receptor Science 30 September 2005: 2222-2226
# Ruby Programming/Mailing List FAQ
### Etiquette

There is a list of Best Practices.
See some more questions answered.
* ↑ https://web.archive.org/web/20160327125758/http://blog.rubybestpractices.com/posts/jamesbritt/and_your_Mom_too.html
# Ruby Programming/Here documents

← Alternate quotes | ASCII →
For creating multiple-line strings, Ruby supports here documents (heredocs), a feature that originated in the Bourne shell and is also available in Perl and PHP.

## Here documents

To construct a here document, the << operator is followed by an identifier that marks the end of the here document. The end mark is called the terminator. The lines of text prior to the terminator are joined together, including the newlines and any other whitespace.
The result:
If we pass the puts function multiple arguments, the string literal created from the here document is inserted into the argument list wherever the << operator appears.
In the code below, the here-document (containing the four grocery items and a blank line) is passed in as the third argument. We get the same output as above.

### Multiple here documents

You can also have multiple here documents in an argument list. We added a blank line at the end of each here document to make the output more readable.
The output after running this code is:
We have been using the puts function in our examples, but you can pass here documents to any function that accepts Strings.

## Indenting

If you indent the lines inside the here document, the leading whitespace is preserved. However, there must not be any leading whitespace before the terminator.
The result:

### Indenting the terminator

If, for readability, you want to also indent the terminator, use the <<- operator.
Note, however, that the whitespace before each line of text within the here document is still preserved.

## Quoting rules

You may wonder whether here documents follow single-quoting or double-quoting rules.

### Double-quoting rules

If there are no quotes around the identifier, like in our examples so far, then the body of the here document follows double-quoting rules.
The output of this example is:
Double-quoting rules are also followed if you put double quotes around the identifier. However, do not put double quotes around the terminator.

### Single-quoting rules

To create a here document that follows single-quoting rules, place single quotes around the identifier.
The result:
# Ruby Programming/Introduction to objects

← Encoding | Ruby basics →
Like Smalltalk, Ruby is a pure object-oriented language — everything is an object. In contrast, languages such as C++ and Java are hybrid languages that divide the world between objects and primitive types. The hybrid approach results in better performance for some applications, but the pure object-oriented approach is more consistent and simpler to use.

## What is an object?

Using Smalltalk terminology, an object can do exactly three things.
* Hold state, including references to other objects.
* Receive a message, from both itself and other objects.
* In the course of processing a message, send messages, both to itself and to other objects.
If you don't come from Smalltalk background, it might make more sense to rephrase these rules as follows:
* An object can contain data, including references to other objects.
* An object can contain methods, which are functions that have special access to the object's data.
* An object's methods can call/run other methods/functions.

## Variables and objects

Let's fire up irb to get a better understanding of objects.
In the first line, we created a String object containing the text "Stephen Colbert". We also told Ruby to use the variable comedian to refer to this object.
Next, we tell Ruby to also use the variable favorite_comedian to refer to the same String object.
Now, we have two variables that we can use to refer to the same String object — comedian and favorite_comedian. Since they both refer to the same object, if the object changes (as we'll see below), the change will show up when using either variable.

## Methods

In Ruby, methods that end with an exclamation mark (also called a "bang") modify the object. For example, the method upcase! changes the letters of a String to uppercase.
Since both of the variables comedian and favorite_comedian point to the same String object, we can see the new, uppercase text using either variable.
Methods that do not end in an exclamation point return data, but do not modify the object. For example, downcase! modifies a String object by making all of the letters lowercase. However, downcase returns a lowercase copy of the String, but the original string remains the same.
Since the original object still contains the text "STEPHEN COLBERT", you might wonder where the new String object, with the lowercase text, went to. Well, after irb printed out its contents, it can no longer be accessed since we did not assign a variable to keep track of it. It's essentially gone, and Ruby will dispose of it.

## Reassigning a variable

But what if your favorite comedian is not Stephen Colbert? Let's point favorite_comedian to a new object.
Now, each variable points to a different object.
Let's say that we change our mind again. Now, our favorite comedian is Ellen DeGeneres.
Now, no variable points to the "Jon Stewart" String object any longer. Hence, Ruby will dispose of it.
# Ruby Programming/Interactive Ruby

← Notation conventions | Hello world →
When learning Ruby, you will often want to experiment with new features by writing short snippets of code. Instead of writing a lot of small text files, you can use irb, which is Ruby's interactive mode.

## Running irb

Run irb from your shell prompt.
The >> prompt indicates that irb is waiting for input. If you do not specify --simple-prompt, the irb prompt will be longer and include the line number. For example:
A simple irb session might look like this.
These examples show the user's input in bold. irb uses => to show you the return value of each line of code that you type in.

### Cygwin users

If you use Cygwin's Bash shell on Microsoft Windows, but are running the native Windows version of Ruby instead of Cygwin's version of Ruby, read this section.
To run the native version of irb inside of Cygwin's Bash shell, run irb.bat.
By default, Cygwin's Bash shell runs inside of the Windows console, and the native Windows version of irb.bat should work fine. However, if you run a Cygwin shell inside of Cygwin's rxvt terminal emulator, then irb.bat will not run properly. You must either run your shell (and irb.bat) inside of the Windows console or install and run Cygwin's version of Ruby.

## Understanding irb output

irb prints out the return value of each line that you enter. In contrast, an actual Ruby program only prints output when you call an output method such as puts.
For example:
Helpfully, x=3 not only does an assignment, but also returns the value assigned to x, which irb then prints out. However, this equivalent Ruby program prints nothing out. The variables get set, but the values are never printed out.
If you want to print out the value of a variable in a Ruby program, use the puts method.
# super

The super keyword can be used to call a method of the same name in the superclass of the class making the call. Values passed to the super call are passed into the parent method.
Example:
A call to the initialize function of the child class above will result in the execution of both its body and the body of the initialize function in the parent class.
Note that if you invoke super without arguments, all arguments to executing method will be passed to the parent method as well - and if parent's signature does not match the number of arguments, an exception will be raised. So, if the child version of the method uses a different number of arguments than the version in superclass, you need to list arguments that you want to pass to the parent's version of the method.
Note also that you can use any method name, not just initialize (in this case).

# iterators

Iterators provide a method for cycling through a set of values and performing an operation, usually specified by a code block, for each value. Iterator functionality is often provided through the mixin Enumeration module.
The first iterator that Ruby programmers are likely to encounter is the each iterator.
Example:
Outputs:

# yield

yield executes the entire code block passed to the method.
Example:
Outputs:
You can therefore make your own method looking like the built-in times:
Outputs:
# Ruby Programming/Notation conventions

← Ruby editors | Interactive Ruby →

## Command-line examples

In this tutorial, examples that involve running programs on the command-line will use the dollar sign to denote the shell prompt. The part of the example that you type will appear bold. Since the dollar sign denotes your shell prompt, you should not type it in.
For example, to check what version of Ruby is on your system, run:
Again, do not type the dollar sign – you should only enter "ruby -v" (without the quotes). Windows users are probably more familiar seeing "C:\>" to denote the shell prompt (called the command prompt on Windows).
An example might also show the output of the program.
In the above example, "ruby 1.8.5 (2006-08-25) [i386-freebsd4.10]" is printed out after you run "ruby -v". Your actual output when you run "ruby -v" will vary depending on the version of Ruby installed and what operating system you are using.

### Running Ruby scripts

For simplicity, the following convention is used to show a Ruby script being run from the shell prompt.
However, the actual syntax that you will use to run your Ruby scripts will vary depending on your operating system and how it is setup. Please read through the Executable Ruby scripts section of the Hello world page to determine the best way to run Ruby scripts on your system.

### Running irb

Ruby typically installs with "interactive ruby" (irb) installed along with it. This is a REPL that allows you to experiment with Ruby, for example: