OpenLLM-France/wikimedia huggingface dataset:
# Question Writer Manual/Extras/PlayStation Portable
## PlayStation Portable

The Playstation Portable is a mobile gaming device that now supports Flash 6, and so you can run Question Writer tests and quizzes on it. It has a large screen for a mobile device, with widescreen proportions (480x272). You can use the existing themes with the PSP, but it looks best with a theme that is specifically designed for it.
Here's a sample quiz that we've made for the PSP, (or here, stretched for desktop use ), the source for the quiz , and the theme (.qws) file too.
Kudos to Radu Chiotan for creating a great theme and Delia Mihai for the cool background.
When publishing for the PSP - there are a few things to take into account:
* Turn off the Maximize in browser option - this will ensure the quiz appears at the correct size.
* Users can't use the keypad to tab between the buttons. Users must use the pointer device and X button.
* It's a good idea to avoid the use of scrollbar, this will help to preserve memory on the device.
* You'll get between 5 questions with feedback or 20 questions without running out of memory - it depends on all the factors that go into your quiz - more question types, with scrollbars and feedback, and complex buttons and themes all increase pressure on the memory and can lead to an 'out of memory' error on the device.
* Users have to click once on the Flash before starting the quiz to focus/activate it.
* Users can download tests and quizzes to use offline, or live on the internet.
* The PSP runs quite a bit more slowly than desktop flash, users will have to wait a second or two after clicking a button for the effect to show up.
* PSP supports Flash 6, but Flash 6 doesn't allow sending results to our service. There is a way around this if you send the results back to your own server. Flash 7 is required to use the 'Results by Email' service.
# Question Writer Manual/Frequently Asked Questions/Branching

* I would like to set a different set of questions to people depending on how they answer the first question, for example different questions for male or female contestants. Is it possible to ask a branching or dynamic question?
Yes, using the latest version of Question Writer 4 you can ask different questions based on previous responses by setting conditions and evaluating the scores based on these conditions. You can read more about this in Custom Feedback and Skipping and Branching.
# Question Writer Manual/Frequently Asked Questions/Email Accounts

* Can I send results to more than one email address?
When you are setting up your quiz, you can only enter one email address in Send Results Via Website to E-mail.
If you need to circulate the quiz results to a number of different people you can do this by creating a new email account that will automatically forward all emails to a list of addresses. Gmail is one email service that will do this successfully. You can then enter that email address in the quiz set up.
See Results for more information on results.
# Question Writer Manual/Extras/Question Writer API
## Question Writer API

There is a code library to help creating Question Writer quizzes. If you'd like to export to the Question Writer format from your .NET application or website, you can use this QW_API.dll - there's also full documentation on how to use it
# Question Writer Manual/Frequently Asked Questions/Back Button

* Can I include a back button in every page, even with feedback after the question?
There is a way you can do this, but it is not a standard option within the program.
You need to edit this file (with a program like notepad):
C:\Program Files\Question Writer 4\Publishing\quizresources\styles.xml
You'll find a section
<style id="aftereachquestion">
</style>
change it so that all the values are true, like so
<style id="aftereachquestion">
</style>
# Planets and the Solar System/Sun

The sun is a star in the center of our solar system. It is about 93 million miles from Earth.
It is the largest object in our solar system and provides the energy that drives all life on Earth.
Structure of the Sun
The sun is made up of mainly hydrogen and helium. Like, Earth the sun is composed of different layers.
* core
* radiation zone
* convection zone
* photosphere
The core is the hottest region of the sun. In the core hydrogen combines to form helium, and this process releases the energy in different forms, like heat and light. Temperatures in the core can reach up to 27 million degrees Fahrenheit.
The energy produced in the core, then passes through the radiation zone and the convection zone. The temperature in the convection zone changes, creating a movement similar to "boiling water".
The photosphere is considered the surface of the sun. The word part photo- means light and sphere means ball. The photosphere is ball of light visible from Earth. The temperature the surface is about 10,000 degrees Fahrenheit.
Our Sun is a Star
Stars are grouped by size, temperature, color, and other traits. Our sun is a medium size yellow star.
The sun and solar system
All of the planets in our solar system orbit the sun. The sun is located at the center of solar system. Objects closer to the sun receive more heat and light, than objects further away. The habitable zone is a place not too hot and not too cold to support life. We live in the habitable zone. Mercury is the closest planet to the sun. 2021 PH 27 is the closest object to the sun.
# Programming with Moose/Problems solved

