OpenLLM-France/wikimedia huggingface dataset:
# Scribbling On Regardless/Making ArtDice

This project is about making Art Dice - roll the dice and decide which arty activity you should do! A fun way to get ideas, or get you through any artistic block. Your art ideas can go in the sketchbook you made in the first activity.

### Materials you'll need for the art dice

* Art Dice template (see below)
* Colouring pens or pencils
* Glue
* Scissors

### Instructions

Watch our video for a step-by-step guide
* Print out / trace your art dice template
* Give you art dice some background colour - the more vibrant and bright the better!
* You've got 2 dice for a reason - one is for activity, and one is for subject.
* Decide which activities you want on the first one - drawing, painting, collage, stickers... and write one on each side of the dice
* Decide which subjects you want for the second one - out your window, animals, food... and write one on each side of the other dice
* Carefully cut out your dice
* Fold over the dotted lines, and glue together
* Now get rolling!
Art Dice templates - click to expand
* Large Art Dice template
* Small Art Dice template

## Next Project

3 Colour Drawing

## Previous Project

Making a BoomBuddy
# Screen Printing/Finishing Up

Different inks and materials will require different treatments after printing. Most fabric ink require you to use a clothes iron on the printed fabric after the ink dries, in order to heat set the ink so it won't wash out in the washer. Read the instructions for your ink to see what is required.

## Reclaiming

After you've printed, you can save your stencil indefinitely, but obviously you can't reuse the same screen for another stencil, without first removing the old stencil. The process of removing a stencil from the screen is called reclaiming the screen, and it's usually just a matter of applying a special chemical to remove the photo emulsion. Remember that once exposed, water alone is not enough to wash out the emulsion. Fortunately, a number of different solutions are available that will wash out exposed emulsion. Check the instructions for your emulsion to see what it recommends, but usually a low strength paint thinner will work, or you can buy a solution called Stencil Remover quite cheaply and this does the trick well. You simply pour a small amount of the solution over the stencil, rub it in, and then wash it out. The emulsion should wash out with it.
As an alternative, it is possible to remove a screen from the frame, so you can save the stencil and still have the frame available for new stencils. Stretch another screen over the frame and you're good to go. If you're careful removing the stencil, you should be able to reapply it to a frame at a later time if you decide you want to print it again. This way, you only need a few frames, but you can create a veritable library of stencils which you can reuse whenever you want.
# Screen Printing/Making the Print