Perl (prior to version 5.10) has an illogical Method Resolution Order (MRO), this becomes apparent when using multiple inheritance dispatching. A fix for MI-dispatching was first popularized with Dameon's NEXT, which turned out to be a buggy hack that failed horribly in many cases. NEXT was unfortunately inducted into the CORE distro with Perl v5.7.3 and remains in the CORE even today. Moose uses the newer jazzier C optimized Class::C3 which is the new non-default standard for proper method-dispatch in all Perl's greater than Perl 5.95.
Before Class::C3 and NEXT, you had SUPER which predates NEXT by approximately six months and thankfully never made CORE. SUPER was goofy and mostly useless because if foo and bar were siblings and subclasses of baz you could not re-dispatch in foo to a method in bar.
Essentially SUPER supported Method Dispatch only for linear patterns. NEXT supported them in a fashion that was quirky and made little sense. Without learning the quirks there is a high probability the new Class::C3 does precisely what the programmer wants - it is intuitive. Class::C3 uses the C3 MRO algorithm which is also employed by Python.

## The old way

The differences between NEXT and Class::C3 are outside of the range of this book; but, because vanilla Perl doesn't even permit method resolution, and dispatch in the sense of the OO paradigm we will show NEXT in its stead.

### An Example
## Footnotes

* ^ Perl 5.95 adds a new pragma mro which uses C3 resolution. This pragma is however opt in and makes a few tools available to you, which can all be utilized maintaining reverse compatibility with older Perl, using MRO::Compat.
* ^ The method that made little sense is called Depth First Search (DFS). DFS was the predecessor MRO to C3 in Perl. Briefly, it did not handle any form of triangle inheritance in a sane fashion.
# Programming with Moose/Roles and Plugins
## Qualifying scenarios for roles
### SFTHM

    Straight From The Horses Mouth
* If you can model your problem without using Roles, and with only single inheritance do it.
* Anything that can modeled with Roles can be modeled with Multiple Inheritance.
* If you know at compile time you want to apply a plugin, you probably don't wan't to use a plugin.
* If a plugin or role is only used one class, you're better off not using it.
* A role should only specify methods, and not subs. Subs should be specified in a module that uses Sub::Exporter instead of Moose's role system. A role is for method composition. Roles do more than just export. SFTHM

## Order sensitivity

Roles try not to be order sensitive when it comes to requirements, and conflict resolution; however, they are highly order sensitive when it comes to composition.
The order the roles are used determines the order of the method modifiers. Any method modifiers in the class before the with (keyword that includes the roles) will run before them, and any that are declared after the with will run after the roles.

## Disadvantages to inheritance

* ^ Inheritance permits build time setting of args via the constructor, i.e, Foo->new({bar=>'baz'}). If Foo is a subclass of Bar and Bar provides a few attributes via Moose#has, those attributes can be set in Foo's constructor arguments. In the plugin model, Foo applies plugin Bar and then you only set that which Bar does via one method call per attribute, rather than by hash. There is no way to apply Bar, and then initialize Foo with Bar's modifications using one hash, nor is there a way to initialize just Bar's modifications using one hash.
** All compile time resolution is disabled, i.e, +has => ( default => 'NewDefault' ) has no effect in a plugin.
* ^ You can not subclass a Role: a role for instance can provide contact information on a person, afterward it is said that a person can be contacted. A role however can not subclass that role to provide US-Specific contact information, for this you either must use two roles, or multiple-inheritance.
* Some tools are not supported by Roles, such as Moose's augment.
# Programming with Moose/Evolution of the Moose

Your typical non-Moose program will undergo a series of changes as your understanding of Moose advances and you achieve the venerable rank of Moose elder:
* Dismantling the sub new
* Breaking apart the setters by using sub BUILD
* Removing sub new , sub BUILD
Your end result will be an application which delays most tasks until called for. You will find less of a need to use sub new because the very nature of it is more compile time than you will often require. That is to say, Moose will permit you to further fragment your monolithic new, into smaller tinier more manageable news that work when you try to retrieve information. This doesn't completely kill off the vanilla sub new, but it knocks off a big chuck of it.
# Programming with Moose/Obtaining Moose

There are numerous way you can obtain the latest version of Moose. Some of the more popular methods are listed below.

## CPAN

Using the CPAN module:
Using the interactive shell, in non-interactive mode:
To use the shell in interactive mode simply:

## Tarball

Download from http://search.cpan.org/dist/Moose/.

## Debian (and Debian-derived systems)

If you're running Debian, or a Debian-based system, your package manager can install Moose. Using this method has advantages and disadvantages. The disadvantage is that you will not always be running the bleeding edge of Moose, and not all Moose extensions are packaged for Debian. The advantages are that you get quality control, security tracking, and ease of installation with Debian's APT.
To install Moose on a Debian system;
# Programming with Moose/Ideology
## Goal

Moose's goal is to increase programmer productivity by patching suboptimal syntax and Perl5's lacking object model. Moose goes about this by doing the grunt work for you. Nothing Moose accomplishes is done with source filters.

## Speed

Moose does not endeavor to make your program execute faster, nor does it show much concern for compile time. Most of the speed hit for using Moose occurs at compile time by design.

## Base-type independence

One of the things Moose accomplishes is an abstraction away from Perl5's base data-types. It shouldn't matter if your object is a blessed hash, array, or scalar with Moose and proper practices you can accomplish base-type independence.

## The bundle

A simple use Moose; should be your one-stop-shop for an off-the-shelf OO solution to both Perl's problems and yours. The latest and greatest sandbox for Moose features too esoteric to be included into Moose, or things built with the framework can be found in the MooseX:: namespace. MooseX is loosely reserved for things which build on top of Moose, or things that modify the behavior of Moose. Note however that MooseX is not the appropriate namespace for code which just uses Moose. Some extensions include MooseX::Traits, MooseX::Singleton, MooseX::Types.
# Programming with Moose/Preface

The first goal of a book should be to convince the reader it's worth reading in the first five minutes. It shouldn't take you five minutes to read this.

## Should I even be reading this?

This book is free, and in being free I can willfully tell people how to save time up front: If the following applies to you do not waste your time and go away:
* You don't use the OOP paradigm and you don't care to know what you're missing.
* You won't entertain the idea of making your perl programs dependent on a module that does not exist in the CORE distribution.
* You think all syntax that looks foreign to perl is bad.
* You're the benchmark-before-completion type of programmer, or you won't compromise on execution speed.
* You don't like radical change.

## Tell me what you're 'twerkin with

Let me start out with the problem: perl5 is old and crusty.
The OOP paradigm of Perl5 is in severe need of a face lift. Not only does it lack functionality that other programming languages have, the functionality it does have it does poorly. Moose will scrape off this crust and abstract away these shortfalls. All hail the shiny newer Moose-powered perl.
Moose is an awkward gem, and telling you what it's about is more of a boring practice of pedantry - one we will tackle at a later point. Moose does a lot, and it has ambitious goals, but aside from what it wants to accomplish, you'll find it delivers on the following:
* It will eliminate the need for the variety of modules that help compensate for that aforementioned old and crustyness.
* It will make programming more fun and less tedious. To further assist the hype-catalyst, it will make the fun more fun, and the tedious more fun, and the tedious less existent and.. or something...
* It will provide a versatile framework for which you can quickly prototype, and meld real-world problems.
* It will give you real world practice with another up and coming paradigm: AOP.
Be prepared to leave behind all of your old perl-OOP practices. Moose doesn't play well with them: it single-handedly replaces them! No more need for Class::Accessor, or writing manual checks using ref inside of your app. Gone are the days of using Conway's cursed NEXT, or violating blackbox rules to get the job done. Tokens, Models, and Events are all that you should be thinking of. Moose will think of the rest for you in a totally impersonal pre-thought-out fashion of course.
One more thing, this book goes about teaching Moose by comparing the "(old) perl way", with the "(new) Moose way." If this analogy bothers you, you can find the non-entertaining Moose docs on CPAN.
There is in addition a set of syntax docs in this book, which are surely more neutral.

## Footnotes

* ^ Moose is not a source filter. The syntax looks foreign to native perl because the idiom bareword=> is not adopted anywhere in the Perl example. Moose has no voodoo of the sourcefilter sort.
# Principles of Biochemistry/Glycolysis