Printing is a pretty simple procedure though it takes some practice to really master it. With the frame turned upside down (flat side down) you add a line of your printing ink to one edge of the screen. Using a rubber squeegee, you smooth the ink over the entire stencil. This is called the flood stroke and the purpose is to fill the stencil with ink. Next you place the stencil on the item you`re printing on, still flat side down, and use the squeegee again, this time moving in the opposite direction, to spread the ink over the stencil and force it through the screen. That's all there is to it. Most ink should just wash off the screen with tap water without disturbing the stencil. Once it's dry you're ready to print again. Or if you're using the same color, you can print right away, just don't let the paint dry too much on the stencil, it could be difficult to wash out without destroying the stencil.
# Scribbling On Regardless/3 Colour Drawing

Fun & easy drawings using only three colours! See what ideas you can come up with when you're limited to just three colours... no more, no less...

### Materials you'll need

* Paper (use your sketchbook)
* 3 colours of pen or pencil

### Instructions

Watch our video for a step-by-step guide
* Test out your colour combinations in your sketchbook or on a spare piece of paper
* How do they look together? What different styles and patterns can you make?

#### Cityscape

* Try doing a cityscape, like in the video. At its most basic, you draw a square, and then make it a cube with three diagonal lines, and then join and connect them.
* How do different cubes and boxes fit together?
* Add windows to your buildings - maybe a door, or a chimney? Is there a garden? What's in the garden?

#### Stack 'em up

* Start with a small idea - like a star - at the bottom of your page
* Draw different bubbles stacked on top of each other - each one must be connected to the bit below it
* Now turn each of these into a character - what faces are they pulling? Are they wearing a hat? Do they have different clothes?

## Next Project

Making Stickers

## Previous Project

Making ArtDice
# Parrot Virtual Machine/JIT and NCI
## JIT and NCI

JIT, the Just in time compiler is a system which compiles Parrot opcodes into native machine code for faster execution. NCI, the native call interface is a subsystem in Parrot that allows it to communicate with compiled library functions. These two systems are very important for Parrot and, as we shall see, they are closely related to one another.
# Parrot Virtual Machine/HLL Interoperation
## HLL Interoperability

Parrot was designed not just for Perl6, even though that was one of the bigger driving forces initially. Parrot is being designed and implemented to be a virtual machine for all dynamic programming languages (and even a few statically-typed ones too). The ultimate goal is to be able to combine tools and libraries written in various languages together, and allow developers to write different parts of a project in the language that makes the most sense to that project.
Parrot makes interoperability easy, but it's ultimately the responsibility of the language designers to make sure that their languages play nicely with others.

## Sharing Data
### Vtables: Standard Interfaces

All PMC objects implement the standard vtable functions, and these are to be the primary interface for dealing with foreign or exotic data types. If you receive a Ratio object from common LISP, you might not know what it's methods are, or what it's internal storage structure is when you use it from Perl 6. However, by calling the standard vtable methods, you can interact with it in an easy way.

### .HLL_map PMC Mapping
## Sharing Functions
### Multi Methods

Like many modern programming languages, Parrot allows function name overloading. Called multiple method dispatch (MMD), Parrot's function call system is very powerful and flexible. In the MMD system, multiple functions in a single namespace can have the same name, so long as they have different call signatures. A call signature specifies the number and type of parameters and return values that the function expects. If we call a function:
Parrot only calls a function Foo if it has three inputs and four outputs. Multiple dispatch isn't just used for functions, it's also used for opcodes. A program (or, more likely an HLL) can add new opcodes with the same name as an existing opcode, so long as it uses a different function signature. This allows a very powerful and flexible way to customize your system.
We will talk more about MMD in a later chapter.

### Translation Interfaces

The idea of including some sort of translation interface, functions that would automatically convert calls from one HLL to appropriate calls to another, has been attractive to some developers. However, there is a large associated development cost because for n languages we would require $n^{2}$ interfaces to translate to and from them all. Because of this additional complexity cost, it is not recommended to handle data or function sharing using interfaces.

## Documentation

The most important thing a language developer can do is document their interfaces. It is important to document what data types a function expects and what data types it returns. This way, a person using these libraries from a different languages know how to interact with these functions and objects.
Plus, documentation may expose some functions or objects as being overly difficult for reuse. This will help deter developers from using a complicated interface. It will also help to expose to the library designers ways to simplify their library.
# Parrot Virtual Machine/IO Subsystem
## Resources

* http://www.parrotcode.org/docs/pdd/pdd22_io.html
# Parrot Virtual Machine/Exception Subsystem

Exception handling has become a staple in most modern programming languages. Parrot, since it intends to host many such languages must support a robust exception system. Not only does Parrot use exceptions for error handling and recovery, but it also encourages the use of control flow exceptions to implement high-level control flow features of those languages as well. What this means is that the exception subsystem is one of the most important for language implementers to become familiar with.

## Exceptions: The Basics

Exceptions are broken down into two primary parts: the exception object and the exception handler. Exception handlers are like subroutines in many ways, and must be specially registered with Parrot before they can be used. When Parrot detects an error, it creates an exception object by including information about the error, a continuation for the current control flow state, and a few other pieces of information. Exceptions, like most everything else in Parrot, are PMCs and can be stored, manipulated, and used like other PMCs.
Once the exception object is created, Parrot looks through its list of handlers, and passes its exception object to each. Handlers are stored in a stack-like structure, and the most recently registered handler will have the first access to the exception object. The handler can do one of several things. First, it can handle the exception: It can fix the error, call the return continuation that is within the exception object, and returns control flow back to where it was before the error occurred. Second, it could re-throw the exception, passing it to the next handler in the stack. Third, it could ignore the exception. Exceptions which are ignored, or for which no handlers are available, cause Parrot to exit.
# Parrot Virtual Machine/IMCC and PIRC
## IMCC and PIRC

IMCC and PIRC are two separate parsers for PIR and PASM. Both are written using Lex and Yacc.

## IMCC

IMCC, the Intermediate Code Compiler is the current front-end for Parrot that reads PASM and PIR code. It's a relatively old subsystem, and has proven itself difficult to extend or maintain. IMCC will likely be the "official" parser for PIR and PASM until the Parrot 1.0 release. However, the plan for the future is to move to a more extensible and more manageable parser, such as PIRC.
IMCC is written using a combination of a Lex tokenizer and a Yacc parser. It includes a number of components, such as register allocators, and code optimizers.

## PIRC

PIRC is, in theory anyway, a better alternative to parsing PIR and PASM than IMCC is. However, PIRC is not currently complete, and does not offer the feature set of IMCC yet. There are two different implementations of PIRC: one is a hand-written recursive descent parser, and the other is based on a multi-stage Lex/Yacc parser. The old version, the hand-written recursive descent version, is obsolete and is no longer maintained. We will only talk about the new implementation of PIRC here.
PIRC is divided into three different parsers:
* A parser for "Heredoc" constructs, strings which are embedded directly into the file.
* A macro parser and text replacer. This is a preprocessor for handling macros and constants.
* A parser for the rest of PIR and PASM
Breaking things up like this proves to keep things much more simple, and reduces the number of states and conditionals that a single large parser would require.

## PIRC Current Status

PIRC is intended to replace IMCC as the primary front-end to Parrot. However, this changeover might not be made until after the 1.0 release of Parrot. In other words, it's an important development, but the Parrot developers aren't going to wait around for it.
# Parrot Virtual Machine/Extensions
## Extending Parrot

Parrot is not just an executable VM, it's a dynamically-linkable library that exports a Parrot API. The API allows add-ons to be developed to extend the functionality of Parrot.
There are two basic APIs or, more specifically, a single API that can be divided into two distinct categories: Those that have access to the internals of Parrot, and those that do not. In general, most extensions will not need deep internal access to Parrot's structures, and most should not rely on them. Parrot's internal structures are subject to change, and relying on a precise format of one for your extension could cause compatibility problems later on.
# Parrot Virtual Machine/Languages on Parrot
## Languages on Parrot

There are a number of programming languages being implemented on Parrot, some of which are nearing functional completion, some which are still in active development, and some which have been started but are now abandoned. Interested developers may want to help join in the development effort with some of these languages, adopt an abandoned language project, or start a new language project entirely.
As of the 1.0.0 release, all language implementations except toy and example languages will be developed and maintained outside of the central Parrot repository. Where available, locations to external project pages will be provided.

## Language Projects
### Rakudo (Perl 6)

Rakudo is the name of the Perl6 implementation on Parrot. This is not the only implementation of Perl6, however.
Rakudo development is test-driven. There is a gigantic suite of tests for the Perl6 language that have been developed over the years. The progress of the Rakudo interpreter is measured by the number of specification tests, or "spectests" that pass. There is not a straight-forward way to measure the percentage progress of the project, because the total number of tests is changing regularly as well.
Rakudo is under active development by several volunteers. Some developers have even received funding to work on Rakudo more regularly.

### abc

A basic calculator language.

### C99

The implementation of the C programming language, following the C99 specification, has a number of purposes. C is a strongly-typed language, so it isn't necessarily the best candidate for implementation on the dynamically-typed Parrot. However, there are a number of benefits to the Parrot project to having a C parser available.
The C99 language parser is being used, at least in part, to help automate the process of generating NCI function signatures for new libraries and extensions. This is under active development by volunteers, some of which have been funded.

### Cardinal (Ruby)

An implementation of Ruby

### Jako

A language derived from C and Perl

### Pipp (PHP)

Pipp is a recursive acronym for Pipp is Parrot's PHP. This language implementation was previously named "Plumhead", shorthand for the name "Plum-headed Parakeet". Pipp is being maintained on github at pipp. The project seems halted: the website is down/missing and the last commit was at 2009-07-22.

### Partcl (TCL)

ParTCL is the TCL compiler for Parrot. The ParTCL project lives at http://code.google.com/p/partcl/

### Zcode
## Translator Projects

Projects to translate to or from Parrot Bytecode.

## Resources

* http://www.parrot.org/languages/
# Parrot Virtual Machine/Command Line Options
## Resources

* http://www.parrotcode.org/docs/running.html
# Parrot Virtual Machine/Exception Handling
## Exceptions

Exceptions are errors that are caused in a program. However, unlike an ordinary error which causes the program to terminate unexpectedly, exceptions are controlled and can be recovered from without having to restart the program.
In Parrot, exceptions are objects. This means you create an exception using the new keyword, and manipulate an exception using methods on that object. Before we discuss exceptions any further, we need to discuss some terminology. Readers who are familiar with exceptions in other programming languages can probably skip these definitions.

### Throw

    To throw an exception means to create an exception object. Once an exception has been created, the system enters a kind of "panic state" where it attempts to fix the exception. If the exception cannot be fixed, the program terminates.

### Raise

    To raise an exception is the same as to throw one.

### Handler

    A handler is a routine which can fix an exception. When an exception is raised and the system enters panic mode, it looks for a handler. If there is a handler available, the exception is sent to that handler. If no handlers are available to handle the exception, the system will terminate.

### Catch

    A handler that receives an exception object is said to "catch" it. Whenever an exception is thrown, a handler should be available to catch it. Again, if no handlers are available to catch an exception, Parrot will exit.

### Rethrow

    All handlers are not equipped to handle all exceptions. If a handler catches an exception that it cannot fix, it can optionally rethrow that exception. Rethrowing causes the system to search for a different handler.

## Creating an Exception

Creating a new exception object in PIR is deceptively simple:
Exceptions are hash-like, which means they have named fields. One such field is the '_message' field, which contains the name of the exception. Exception handlers will check the name to determine if they can handle a particular exception, or if it needs to be rethrown.

## Creating a Handler

In Parrot, a handler is a label that the system jumps to in the event of an exception. These labels are stored in a stack structure. The exception handler on the top receives the instruction, but if it rethrows, the exception will be propagated down through the exception stack until it is finally handled.

## Resources

* http://www.parrotcode.org/docs/pdd/pdd23_exceptions.html
# DESCRIPTION:

Returns the first value exclusive ORed with the second.
XOR~ is an action value.

# ARGUMENTS

* value1 -- (Type: logic number char tuple binary string image)
* value2 -- (Type: logic number char tuple binary string image)
# Rebol Programming/zero

ZERO is an integer of value: 0
# DESCRIPTION:

Returns TRUE if the number is zero.
ZERO? is an action value.

# ARGUMENTS

* number -- (Type: number pair char money time tuple)
# Recipes for the Design of Experiments
## Short Description:

This book covers practical examples of the statistical design of experiments for systematically testing hypotheses (ideas) about how a system under test behaves. The examples will be based on the setting, design, analysis paradigm and include R code for the design and analysis. The aim is to provide examples that readers can use in their own work. Topics to be covered are:
* The scientific method, randomized controlled trials, one factor at a time experiments and reproducible research
* Tools for reproducible research and the R project for statistical computing
* A review of descriptive and inferential statistics
* Experiments with a Single Factor: One Way ANOVA
* Experiments with More Than One Factor
* Full Factorial Experiments at Two Levels
* Fractional Factorial Experiments at Two or Three Levels
* Regression Models
* Response Surface Methodology
* Taguchi Designs and Quality Control
Work will begin on August 29, 2016 with contributions from students in the Rensselaer classes ISYE 4330 and ISYE 6020: The Design of Experiments.
* Chapter 0: Preliminaries: From Edison to Taguchi
* Chapter 1: One Factor, Two Level Experiments
* Chapter 2: Two or More Factors
* Chapter 3: Completely Randomized Designs
* Chapter 4: Completely Randomized Block Designs from the literature
* Chapter 5: Blocked Designs with multiple explanatory and nuisance factors
* Chapter 6: The Analysis of Covariance
* Chapter 7: Resampling Methods
* Chapter 8: Fractional Factorial Designs
* Chapter 9: Response Surface Methods
* Chapter 10: Taguchi Designs
* Appendix A: Biographies
# Rebol Programming/yellow

YELLOW is a tuple of value: 255.255.0
# Rebol Programming/yello

YELLO is a tuple of value: 255.240.120
# Rebol Programming/yes

YES is a logic of value: true
# Secret of Mana/Walkthrough

* Chapter 1: The Mana Sword
* Chapter 2: Potos and the mana knight
* Chapter 3: Luka
# Secret of Mana/Walkthrough/Chapter 1

At the beginning of the game, Randi (the main character) and two of his friends are playing on a bridge over a waterfall. Suddenly Randi falls from the bridge and finds himself trapped by undergrowth. The only way to return to his hometown, is to find some kind of knife or sword to cut the undergrowth away.
After you fall from the bridge, go to the south, where you can leave the river bed. Keep on going to the south, and you will suddenly hear a voice calling your name. Cross the small bridge which leads over the river, and go to the north. You will pass the undergrowth, where Randi mentions that he needs something to cut it away. Now enter the river bed again and you will soon see a sword stuck in a stone - the mana sword.
Make sure that you stay in front of it, and press the "B"-Button. Randi then pulls the sword out of the stone and a ghost appears for a few seconds. Now go to the undergrowth again and cut it away, by pressing the "B"-Button. Then follow the path to the right, where you will fight your first monster.
This monster, called Rabite, is a rather weak one. Two hits with Randi's sword should be enough to kill it. Now follow the path through the woods, where you will com across other rabites. After you've killed several of them, your sword reaches a new level. That means that Randi can use better techniques, by holding the "B"-Button for a few seconds.
Cross two bridges and you will soon reach Potos, Randi's hometown.
Continue to Chapter 2.
# Pinyin/Foreign language

See also
Search Pinyin language
# Pinyin/Force

In physics, a force is an effect that causes things to move in a particular way.
zaih wuhliixuer, lih shih daaozhih wuhtii xiahng tehdihng fangxiahng yirdohng d xiaohyihng.
# Pinyin/Form
## Noun

* a form is the shape of somebody or something.
** xirngzhuahng shih moourern huoh moouwuh d yahng'zi.
# Pinyin/Former

Search former
# Pinyin/Foreigner

A foreigner is a person who comes from another country.
waihguorrern shih lairzih bierd guorjia d rern.
# Pinyin/Foshan

See also
# Pinyin/Foreign

See also
# Pinyin/Found

See also
# Robotics/Computer Control/The Interface

This chapter covers the hardware and its interface used to control the robot.
* Computers
* Single Board Computers and multichip modules/
* Microcontrollers
* Remote Control (wired)
* Communication Sensors (wireless)
* Networks