Glycolysis is the first step of glucose catabolism. Glycolysis is divided into two categories: aerobic (chemical reactions that occur with the presence of oxygen) and anaerobic (chemical reactions that do not require oxygen). An example of anaerobic glycolysis is fermentation. Glucose is the reactant; while ATP and NADH are the products of the Glycolysis reaction. There are three stages in an aerobic glycolysis reaction: 1) decarboxylation of pyruvate 2) Citric Acid Cycle (also known as the Krebs Cycle) 3) Electron transport chain.
Glycolysis consists of a total of 10 chemical reactions that starts with the breakdown of glucose into pyruvate and NADH which takes place in the cytoplasm.
       This reaction is irreversible under intracellular condition, transferase class
       Catalyzed by hexokinase-soluble and cytosolic protein (glucokinase in liver)
       Requires ATP, and Mg2+ as substrates, generates ADP
       ΔG′°= -16.7 kJ/mol
       This reaction is reversible, isomerase class
       Catalyzed by phosphohexo isomerase
       Requires Mg2+ as a substrate
       ΔG′°= 1.7 kJ/mol
       Irreversible reaction, transferase class
       Catalyzed by phosphofructokinase-1 which is highly regulate allosteric enzyme
       Requires ATP, and Mg2+ as substrates, generates ADP
       ΔG′°= -14.2 kJ/mol
       Reversible reaction, lyase class
       Catalyzed by aldose
       Yields 2 different triose phosphates: G3P (an aldose), and DHAP (a ketose)
       ΔG′°= 23.8 kJ/mol
       Reversible reaction, isomerase class
       Catalyzed by triose phosphate isomerase
       ΔG′°= 7.5 kJ/mol
       Reversible reaction, oxidoreductase class
       Catalyzed by glyceraldehyde 3-phosphate dehydrogenase
       Requires NAD+, yields NADH
       ΔG′°= 6.3 kJ/mol
       Reversible reaction, transferase class
       Catalyzed by phosphoglycerate kinase
       Requires ADP and Mg2+, generates ATP
       ΔG′°= -18.5 kJ/mol
       Reversible reaction, isomerase class
       Catalyzed by phosphoglycerate mutase
       Requires Mg2+
       ΔG′°= 4.4 kJ/mol
       Reversible reaction,, lyase class
       Catalyzed by enolase
       ΔG′°= 7.5 kJ/mol
       Irreversible reaction, transferase class
       Catalyzed by pyruvate kinase
       Requires ADP, Mg2+, K+, generates ATP
       ΔG′°= -31.4 kJ/mol
       The product pyruvate first appears in enol form, then tautomerizes to keto form.
The net reaction for Glycolysis is :
Glucose+2ADP+2P$_1$+2NAD+ --> 2 Pyruvate + 2ATP+2NADH+2H$^+$+2H$_2$O
Fermentation Glycolysis in fermentation occurs under anaerobic condition, thus, NAD$^+$ has to be regenerated. In order to do obtain NAD$^+$, pyruvate is reduced into ethanol or lactic acid. During fermentation, only 2 ATP per glucose are produced; therefore, it is not too efficient. There are two types of fermentation: 1) Alcohol fermentation which occurs in yeast and some bacteria and 2) Lactic acid fermentation which occurs in some fungi and bacteria, and muscles cells.
# DESCRIPTION:

Returns TRUE for block values.
BLOCK? is an action value.

# ARGUMENTS

* value -- (Type: any-type)
# DESCRIPTION:

Returns the context in which a word is bound.
BOUND? is a native value.

# ARGUMENTS

* words -- (Type: any-word)
# DESCRIPTION:

Breaks out of a loop, while, until, repeat, foreach, etc.
BREAK is a native value.

# REFINEMENTS

* /return -- Forces the loop function to return a value.
** value -- (Type: any-type)
# Rebol Programming/brick

BRICK is a tuple of value: 178.34.34
# Rebol Programming/btn-dn.png

BTN-DN.PNG is an image of value:
# DESCRIPTION:

Returns the monochrome brightness (0.0 to 1.0) for a color value.
BRIGHTNESS? is a function value.

# ARGUMENTS

* color -- (Type: tuple)
# DESCRIPTION:

Opens the default web browser.
BROWSE is a native value.

# ARGUMENTS

* value -- The URL or file to open (Type: any-string)

# REFINEMENTS

* /only -- Don't open a new window if possible
# Rebol Programming/blue

BLUE is a tuple of value: 0.0.255
# DESCRIPTION:

Returns a copy of the body of a function or object.
BODY-OF is a function value.

# ARGUMENTS

* value -- (Type: any)
# Rebol Programming/brown

BROWN is a tuple of value: 139.69.19
# Programmable Logic/FPOAs

http://en.wikipedia.org/wiki/Field-programmable_object_array
# Programmable Logic/Further Reading
## Further Reading

* Xilinx.com
* Intel FPGA
* Lattice
* Synopsys
* Boltros, Nazeth M. "HDL Programming Fundamentals", ISBN 1584508558
* Wikiversity:Computer Architecture Lab discusses designing CPUs and then implementing them using a FPGA.
** Wikiversity Computer Architecture Lab FPGA tutorials

### Verilog Resources

* Verilog on Wikipedia

### VHDL Resources

* VHDL
* The Hamburg VHDL archive
** VHDL Cookbook (PDF)
* Ashenden, Peter J., "The Designer's Guide to VHDL", 2nd edition.
* Designers Guide to VHDL - ISBN 9780120887859
* www.opencores.org - A home of many open source VHDL and Verilog projects

### SystemC Resources

* SystemC on Wikipedia
* SystemC.org

### Wikibooks Resources

* Embedded Systems
* Digital Circuits
* VHDL for FPGA Design - Principles and Practices
* Semiconductors
* Logic for Computer Science
# Programmable Logic/Devices
## Devices

* PALs
* GALs
* Complex Programmable Logic Devices (CPLDs)
* Field Programmable Gate Arrays (FPGAs)
* Field Programmable Object Arrays (FPOAs)
# Programmable Logic/Cores and IP

Programmable logic cores or IP are pre-designed logic blocks that implement a certain functionality. The can be blocks that are embedded in the FPGA fabric (Hard Cores) or predesigned and debugged blocks that are implemented using the FPGA fabric (Soft Cores).

#### Cores and IP

* Hard Cores
* Soft Cores
# Programmable Logic/Debugging Designs

Debugging programmable logic designs is often a long and difficult task. HDLs give allow us to program PLDs with a the power of a higher level language. Unfortunately, the debugging of these designs is not as straight forward as debugging a C or Python program. There are some tools that help us in these departments, however. They are testbences, simulators, and integrated logic analyzers.
* Testbenches
* Simulators
* Integrated Logic Analyzers (ILAs)
# Programmable Logic/Design Basics
#### Design Basics

* Design Process
* Parallel Execution
* Timing and Synchronization
# Programmable Logic/Device Programming
## Device Programming

* JTAG
* EEPROMS
* Reconfiguration
# Python Programming/Internet

| Previous: Web Page Harvesting | Index | Next: Networks |
The urllib module which is bundled with python can be used for web interaction. This module provides a file-like interface for web urls.

## Getting page text as a string

An example of reading the contents of a webpage
Processing page text line by line:
Get and post methods can be used, too.

## Downloading files

To save the content of a page on the internet directly to a file, you can read it and save it as a string to a file object
This will download the file from here and save it to a file "pythonbook.pdf" on your hard drive.

## Other functions

The urllib module includes other functions that may be helpful when writing programs that use the internet:
The urlencode function, described above converts a dictionary of key-value pairs into a query string to pass to a URL, the quote and quote_plus functions encode normal strings. The quote_plus function uses plus signs for spaces, for use in submitting data for form fields. The unquote and unquote_plus functions do the reverse, converting urlencoded text to plain text.

## Email

With Python, MIME compatible emails can be sent. This requires an installed SMTP server.
This sends the sample message from 'sender@example.com' to 'receiver@example.com'.

## External links

* urllib.request, docs.python.org
* HOWTO Fetch Internet Resources Using The urllib Package, docs.python.org
* urllib2 for Python 2, docs.python.org
* HOWTO Fetch Internet Resources Using urllib2 — Python 2.7, docs.python.org
| Previous: Web Page Harvesting | Index | Next: Networks |