text:
User:TimMartin~enwikibooks

Tim Martin - Designer, Lecturer and Typographer Design & Research The Type Museum

title: User:TimMartin~enwikibooks


text:
User talk:61.145.130.190

Please stop. If you continue to use Wikibooks for advertising, you will be temporarily blocked from editing.

 * 17:55, 15 Dec 2004 (CET) - Placed spam on the page: Study help desk

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

title: User talk:61.145.130.190


text:
Talk:Objective-C Programming

While this is a great start, wouldn't it maybe be better to start from a total beginner's perspective on programming? There's no explaination of what a "method" is, for example. Unless knowledge from other OO programming languages are required reading, in which case why is OO programming defined here? ;) Sort of inconsistant.

Objective-C Programming as a name would be more in line with C Programming and C++ Programming Otus 11:52, 3 June 2007 (UTC)

title: Talk:Objective-C Programming


text:
Talk:Objective-C Programming/concepts

The word processor analogy is a bit, hard for a beginner to grasp here. I understand it, but a new programmer may not, or at the very least will likely have a hard time understanding the relationship. In "Programming in Objective-C" by Stephen G. Kochan he uses a car analogy. Might we strive for something a little easier and more simple to understand.

A car is developed from a blue print, or a concept car. Each car that you can buy is an instance of this blue print or concept car. Each instance of this car is an Object Something along those lines?

Or possibly we can relate it to the human body which most people who can read out to understand at this point in their lives.

The human body is an object. The human body is created from a blueprint (our genes). Each person is an "instance" of the human body. I can see this might be more difficult, but I'd almost try to find something like a Car or what have you that you can then break down, a car has an engine, a gas tank, a stereo, etc. This way the example can be used again when describing inheritance later on.

title: Talk:Objective-C Programming/concepts


text:
Cookbook:Choucroute (Sauerkraut with Meat and Potatoes)

| Alsatian recipes

Choucroute garnie is a dish of Sauerkraut with sausages, salt pork, and potatoes. Being a little picky about your ingredients (especially the sauerkraut) with this recipe makes all the difference.

Ingredients

 * 1 or so tablespoons of duck fat
 * 1 medium onion, finely chopped
 * 2–3 small potatoes
 * 5 juniper berries
 * 1 clove
 * 1–2 garlic cloves
 * 1 or so tablespoons of coriander seed
 * ½ tablespoon black mustard seed
 * 2 strips of bacon (or the same amount of salted pork belly), sliced into rough squares
 * 1 pound of sauerkraut
 * 4 pork sausages
 * 3 smoked pork slices, bone in
 * 1 cup (240 ml) or so of white wine (dry)

Procedure

 * 1) In a pot large enough to in the end hold everything, melt the duck fat over medium heat.
 * 2) When hot, add the onions and sauté until translucent (about 5 minutes or so).
 * 3) Then, add the sauerkraut, white wine, juniper berries, clove, coriander seed, mustard seed, and garlic.
 * 4) Add the smoked pork and bacon.
 * 5) Cover, and then simmer for about 2 hours.
 * 6) In other pot, simmer the peeled potatoes and your sausages—don't boil, or your sausages will split open.
 * 7) Simmer until potatoes are done (and by then the sausage will be, too).
 * 8) Serve in a heap—sauerkraut at the bottom, various pig and potato parts on top.

Livre de cuisine/Choucroute 2


text:
Color Theory

“In visual perception, a color is almost never seen as it really is—as it physically is.”—Josef Albers

Color is fundamental to many forms of art. Its relevance, use and function in a given work depend on the medium of that work. While some concepts dealing with color are broadly applicable across media, others are not.

The full spectrum of colors is contained in white light. Humans perceive colors from the light reflected off objects. A red object, for example, looks red because it reflects the red part of the spectrum. It would be a different color under a different light.

Light can be split up into a spectrum by sending it through a prism. This was discovered by Isaac Newton, who is the creator of color theory.

Color Theory
The study of color in art and design often starts with color theory. Color theory splits up colors into three categories: primaries, secondaries, and tertiaries.

The basic tool used is a color wheel, developed by Isaac Newton in 1666. Another model, the color tree, was created by Albert Munsell. It has a spectrum made up of sets of tints and shades on connected planes.

Theory Variations
There are a number of approaches to organizing colors into meaningful relationships. Most systems differ in structure only. Among these, three systems are consistently used in the contemporary art world.

Traditional Model
Traditional color theory is a qualitative attempt to organize colors and their relationships. It is based on Newton's color wheel, and continues to be the most common system used by painters and printmakers.

 * Traditional color theory uses the same principles as subtractive color mixing (see below) but prefers different primary colors.

 * The Primary colors are red, blue, and yellow. These are the "elemental" colors, because they cannot be produced by mixing other colors together, and all other colors are derived from some combination of these three.

 * The Secondary colors are orange (mix of red and yellow), green (mix of blue and yellow), and purple (mix of blue and red).

 * The Tertiary colors are obtained by mixing one primary color and one secondary color. Depending on amount of color used, different hues can be obtained such as red-orange or yellow-green. Neutrals (browns and grays) can be made by mixing all three primaries together.

 * White and black lie outside of these categories. They are used to lighten or darken a color. A lighter color (made by adding white to it) is called a tint, while a darker color (made by adding black) is called a shade.

Color Mixing
A more quantifiable approach to color theory is to think about color as the result of light reflecting off a surface. Understood in this way, color can be represented as a ratio of amounts of primary color mixed together. In this system, primary colors are chosen by dividing up the visible spectrum into thirds and making each third a primary.

Whether a color is being determined by the light source being reflected or the surface reflecting it makes a significant difference in the way colors interact with one another. This distinction is blurred when working with digital technology where production environments and product often move fluidly between these media types.

 * Additive color theory is used when different colored lights are being projected on top of each other. Projected media produce color by projecting light onto a reflective surface.  Where subtractive mixing creates the impression of color by selectively absorbing part of the spectrum, additive mixing produces color by selective projection of part of the spectrum.  Common applications of additive color theory are theater lighting and television screens.  RGB color is based on additive color theory.

 * The Primary colors are red, blue, and green.

 * The Secondary colors are yellow (mix of red and green), cyan (mix of blue and green), and magenta (mix of blue and red).

 * The Tertiary colors are obtained by mixing the above colors at different intensities.

 * White is created by mixing the three primary colors while black represents the absence of all colors. The lightness or darkness of a color is determined by the intensity/density of its various parts.  For instance: a middle-toned gray could be produced by projecting a red, a blue and a green light at the same point with 50% intensity.

 * Subtractive color theory ("process color") is used when a single light source is being reflected by different colors laid one on top of the other. Color is produced when parts of the external light source's spectrum are absorbed by the material and not reflected back to the viewer's eye.  Subtractive color works as the reverse of additive color theory.  Common applications of subtractive color theory are color printing and photographic positives and negatives. The CMYK color model uses subtractive color theory. It was developed by Herbert Ives for printing.

 * The Primary colors are yellow, cyan, and magenta.

 * The Secondary colors are red (mix of magenta and yellow), blue (mix of cyan and magenta), and green (mix of cyan and yellow).

 * The Tertiary colors are obtained by mixing the above colors at different intensities.

 * Black is created by mixing the three primary colors while white represents the absence of all colors. (However, since it is impossible to mix a perfect black, and in order to save money and paper drying time, devices using process colors add black as a fourth "color." CMYK stands for Cyan, Magenta, Yellow, and Key (i.e., black). Similar to additive color theory, lightness/darkness is determined by color intensity/density.

Color Interactions
Beyond creating a mixing hierarchy, color theory also provides tools for understanding how colors work together.

Analogous Colors
Analogous colors are similar to one another. As their name implies, analogous colors can be found next to one another on any 12 part color wheel.

 * Common analogous colors can be found by taking one tertiary color and one of the secondary colors used by it when creating that tertiary color. note: examples using traditional color theory

 * purple/blue-purple.

 * green/yellow-green.

 * orange/red-orange.

A warm/cool scheme uses two pairs of analogous colors; one warm pair and one cool pair. (Intermixing should only be done within the pairs.)

Complementary Colors
Complementary colors are pairs of colors which, if added, would produce complete color saturation—white or black depending on the type of mixing you're doing. Complementary colors are found directly opposite one another on a color wheel.

 * Common complementary colors can be found by taking one secondary color and the primary color not used when creating that secondary color. note: examples using traditional color theory

 * violet/yellow.

 * green/red.

 * orange/blue.

 * white/black. Though they are not represented on the color wheel, adding white to black will always result in complete color saturation regardless of mixing method.

A double complementary scheme is made up of two complementary color pairs. (Intermixing may be done, but only within the pairs.)

A split complementary uses three hues, one color, and two others which are on each side of that hue's complement on the color wheel.

See also
 * color harmony

Attributes
The three attributes of color are hue, saturation, and value.

Hue
A hue is a pure, spectral color. Black and white are not hues.

Values
Color values range from low key (very dark) to high key (very light). 1 is absolute black, and 10 is pure white. Yellow is the hue with the lightest value, while violet is the darkest.

The value of a color can make a difference in how it is perceived. A color on a dark background will appear lighter, while that same color on a light background will appear darker.

Other Considerations
Other factors that affect how a piece looks are perception, and local color. Under what conditions will the piece be viewed? Since most art and design is looked at under ordinary (white) light, designers often buy bulbs that recreate that light.

Color quality is another concern. This can be affected by opacity or texture of media, or glossiness of surface.

Color Subtraction
A visual phenomenon where the appearance of one color will lessen its presence in a nearby color. For instance, orange (red + yellow) on a red background will appear more like yellow (RY − R = Y).

Simultaneous Contrast
Neutrals on a colored background will appear tinted toward that color's complement, because the eye attempts to create a balance. (Grey on a red background will appear more greenish, for example.) In other words, the color will shift away from the surrounding color.

Also, non-dominant colors will appear tinted towards the complement of the dominant color.

Color interaction affect values, as well. Colors appear darker on or near lighter colors, and lighter on or near darker colors. Complementaries will look more intense on or near each other than they will on or near grays.

Color for programmers
Color spaces

Color in scientific data visualisation

Misconceptions about colors
=See also=
 * Color Models: RGB, HSV, HSL from a computer graphics (Web page, image) perspective
 * Commons:Category:Color_theory

title: Color Theory


text:
User:Jkh.gr~enwikibooks

My WikiPage

title: User:Jkh.gr~enwikibooks


text:
Ada Programming/Tips

Full declaration of a type can be deferred to the unit's body
Often, you'll want to make changes to the internals of a private type. This, in turn, will require the algorithms that act on it to be modified. If the type is completed in the unit specification, it is a pain to edit and recompile both files, even with an IDE, but it's something some programmers learn to live with.

It turns out you don't have to. Nonchalantly mentioned in the ARM, and generally skipped over in tutorials, is the fact that private types can be completed in the unit's body itself, making them much closer to the relevant code, and saving a recompile of the specification, as well as every unit depending on it. This may seem like a small thing, and, for small projects, it is. However, if you have one of those uncooperative types that requires dozens of tweaks, or if your dependence graph has much depth, the time and annoyance saved add up quickly.

Also, this construction is very useful when coding a shared library, because it permits to change the implementation of the type while still providing a compatible ABI.

Code sample:

Private_And_Body Private_Type  ; Body_Type; Private_Type  Body_Type; Private_And_Body;

The type in the public part is an access to the hidden type. This has the drawback that memory management has to be provided by the package implementation. That is the reason why Private_Type is a limited type, the client will not be allowed to copy the access values, in order to prevent dangling references.

Normally, the full type definition has to be given in the specification because the compiler has to know how much place to allocate to objects in order to produce code using this type. And the astute reader will note that also in this case the full type definition is given for Private_Type: it is an access to some other (albeit incomplete) type, and the size of an access value is known. This is why the full type definition of Body_Type can be moved to the body.

The construction centering around Private_Type is sometimes called an opaque pointer.

Lambda calculus through generics
Suppose you've decided to roll your own set type. You can add things to it, remove things from it, and you want to let a user apply some arbitrary function to all of its members. But the scoping rules seem to conspire against you, forcing nearly everything to be global.

The mental stumbling block is that most examples given of generics are packages, and the Set package is already generic. In this case, the solution is to make the Apply_To_All procedure generic as well; that is, to nest the generics. Generic procedures inside packages exist in a strange scoping limbo, where anything in scope at the instantiation can be used by the instantiation, and anything normally in scope at the formal can be accessed by the formal. The end result is that the relevant scoping roadblocks no longer apply. It isn't the full lambda calculus, just one of the most useful parts.

Element ; Sets Set ; [..]      Apply_To_One (The_Element :   Element); Apply_To_All (The_Set :  Set); Sets;

For a view of Functional Programming in Ada see.

Compiler Messages
Different compilers can diagnose different things differently, or the same thing using different messages, etc.. Having two compilers at hand can be useful.

 * : When a source program contains a construct such as, you may see messages saying something like «selected component "Bar"» or maybe like «selected component "Foo"». The phrases may seem confusing, because one refers to  , while the other refers to  . But they are both right. The reason is that selected_component is an item from Ada's grammar . It denotes all of: a prefix, a dot, and a selector_name. In the   example these correspond to  , ' ', and  . Look for more grammar words in the compiler messages, e.g. «prefix», and associate them with identifiers quoted in the messages.

 * For example, if you submit the following code to the compiler,

Pak Foo T  PakBar Foo

 * the compiler may print a diagnostic message about a prefixed component: 's author thought that   denotes a package, but actually it is the name of a generic package. (Which needs to be instantiated first; and then the instance name is a suitable prefix.)

Universal integers
All integer literals and also some attributes like  are of the anonymous type universal_integer, which comprises the infinite set of mathematical integers. Named numbers are of this type and are evaluated exactly (no overflow except for machine storage limitations), e.g.

Very_Big: := 10**1_000_000 - 1;

Since universal_integer has no operators, its values are converted in this example to root_integer, another anonymous type, the calcuation is performed and the result again converted back in universal_integer.

Generally values of universal_integer are implicitly converted to the appropriate type when used in some expression. So the expression  is fine; the value of   is interpreted as a modular integer since  can only be applied to modular integers (of course a context is needed to decide which modular integer type is meant). This feature can lead to pitfalls. Consider

Ran_6  1  6 Mod_6  6

and then

A Ran_6 …     A  Ran_6 …    ( A)  Ran_6 …    A  1  6 …     A  1  6 …    A  Mod_6 …     A  Mod_6 …

 * The second conditional cannot be compiled because the expressions to the left of  is incompatible to the type at the right. Note that   has precedence over  . It does not negate the entire membership test but only.

 * The fourth conditional fails in various ways.

 * The sixth conditional might be fine because  turns   into a modular value which is OK if the value is covered by modular type.

 * GNAT GPL 2009 gives these diagnoses respectively:

error: incompatible types error: operand of not must be enclosed in parentheses warning: not expression should be parenthesized here

 * A way to avoid these problems is to use  for the membership test (which, btw., is the language-intended form),

A  Ran_6 …

 * See
 * ), and
 * Membership Tests
 * Membership Tests
 * Membership Tests
 * Membership Tests

Text_IO Issues
A canonical method of reading a sequence of lines from a text file uses the standard procedure .Get_Line. When the end of input is reached, Get_Line will fail, and exception End_Error is raised. Some programs will use another function from to prevent this and test for End_of_File. However, this isn't always the best choice, as has been explained for example in a Get_Line news group discussion on comp.lang.ada.

A working solution uses an exception handler instead:

The_Line String1100 Last Natural Text_IOGet_LineThe_Line Last Text_IOEnd_Error

The function End_of_File RM A.10.1(34) works fine as long as the file follows the canonical form of text files presumed by Ada, which is always the case when the file has been written by. This canonical form requires an End_of_Line marker followed by an End_of_Page marker at the very end before the End_of_File.

If the file was produced by another any other means, it will generally not have this canonical form, so a test for End_of_File will fail. That's why the exception End_Error has to be used in those cases (which always works).

Quirks
Using GNAT on Windows, calls to subprograms from might need special attention. (For example, the  function might seem to return values indicating that no time has passed between two invocations when certainly some time has passed.) The cause is reported to be a missing initialization of the run-time support when no other real-time features are present in the program. As a provisional fix, it is suggested to insert

00

before any use of  services.

Stack Size
With some implementations, notably GNAT, knowledge of stack size manipulation will be to your advantage. Executables produced with GNAT tools and standard settings can hit the stack size limit. If so, the operating system might allow setting higher limits. Using GNU/Linux and the Bash command shell, try

$ ulimit -s [some number]

The current value is printed when only  is given to ulimit.

Wikibook

 * Ada Programming
 * Ada Programming/Errors

Ada Reference Manual

|Tips

title: Ada Programming/Tips


text:
Talk:Linear Algebra

New book conversion more or less finished, Current LMOS
The conversion form Jim Heffron's book to wikibooks is now more or less complete. There are still a number of pages from the old book which can be found at Linear Algebra/OLD/TOC. These pages should either be merged, or (I think) could be used as a seed for a more advanced book on linear algebra for Mathematics majors. In terms of a local MOS, all mathematics is contained between $$$$, regardless of inline or displayed. Theorems, lemmas, remarks, examples, exercises, etc. should be in a. The book is written in American English. Thenub314 (talk) 15:00, 1 May 2010 (UTC)

Duplicate page
There is both a page http://en.wikibooks.org/wiki/Linear_Algebra/Eigenvalues_and_eigenvectors (no capital letter) and http://en.wikibooks.org/wiki/Linear_Algebra/Eigenvalues_and_Eigenvectors (with capital letter) But these are different pages. The table of contents of this book links to the latter, which seems to be the most maintained. But the wikipedia article about eigenvalues/vectors links to the former. Maybe the former should be removed and the wikipedia article changed? --87.65.116.226 (talk) 13:32, 12 June 2010 (UTC)

Suggested points of discussion from failed WB:Featured books/Nominations
I think what happens next is discussion continues in the book's discussion pages by book contributors and those with issues with the book. Things to consider discussing more in the book's discussion pages might be: --dark lama  10:52, 2 July 2010 (UTC)
 * 1) Does the book need a new name?
 * 2) Does the scope and audience of the book need to be better defined?
 * 3) Do parts need to be rewritten to be easier to follow and understand?
 * 4) Can missing material be added to reduce or eliminate a need to depend on Wikipedia links?
 * 5) How can this book be made better?

Orphaned pages

 * Linear Algebra/Inner product spaces
 * Linear Algebra/Topic: Crystals/Solutions
 * Linear Algebra/Topic: Linear Recurrences/Solutions

These are not linked to by this book. Please mark them for deletion with, link to them, or merge them into another page and mark them with. – Adrignola talk 00:35, 12 July 2010 (UTC)

 * Thanks! Slip ups on my part, now linked where appropriate. Thenub314 (talk) 10:19, 12 July 2010 (UTC)

Outdated
This is a great wikibook and I am very impressed by the work done on it; however, the book it is based off is updated very regularly, while this one is not. I question whether it might be better to just redirect readers to the original. InverseHypercube (discuss • contribs) 23:00, 4 October 2012 (UTC)
 * How much has changed in the area of linear algebra? Is it just some of the applications sections? Or is it reorganization of the sections? Rgrasmus (discuss • contribs) 15:36, 24 April 2013 (UTC)
 * Agree, this is more a unsophisticated "young-Wikipedian" attitude I wouldn't expect to see much here on Wikibooks—it is a fallacy that all fields of knowledge are progressing at an breakneck pace rather than a recognition that things like mathematical theory or even physics fundamentals are rather stable and updating is hardly ever needed. A lot of the inflation of the cost of education could be eliminated by holding down the switching of texts for standard courses. For example, I have a physics text published in 1911, and 98% of it is still spot on, most of the rest is new theory-but for understanding fundamental mechanics and non-relativistic physics, Newtonian physics, the book is perfectly well suited.
 * Secondarily, if Mathematicians were good at having applications sections people would actually understand the topics. As an engineer, imho, the whole pedagogy mindset sucks. They do really poorly at relating math to the real world.
 * Next time, when tagging like these, please put the template in the edit summary. Finding when it was hung and by who would save others time, and have brought me to this note sooner. // Fra nkB 15:15, 31 July 2013 (UTC)

Pages that need serious care
As I've been reading through this book, I've noticed some pages have more errors than others Lazauya (discuss • contribs) 05:34, 6 June 2016 (UTC)

 * Linear_Algebra/Changing_Map_Representations This page has some big formatting errors that I tried to correct, but I simply do not know how Lazauya (discuss • contribs) 05:34, 6 June 2016 (UTC)

Topics related to unitary transformations
I have noticed that unitary (aka orthonormal) transformations/matrices are given a very light treatment. I am creating a new section to describe important results such as the singular value decomposition and the spectral theorem, with possibly some references to quantum information applications. Feel free to assist and correct where necessary.

Math buff (discuss • contribs) 00:56, 6 March 2017 (UTC)

errors
Upon attempting to load, I am repeatedly getting the following error: "504 Gateway Time-out / nginx/1.11.13" (Part 2 loads okay). The single-file PDF generated from  also contains display errors. Is there a way that I can print-to-PDF or download this book as just one or two files without having to print each chapter individually? Nicole Sharp (discuss • contribs) 21:53, 28 May 2017 (UTC)

Thorough rework?
What do you have in mind to rework, about this book? --Pi zero (discuss • contribs) 12:39, 11 August 2017 (UTC)
 * In order to save the time of beginning students, I'll introduce the most general notions first, so that the theorems don't have to be repeated at a later stage in larger generality. In particular, determinants and matrix theory will be developed on the level of rings, elementaries on vector spaces will be stated on the level of modules (where of course the brief definition of modules gives a much finer mnemonic of the definition of vector spaces than the direct, "bare hands" definition that is pursued here). The rework will leave the current content as-is, until it is finished, and then the current wikibook will be moved somewhere else or deleted. --Mathmensch (discuss • contribs) 12:47, 11 August 2017 (UTC)

Moore-Penrose inverse
Dear Wikibookians,

I have recently transwikified a page on the Moore-Penrose inverse from Wikipedia and polished it for inclusion in the linear algebra section of the Topics in Abstract Algebra Wikibook (User:Felix QW/Proofs involving the Moore–Penrose inverse). However, as I was reformatting it, it occurred to me that it would be a natural follow-on from the sections already present in Unitary Transformations here, and that the level of the material is not too high. Therefore I was wondering what the thoughts are on including it as a topic on Unitary Transformations V here? Of course, it would need to be reformatted (again) to meet the conventions of Linear Algebra.

title: Talk:Linear Algebra


text:
Robotics/Design Basics/Basic Programming

Microcontrollers
These days using programmable components is easy. In the early days you had to write code in assembly, burn it in an EPROM, plug the EPROM in its socket and hope you didn't make any mistake. Because if you did, you had to hunt down the error in hundreds of lines of cryptic assembly code and had to use a new EPROM. These days you've got flash memory which can be reprogrammed in circuit. You've got C and Basic compilers to write your code. Most µcontrollers have a whole lot of hardware on chip (UART, Watchdog, Real Time Clock, RAM, ROM, EEPROM,...) and libraries are available for different programming languages which make coding LC-displays or Servos very easy. Not to mention you've got emulators (A special connector plugged into the MICROcontroller socket which allows a PC to pretend to be the µcontroller) and simulators (simulates the µcontroller on a PC and allows to run its code) to hunt down the bugs.

AVR
A good µcontroller to start with is the Atmel AVR ATtiny2313 (previously: AT90S2313) or ATMEGA8535 (previously: AT90S8535) (Atmel). It's cheap, has all the essentials on chip and has a whole lot of websites dedicated to it. The 8535 is more expensive, but has more memory and has an on board ADC. An AVR combined with Bascom-AVR is pretty much the easiest way to start with µcontrollers.

See Atmel AVR for details.

See Robotics/Computer Control/The Interface/Microcontrollers for other popular microcontrollers.

See General Engineering Introduction/Arduino and Motors/Arduino Introduction for one way to do AVR development.

PC
The PC has many advantages over µcontrollers when it comes to controlling a robot. However it has 2 flaws that make it nearly impossible to use in small robot-projects: This means that PCs are limited to tethered or large robots. If power isn't a problem the PC offers enormous amounts of RAM and HD space and plenty of CPU power. Plus a very handy user interface. Also network capabilities can be very useful for some applications. Providing your robot with a wireless connection (IR, radio, WiFi, bluetooth,...) and a similar interface on the PC reduces the wire-problem to a limited-distance (or in the case of IR a line-of-sight) problem.
 * First: it's large and heavy.
 * Secondly: A modern pc consumes enormous amounts of power.

If you intend to use a PC in your project, you might want to use one of the flavors of linux as the OS, as it allows easy access to any of the parts of the computer. Another choice for an OS is the older MS-DOS, although MS-DOS lacks multithreading (but those can be added in your software) and has ugly memory management (remember the 640Kb limit?).

Laptop
The laptop has only its size against it. A laptop provides the benefits of a PC without the enormous power consumption. The downside to laptops is their limited battery life. limited battery life.html

PDA
The PDA (Personal Digital Assistant) is nothing more than a hand held PC (Personal Computer). Most of the time these units used scaled down RISC (Reduced Instruction Set Chip) processors to allow for fast execution times and also allow the unit to remain smaller and lighter than your average laptop. Some PDA's even have built-in GPS which makes it very interesting for outdoor robot applications. The downside is their price. The PDA is useful for play, but also serves as a great business tool especially when they are equipped with a stylus.

Gameboy
The Gameboy (the classic, advance, color and DS) can be a very powerful device. These have been used in many projects (see google). The only drawback is constructing the special PCB to act as a connector.

Gameboy Advance (GBA)
The Gameboy Advance is also excellent as a robotics platform. There are a few complete open-source development suites available (GCC based C/C++ plus ARM assembler). There is also a good kit (Charmed Labs) available to interface Lego robotics motors/sensors and give much more control compared to the Lego RCX. With 4MB of FLASH and a few hundred K of RAM the kit has huge potential. The kit is not really for the complete beginner though as setting up the GNU tools can be quite complicated although the development environment is consequently very rich.

See GBA Development for tips on writing software for the Game Boy Advance.

Programmable Logic Controllers
Programmable logic controllers, PLCs, are special purpose industrial computers, made to be easy to interface with electrical circuits. Most PLC are expandable but there are some compact "all-in-one" solutions as well. They have excellent bit-manipulating possibilities, and add-on-cards for several special signals as high-speed counters, analog I/O, networks and fieldbuses (RS-232, RS422, RS-485, Ethernet, DeviceNet, Profibus...), pulse output, servo control, etc. Increasingly, special inputs are included in the PLC CPU unit. PLCs are traditionally used to control automated factories, possibly several machines per PLC. They normally use special-purpose programming languages, most commonly ladder or SFC.

PLCs are available in sizes from approximately 5x5x5 cm (there is a PLC IC available as well, but for the purposes of this book we choose to ignore that fact). The smallest ones are very limited though, with only a few I/Os and very limited memory, and also very limited instruction set with regards to data processing and calculations. PLCs are especially suitable if you have a lot of experience of electric systems, but feel intimidated by designing and soldering PCBs and programming computers (i.e., you are an electrician). They also shine in very large system with many special purpose sensors and outputs, as mostly there will be a standard solution from the manufacturer that is possible to use.

The downside with PLCs are their price - They can be quite costly, normally at least an order of magnitude higher than microcontrollers. They also draw more current than a microcontroller, however less than a computer. On the other hand, compared to a computer, they are computationally weak. They aren't suited for heavy signal-processing work.

PLC:s are best suited for large robots, but could be usable in medium-sized projects as well.

Combinations
It's common to use both a computer/laptop/PDA and (a) microcontroller(s) as those 2 complement each others limitations. e.g. The first has the advantage of large amounts of memory and processing power, however lacks specific outputs that are very handy in robotics, like PWM. Microcontrollers commonly have PWM channels that operate independently of the rest of the microcontroller, but are limited in their processing speed and memory. Linking those 2 devices provides the best of both worlds.

Programming languages
This page discusses some of the available programming languages and provides links to download compilers for those languages.

Which language to pick?
The choice of language depends on a few points:

 * previous experience. If you're already comfortable with a particular programming language, you'll probably want to use that language for programming your robot.

 * How much time and effort you intend to invest. Not every language is equally hard/easy to use. Most of the complexity of a language comes from allowing more low-level access. Basically the more control a language gives to the user, the harder it is to use, but also the more powerful it is. In theory Assembly would allow a programmer to write the fastest and smallest code. However this is only true for an experienced programmer. Modern compilers can generate code that comes near to hand written Assembly. In most cases, using Assembly needlessly complicates a program, with the exception of using inline assembly in a C or Basic program. Usually these are a few lines of code which work directly with memory, or have to execute in a known time. For many if not most projects, a language such as Basic or C suffices. Only if you intend to push a microcontroller or PC to the limits of its capabilities is it worth the trouble of writing Assembly code.
 * your goals. If you want a simple robot, you wouldn't need Assembly code at all. With modern microcontroller you can easily write sloppy Basic code and still have sufficient speed and memory. If you intend to build a cutting edge robot with a few dozen sensors, image recognition and speech recognition you'll need to write perfect code and will need Assembly for some of the components in order to have enough speed and be able to fit the code in the limited memory of the microcontroller(s). Most projects will fall in between these two extremes and good written Basic or C code would be more than sufficient. Knowing (some) Assembly can be useful as it'll give some insight on how processors work. Such insights make you a better programmer.
 * Availability. Not all languages are available for all microcontrollers. Urbi is open source, C and Basic and Forth are common, often as freeware, other languages might be available commercially, or not at all.

Writing your software
This section doesn't intend to teach the basics of programming, just those points that aren't addressed in most programming tutorials and beginners books.

 * Style. "Style" is how you indent your lines, how you pick your variable and function names. Pick one and stick with it throughout your program. Especially for functions and variables you should decide when to use capital letters, underscores and when to stick words together. Doing this the same everywhere makes it easier not to miss-spell names.
 * Use informative names. Functions, procedures and variables should have informative names. Their purpose should be clear.
 * Plan before coding. In software development there are two important steps before coding: requirement analysis and software architecture. The first is about finding out what the program is expected to do, what inputs to expect, which output it should generate and what the limitations of its environment are going to be. The latter involves working out how the program is going to be structured, which data types to use, which algorithms, how the input is going to enter the program and how to make sure it's valid and how to format the output. Using a lite version of these steps will make it much easier to write a decent program. If you intend to build a more complicated robot, you'll going to need to invest more time in planning out your software. Have all your software requirements written out first. Then pick a few of the most critical requirements and refine them. Implement those first. After you're done with those (this includes throughfully testing them), pick a new set and refine and implement those. By doing it in small steps you avoid having to write out everything at the start (and making many assumptions) and get to use the insights you get by coding parts of it.
 * Use PDL (Program Development Language) PDL is a method to write functions. It involves writing down the individual steps of a function in plain English without referring to language-specific things, then refining these steps into smaller steps, until it's easier to write the code than to split the steps further. Afterward leave the PDL lines in as comments.
 * Simulation and Debugging Learn to use the simulator. It's easier to find errors there than in the hardware. Also learn to use the debugger. It's your best friend for finding errors.
 * If your software runs on a PC a log-file can be useful. But be picky with what you let the software log. If you intend to run it for a long time those log-files can become massive. If you want to log sensor data over time, know that these can be imported in Excel by saving the data with spaces between them to separate columns and newlines to separate rows. See Comma-separated values.


text:
Ada Programming/Types/access

What's an Access Type?
Access types in Ada are what other languages call pointers. They point to objects located at certain addresses. So normally one can think of access types as simple addresses (there are exceptions from this simplified view). Ada instead of saying points to talks of granting access to or designating an object.

Objects of access types are implicitly initialized with, i.e. they point to nothing when not explicitly initialized.

Access types should be used rarely in Ada. In a lot of circumstances where pointers are used in other languages, there are other ways without pointers. If you need dynamic data structures, first check whether you can use the Ada Container library. Especially for indefinite record or array components, the Ada 2012 package (RM ) can be used instead of pointers.

There are four kinds of access types in Ada: Pool access types - General access types - Anonymous access types - Access to subprogram types.

Pool access
A pool access type handles accesses to objects which were created on some specific heap (or storage pool as it is called in Ada). A pointer of these types cannot point to a stack or library level (static) object or an object in a different storage pool. Therefore, conversion between pool access types is illegal. (Unchecked_Conversion may be used, but note that deallocation via an access object with a storage pool different from the one it was allocated with is erroneous.)

Person First_Name : String (1..30); Last_Name : String (1..20); ; Person_Access   Person;

A storage size clause may be used to limit the corresponding (implementation defined anonymous) storage pool. A storage size clause of 0 disables calls of an allocator.

Person_Access' 0;

The storage pool is implementation defined if not specified. Ada supports user defined storage pools, so you can define the storage pool with

Person_Access' Pool_Name;

Objects in a storage pool are created with the keyword :

Father: Person_Access := Person;                                          -- uninitialized Mother: Person_Access := Person'(Mothers_First_Name, Mothers_Last_Name);  -- initialized

You access the object in the storage pool by appending. is the complete record; components are denoted as usual with the dot notation:. When accessing components, implicit dereferencing (i.e. omitting ) can serve as a convenient shorthand:

Mother. := (Last_Name => Father.Last_Name, First_Name => Mother.First_Name); -- marriage

Implicit dereferencing also applies to arrays:

Vector  (1 .. 3)  Complex; Vector_Access  Vector; VA: Vector_Access := Vector; VB: (1 .. 3)  Vector_Access := ( =>  Vector); C1: Complex := VA (3);   -- a shorter equivalent for VA. (3)  C2: Complex := VB (3)(1); -- a shorter equivalent for VB(3). (1)

Be careful to discriminate between deep and shallow copies when copying with access objects:

Obj1. := Obj2.; -- Deep copy: Obj1 still refers to an object different from Obj2, but it has the same content Obj1 := Obj2;         -- Shallow copy: Obj1 now refers to the same object as Obj2

Deleting objects from a storage pool
Although the Ada standard mentions a garbage collector, which would automatically remove all unneeded objects that have been created on the heap (when no storage pool has been defined), only Ada compilers targeting a virtual machine like Java or .NET actually have garbage collectors.

When an access type goes out of scope, the corresponding still allocated data items are finalized (i.e. they do no longer exist) in an arbitrary order; the allocated memory, however, is only freed when the attribute Storage_Size has been defined for the access type via an attribute_definition clause. (Note: Finalization and deallocation are different things!)

Proof
The following are excerpts from the Ada Reference Manual. The ellipses stand for parts not relevant for the case.

RM 3.10(7/1) There are ... access-to-object types, whose values designate objects... Associated with an access-to-object type is a storage pool; several access types may share the same storage pool. ... A storage pool is an area of storage used to hold dynamically allocated objects (called pool elements) created by allocators.

(8) Access-to-object types are further subdivided into pool-specific access types, whose values can designate only the elements of their associated storage pool...

RM 7.6(1) ... Every object is finalized before being destroyed (for example, by leaving a subprogram_body containing an object_declaration, or by a call to an instance of Unchecked_Deallocation)...

RM 7.6.1(5) For the finalization of an object:

(6/3) If the full type of the object is an elementary type, finalization has no effect;

(7/3) If the full type of the object is a tagged type, and the tag of the object identifies a controlled type, the Finalize procedure of that controlled type is called;

(10) Immediately before an instance of Unchecked_Deallocation reclaims the storage of an object, the object is finalized. If an instance of Unchecked_Deallocation is never applied to an object created by an allocator, the object will still exist when the corresponding master completes, and it will be finalized then.

(11.1/3) Each nonderived access type T has an associated collection, which is the set of objects created by allocators of T, or of types derived from T. Unchecked_Deallocation removes an object from its collection. Finalization of a collection consists of finalization of each object in the collection, in an arbitrary order…

RM 13.11(1) Each access-to-object type has an associated storage pool. The storage allocated by an allocator comes from the pool; instances of Unchecked_Deallocation return storage to the pool. Several access types can share the same pool.

(2/2) A storage pool is a variable of a type in the class rooted at Root_Storage_Pool, which is an abstract limited controlled type. By default, the implementation chooses a standard storage pool for each access-to-object type…

(11) A storage pool type (or pool type) is a descendant of Root_Storage_Pool. The elements of a storage pool are the objects allocated in the pool by allocators.

(15) Storage_Size or Storage_Pool may be specified for a nonderived access-to-object type via an attribute_definition_clause...

(17) If Storage_Pool is not specified for a type defined by an access_to_object_definition, then the implementation chooses a standard storage pool for it in an implementation-defined manner...

(18/4) If Storage_Size is specified for an access type T, an implementation-defined pool P is used for the type. The Storage_Size of P is at least that requested, and the storage for P is reclaimed when the master containing the declaration of the access type is left...

Example
The following program will compile but will fail the accessibility check on runtime with an exception.

Ada.Text_IO; Ada.Text_IO; Main Accessibility_Check_Fail String -- Declare a new access type locally. -- All memory with this type will be finalized but not freed -- when the this type goes out of scope. A_Type  String; X : A_Type := String'("x"); Y : String; Y := X;         Y;       Accessibility_Check_Fail; -- Accessibility check will fail because the accessiblity level associated -- with Y is deeper than the accessibility level of this scope. Put_Line(Accessibility_Check_Fail.); Main;

There is also a, which, when applied to such an access type, prevents automatic garbage collection of objects created with it. Note that  was dropped from Ada 2012, subpools for storage management replacing it. See RM 2012 and.

Therefore, in order to delete an object from the heap, you need the generic unit. Apply utmost care to not create dangling pointers when deallocating objects as is shown in the example below. (And note that deallocating objects with a different access type than the one with which they were created is erroneous when the corresponding storage pools are different.)

; Deallocation_Sample Vector      (Integer  <>)  Float; Vector_Ref  Vector; Free_Vector (Object => Vector, Name => Vector_Ref); VA, VB: Vector_Ref; V    : Vector; VA    :=  Vector (1 .. 10); VB    := VA;  -- points to the same location as VA    VA. := ( => 0.0); -- ... Do whatever you need to do with the vector Free_Vector (VA); -- The memory is deallocated and VA is now null V := VB.all; -- VB is not null, access to a dangling pointer is erroneous Deallocation_Sample;

It is exactly because of this problem with dangling pointers that the deallocation operation is called unchecked. It is the chore of the programmer to take care that this does not happen.

Since Ada allows for user-defined storage pools, you could also try a garbage collector library.

Constructing Reference Counting Pointers
You can find some implementations of reference counting pointers, called Safe or Smart Pointers, on the net. Using such a type prevents caring about deallocation, since this will automatically be done when there are no more pointers to an object. But be careful - most of those implementations do not prevent deliberate deallocation, thus undermining the alleged safety attained with their use.

A nice tutorial how to construct such a type can be found in a series of Gems on the AdaCore web site.

Gem #97: Reference Counting in Ada – Part 1 This little gem constructs a simple reference counted pointer that does not prevent deallocation, i.e. is inherently unsafe.

Gem #107: Preventing Deallocation for Reference-counted Types This further gem describes how to arrive at a pointer type whose safety cannot be compromised (tasking issues aside). The cost of this improved safety is awkward syntax.

Gem #123: Implicit Dereferencing in Ada 2012 This gem shows how to simplify the syntax with the new Ada 2012 generation. (Admittedly, this gem is a bit unrelated to reference counting since the new language feature can be applied to any kind of container.)

General access
General access types grant access to objects created on any storage pool, on the stack or at library level (static). They come in two versions, granting either read-write access or read-only access. Conversions between general access types are allowed, but subject to certain access level checks.

Dereferencing is like for pool access types. Objects (other than pool objects) to be referenced have to be declared, and references to them are created with the attribute. Access level restrictions prevent accesses to objects from outliving the accessed object, which would make the program erroneous. The attribute  omits the corresponding checks.

Access to Variable
When the keyword is used in their definition, they grant read-write access.

Day_Of_Month  1 .. 31;             Day_Of_Month_Access    Day_Of_Month;

Access to Constant
General access types granting read-only access to the referenced object use the keyword in their definition. The referenced object may be a constant or a variable.

Day_Of_Month  1 .. 31;             Day_Of_Month_Access    Day_Of_Month;

Some examples
General_Pointer         Integer; Constant_Pointer   Integer; I1:  Integer := 10; I2: Integer; P1: General_Pointer := I1';  -- illegal P2: Constant_Pointer := I1'; -- OK, read only P3: General_Pointer := I2';  -- OK, read and write P4: Constant_Pointer := I2'; -- OK, read only P5: General_Pointer := I2'Access;  -- read and write only to I2

Anonymous access
Also Anonymous access types come in two versions like general access types, granting either read-write access or read-only access depending on whether the keyword appears.

An anonymous access can be used as a parameter to a subprogram or as a discriminant. Here are some examples:

Modify (Some_Day:          Day_Of_Month); Test  (Some_Day:   Day_Of_Month);  -- Ada 2005 only

Thread (Execute_For_Day: Day_Of_Month) ... Thread;

Day_Data (Store_For_Day: Day_Of_Month) -- components ;

Before using an anonymous access, you should consider a named access type or, even better, consider if the "" or " " modifier is not more appropriate.

In Ada 2005, anonymous accesses are allowed in more circumstances:

Object M  : Integer; Next: Object; ; X: Integer; F   Float;

Implicit Dereference
Ada 2012 simplifies accesses to objects via pointers with new syntax.

Imagine you have a container holding some kind of elements.

Container   ; Element_Ptr  Element; Put (X: Element; Into:  Container);

Now, how do you access elements stored in the container. Of course, you can retrieve them by

Get (From: Container) Element;

This will however copy the element, which is unfortunate if the element is big. You get direct access with

Get (From: Container) Element_Ptr;

Now, pointers are dangerous since you might easily create dangling pointers like so:

P: Element_Ptr := Get (Cont); P. := E; Free (P); ... Get (Cont) -- this is now a dangling pointer

Use of an accessor object instead of an access type can prevent inadvertent deallocation (this is still Ada 2005):

Accessor (Data:   Element)   ;  -- read/write access Get (From: Container) Accessor;

(For the null exclusion  in the declaration of the discriminant, see below). Access via such an accessor is safe: The discriminant can only be used for dereferencing, it cannot be copied to an object of type Element_Ptr because its accessibility level is deeper. In the form above, the accessor provides read and write access. If the keyword is added, only read access is possible.

Accessor (Data:    Element)   ;  -- only read access

Access to the container object now looks like so:

Get (Cont). := E; -- via access type: dangerous Get (Cont).Data. := E; -- via accessor: safe, but ugly

Here the new Ada 2012 feature of aspects comes along handy; for the case at hand, the aspect Implicit_Dereference is the one we need:

Accessor (Data:   Element) Implicit_Dereference => Data;

Now rather than writing the long and ugly function call of above, we can just omit the discriminant and its dereference like so:

Get (Cont).Data. := E; -- Ada 2005 via accessor: safe, but ugly Get (Cont)         := E;  -- Ada 2012 implicit dereference

Note that the call  is overloaded — it can denote the accessor object or the element, the compiler will select the correct interpretation depending on context.

Null exclusions
All access subtypes can be modified with, objects of such a subtype can then never have the value null, so initializations are compulsory.

Day_Of_Month_Access             Day_Of_Month; Day_Of_Month_Not_Null_Access   Day_Of_Month_Access;

The language also allows to declare the first subtype directly with a null exclusion:

Day_Of_Month_Access    Day_Of_Month;

However, in nearly all cases this is not a good idea because it renders objects of this type nearly unusable (for example, you are unable to free the allocated memory). Not null accesses are intended for access subtypes, object declarations, and subprogram parameters.

Access to Subprogram
An access to subprogram allows the caller to call a subprogram without knowing its name nor its declaration location. One of the uses of this kind of access is the well known callbacks.

Callback_Procedure   (Id  : Integer;                                              Text: String); Callback_Function   (The_Alarm: Alarm)  Natural;

For getting an access to a subprogram, the attribute is applied to a subprogram name with the proper parameter and result profile.

Process_Event (Id : Integer;                          Text: String); My_Callback: Callback_Procedure := Process_Event';

Anonymous access to Subprogram
Test (Call_Back:  (Id: Integer; Text: String));

There is now no limit on the number of keyword in a sequence:

F        Some_Type;

This is a function that returns the access to a function that in turn returns an access to a function returning an access to some type.

Access FAQ
A few "Frequently Asked Question" and "Frequently Encountered Problems" (mostly from C users) regarding Ada's access types.

Access vs. access all
An  can do anything a simple  can do. So one might ask: "Why use simple at all?" - And indeed some programmers never use simple.

Unchecked_Deallocation is always dangerous if misused. It is just as easy to deallocate a pool-specific object twice, and just as dangerous as deallocating a stack object. The advantage of "access all" is that you may not need to use Unchecked_Deallocation at all.

Moral: if you have (or may have) a valid reason to store an 'Access or 'Unchecked_Access into an access object, then use "access all" and don't worry about it. If not, the mantra of "least privilege" suggests that the "all" should be left out (don't enable capabilities that you are not going to use).

The following (perhaps disastrous) example will try to deallocate a stack object:

Day_Of_Month  1 .. 31;               Day_Of_Month_Access    Day_Of_Month; Free  Ada.Unchecked_Deallocation (Object => Day_Of_Month,       Name   => Day_Of_Month_Access); A :  Day_Of_Month; Ptr: Day_Of_Month_Access := A'; Free(Ptr); ;

With a simple you know at least that you won't try to deallocate a stack object. The reason is that  does not allow pointers to be created from stack objects.

Access vs. System.Address
An access can be something different from a mere memory address, it may be something more. For example, an "access to String" often needs some way of storing the string size as well. If you need a simple address and are not concerned about strong typing, use the System.Address type.

C compatible pointer
The correct way to create a C compatible access is to use :

Day_Of_Month  1 .. 31;  Day_Of_Month'  Interfaces.C.int'; (Convention => C,                   Entity     => Day_Of_Month); Day_Of_Month_Access  Day_Of_Month; (Convention => C,                   Entity     => Day_Of_Month_Access);

should be used on any type you want to use in C. The compiler will warn you if the type cannot be made C compatible.

You may also consider the following - shorter - alternative when declaring Day_Of_Month:

Day_Of_Month  Interfaces.C.int  1 .. 31;

Before you use access types in C, you should consider using the normal "in", "out" and "in out" modifiers. and know how parameters are usually passed in C and will use a pointer to pass a parameter automatically where C would have used them as well. Of course the RM contains precise rules on when to use a pointer for "in", "out", and "in out" - see "".

Where is void*?
While actually a problem for "interfacing with C", here are some possible solutions:

Test Pvoid System.Address; -- the declaration in C looks like this: -- int C_fun(int *) C_fun (pv: Pvoid) Integer; (Convention   => C,                  Entity        => C_fun,     -- any Ada name                  External_Name => "C_fun");  -- the C name Pointer: Pvoid; Input_Parameter: Integer := 32; Return_Value  : Integer; Pointer     := Input_Parameter'; Return_Value := C_fun (Pointer); Test;

Less portable, but perhaps more usable (for 32 bit CPUs) :

void  2 ** 32; void' 32;

With GNAT you can get 32/64 bit portability by using:

void  System.Memory_Size; void' System.Word_Size;

Closer to the true nature of void - pointing to an element of zero size is a pointer to a null record. This also has the advantage of having a representation for  and  :

Void  ; (C, Void); Void_Ptr   Void; (C, Void_Ptr);

Thin and Fat Access Types
The difference between an access type and an address will be detailed in the following. The term pointer is used because this is usual terminology.

There is a predefined unit  converting back and forth between access values and addresses. Use these conversions with care, as is explained below.

Thin Pointers
Thin pointers grant access to constrained subtypes.

Int      -100 .. +500; Acc_Int   Int; Arr      (1 .. 80)  Character; Acc_Arr  Arr;

Objects of subtypes like these have a static size, so a simple address suffices to access them. In the case of arrays, this is generally the address of the first element.

For pointers of this kind, use of  is safe.

Fat Pointers
Unc      (Integer  <>)  Character; Acc_Unc  Unc;

Objects of subtype  need a constraint, i.e. a start and a stop index, thus pointers to them need also to include those. So a simple address like the one of the first component is not sufficient. Note that A'Address is the same as A(A'First)'Address for any array object.

For pointers of this kind,  will probably not work satisfactorily.

Example
CO: Unc (-1 .. +1) := (-1 .. +1 => ' '); UO: Unc            := (-1 .. +1 => ' ');

Here, CO is a nominally constrained object, a pointer to it need not store the constraint, i.e. a thin pointer suffices. In contrast, UO is an object of a nominally unconstrained subtype, its actual subtype is constrained by the initial value.

A: Acc_Unc           := CO'Access;  -- illegal B: Acc_Unc           := UO'Access;  -- OK C: Acc_Unc (CO'Range) := CO'Access;  -- also illegal

The relevant paragraphs in the RM are difficult to understand. In short words:

An access type's target type is called the designated subtype, in our example. RM (27.1/2) requires that 's designated subtype statically match the nominal subtype of the object.

Now the nominal subtype of  is the constrained anonymous subtype , the nominal subtype of   is the unconstrained subtype. In the illegal cases, the designated and nominal subtypes do not statically match.

Wikibook

 * Ada Programming
 * Ada Programming/Types

title: Ada Programming/Types/access


text:
User:Mariela Riva

Estimada Mariela:

Me hace ilusión un proyecto como este.

Me gustaría contactar contigo para comentarlo, ya que hay cosas que no entiendo bien.

Un saludo desde España,

juani.franco@terra.es

title: User:Mariela Riva


text:
Ada Programming/Attributes/'Size

Description
R'Size is a representation attribute used to get the number of bits of an object or type:
 * When applied to an object, 'Size yields the actual number of bits allocated to store the object.
 * When applied to a subtype, 'Size yields the smallest n such that all values fit in the range 0 .. 2n-1 for only positive values, else -2n-1 .. 2n-1-1.

The 'Size attribute may also be used in an attribute definition clause to set the size for a first subtype. In special cases, it is even possible to force a biased representation by using a smaller value than the n above.

Examples
This subtype allows a biased representation with only three bits because it comprises only eight values:

T  1000 .. 1007;   T'Size  3;

Without the size clause, T'Size would return 10 because 210-1 = 1023.

; Attributes_Size T_IO Ada.Text_IO; I_IO   Ada.Text_IO.Integer_IO (Integer); A_Boolean : Boolean := True; T_IO.Put ("Size of Boolean type  = "); I_IO.Put (Boolean'Size); T_IO.New_Line; T_IO.Put ("Size of Boolean Object = "); I_IO.Put (A_Boolean'Size); T_IO.New_Line; Attributes_Size;

The output with GNAT 10.2.0 will be:

Size of Boolean type  =           1 Size of Boolean Object =          8

Try it yourself and see how your compiler does.

The value of Size can also be specified using an attribute definition clause. For example, the following declarations specify a C99 compatible bool:

Bool  Boolean; Bool'Size .int'Size;

Wikibook

 * Ada Programming
 * Ada Programming/Attributes
 * Ada Programming/Attributes/'Component Size
 * Ada Programming/Attributes/'Max Size In Storage Elements
 * Ada Programming/Attributes/'Value Size (implementation defined)
 * Ada Programming/Attributes/'Object Size (implementation defined)

Ada 2012 Reference Manual

|Size Size

title: Ada Programming/Attributes/'Size


text:
COSTP World History Project/California Content Standards

COSTP World History Project

See: http://www.cde.ca.gov/be/st/ss/hstgrades9through12.asp (Historical and Social Sciences Analysis Skills)

and http://www.cde.ca.gov/re/pn/fd/documents/hist-social-sci-frame.pdf (pp. 125-139)

These will be our primary organizing documents, based strictly on California Department of Education K-12 World History standards.

World History, Culture, and Geography: The Modern World
Students in grade ten study major turning points that shaped the modern world, from the late eighteenth century through the present, including the cause and course of the two world wars. They trace the rise of democratic ideas and develop an understanding of the historical roots of current world issues, especially as they pertain to international relations. They extrapolate from the American experience that democratic ideals are often achieved at a high price, remain vulnerable, and are not practiced everywhere in the world. Students develop an understanding of current world issues and relate them to their historical, geographic, political, economic, and cultural contexts. Students consider multiple accounts of events in order to understand international relations from a variety of perspectives.

====10.1 Students relate the moral and ethical principles in ancient Greek and Roman philosophy, in Judaism, and in Christianity to the development of Western political thought. ====

1. Analyze the similarities and differences in Judeo-Christian and Greco-Roman views of law, reason and faith, and duties of the individual.

2. Trace the development of the Western political ideas of the rule of law and illegiti-macy of tyranny, using selections from Plato's Republic and Aristotle's Politics.

3. Consider the influence of the U.S. Constitution on political systems in the contempo-rary world.

====10.2 Students compare and contrast the Glorious Revolution of England, the American Revolution, and the French Revolution and their enduring effects worldwide on the political expectations for self-government and individual liberty.====

1. Compare the major ideas of philosophers and their effects on the democratic revolutions in England, the United States, France, and Latin America (e.g., John Locke, Charles-Louis Montesquieu, Jean-Jacques Rousseau, Simón Bolívar, Thomas Jefferson, James Madison).

2. List the principles of the Magna Carta, the English Bill of Rights (1689), the American Declaration of Independence (1776), the French Declaration of the Rights of Man and the Citizen (1789), and the U.S. Bill of Rights (1791).

3. Understand the unique character of the American Revolution, its spread to other parts of the world, and its continuing significance to other nations.

4. Explain how the ideology of the French Revolution led France to develop from constitutional monarchy to democratic despotism to the Napoleonic empire.

5. Discuss how nationalism spread across Europe with Napoleon but was repressed for a generation under the Congress of Vienna and Concert of Europe until the Revolutions of 1848.

10.3 Students analyze the effects of the Industrial Revolution in England, France, Germany, Japan, and the United States.
1. Analyze why England was the first country to industrialize.

2. Examine how scientific and technological changes and new forms of energy brought about massive social, economic, and cultural change (e.g., the inventions and discoveries of James Watt, Eli Whitney, Henry Bessemer, Louis Pasteur, Thomas Edison).

3. Describe the growth of population, rural to urban migration, and growth of cities associated with the Industrial Revolution.

4. Trace the evolution of work and labor, including the demise of the slave trade and the effects of immigration, mining and manufacturing, division of labor, and the union movement.

5. Understand the connections among natural resources, entrepreneurship, labor, and capital in an industrial economy.

6. Analyze the emergence of capitalism as a dominant economic pattern and the responses to it, including Utopianism, Social Democracy, Socialism, and Communism.

7. Describe the emergence of Romanticism in art and literature (e.g., the poetry of William Blake and William Wordsworth), social criticism (e.g., the novels of Charles Dickens), and the move away from Classicism in Europe.

====10.4 Students analyze patterns of global change in the era of New Imperialism in at least two of the following regions or countries: Africa, Southeast Asia, China, India, Latin America, and the Philippines. ====

1. Describe the rise of industrial economies and their link to imperialism and colonialism (e.g., the role played by national security and strategic advantage; moral issues raised by the search for national hegemony, Social Darwinism, and the missionary impulse; material issues such as land, resources, and technology).

2. Discuss the locations of the colonial rule of such nations as England, France, Germany, Italy, Japan, the Netherlands, Russia, Spain, Portugal, and the United States.

3. Explain imperialism from the perspective of the colonizers and the colonized and the varied immediate and long-term responses by the people under colonial rule.

4. Describe the independence struggles of the colonized regions of the world, including the roles of leaders, such as Sun Yat-sen in China, and the roles of ideology and religion.

10.5 Students analyze the causes and course of the First World War.
1. Analyze the arguments for entering into war presented by leaders from all sides of the Great War and the role of political and economic rivalries, ethnic and ideological conflicts, domestic discontent and disorder, and propaganda and nationalism in mobilizing the civilian population in support of "total war."

2. Examine the principal theaters of battle, major turning points, and the importance of geographic factors in military decisions and outcomes (e.g., topography, waterways, distance, climate).

3. Explain how the Russian Revolution and the entry of the United States affected the course and outcome of the war.

4. Understand the nature of the war and its human costs (military and civilian) on all sides of the conflict, including how colonial peoples contributed to the war effort.

5. Discuss human rights violations and genocide, including the Ottoman government's actions against Armenian citizens.

10.6 Students analyze the effects of the First World War.
1

10.7 Students analyze the rise of totalitarian governments after World War I.
1. Understand the causes and consequences of the Russian Revolution, including Lenin's use of totalitarian means to seize and maintain control (e.g., the Gulag).

2. Trace Stalin's rise to power in the Soviet Union and the connection between economic policies, political policies, the absence of a free press, and systematic violations of human rights (e.g., the Terror Famine in Ukraine).

3. Analyze the rise, aggression, and human costs of totalitarian regimes (Fascist and Communist) in Germany, Italy, and the Soviet Union, noting especially their common and dissimilar traits.

10.8 Students analyze the causes and consequences of World War II.
1. Compare the German, Italian, and Japanese drives for empire in the 1930s, including the 1937 Rape of Nanking, other atrocities in China, and the Stalin-Hitler Pact of 1939.

2. Understand the role of appeasement, nonintervention (isolationism), and the domestic distractions in Europe and the United States prior to the outbreak of World War II.

3. Identify and locate the Allied and Axis powers on a map and discuss the major turning points of the war, the principal theaters of conflict, key strategic decisions, and the resulting war conferences and political resolutions, with emphasis on the importance of geographic factors.

4. Describe the political, diplomatic, and military leaders during the war (e.g., Winston Churchill, Franklin Delano Roosevelt, Emperor Hirohito, Adolf Hitler, Benito Mussolini, Joseph Stalin, Douglas MacArthur, Dwight Eisenhower).

5. Analyze the Nazi policy of pursuing racial purity, especially against the European Jews; its transformation into the Final Solution; and the Holocaust that resulted in the murder of six million Jewish civilians.

6. Discuss the human costs of the war, with particular attention to the civilian and military losses in Russia, Germany, Britain, the United States, China, and Japan.

10.9 Students analyze the international developments in the post-World World War II world.
1. Compare the economic and military power shifts caused by the war, including the Yalta Pact, the development of nuclear weapons, Soviet control over Eastern European nations, and the economic recoveries of Germany and Japan.

2. Analyze the causes of the Cold War, with the free world on one side and Soviet client states on the other, including competition for influence in such places as Egypt, the Congo, Vietnam, and Chile.

3. Understand the importance of the Truman Doctrine and the Marshall Plan, which established the pattern for America's postwar policy of supplying economic and military aid to prevent the spread of Communism and the resulting economic and political competition in arenas such as Southeast Asia (i.e., the Korean War, Vietnam War), Cuba, and Africa.

4. Analyze the Chinese Civil War, the rise of Mao Tse-tung, and the subsequent political and economic upheavals in China (e.g., the Great Leap Forward, the Cultural Revolution, and the Tiananmen Square uprising).

5. Describe the uprisings in Poland (1952), Hungary (1956), and Czechoslovakia (1968) and those countries' resurgence in the 1970s and 1980s as people in Soviet satellites sought freedom from Soviet control.

6. Understand how the forces of nationalism developed in the Middle East, how the Holocaust affected world opinion regarding the need for a Jewish state, and the significance and effects of the location and establishment of Israel on world affairs.

7. Analyze the reasons for the collapse of the Soviet Union, including the weakness of the command economy, burdens of military commitments, and growing resistance to Soviet rule by dissidents in satellite states and the non-Russian Soviet republics.

8. Discuss the establishment and work of the United Nations and the purposes and functions of the Warsaw Pact, SEATO, NATO, and the Organization of American States.

====10.10 Students analyze instances of nation-building in the contemporary world in at least two of the following regions or countries: the Middle East, Africa, Mexico and other parts of Latin America, and China. ====

1. Understand the challenges in the regions, including their geopolitical, cultural, military, and economic significance and the international relationships in which they are involved.

2. Describe the recent history of the regions, including political divisions and systems, key leaders, religious issues, natural features, resources, and population patterns.

3. Discuss the important trends in the regions today and whether they appear to serve the cause of individual freedom and democracy.


text:
COSTP World History Project/Project

This is a starter page for our major push to create an open content textbook that meets the California content standards for 10th grade World History.

Go to contents of the California Open Source Textbook Project's K-12 World History Project

California Content Standards

California Open Source Textbook Project (COSTP) COSTP began as a public/private undertaking; it was the first organization created to address the high cost, content range, and consistent shortages of K-12 textbooks in California. The latter goal is currently well on its way to being accomplished. COSTP has evolved over recent years to establish and spread the Open Textbook, Open Educational Resource (OER), Open Courseware, and Open Education memes to K-12 and postsecondary educational institutions, worldwide. Many Open source textbook and courseware projects have started up since COSTP’s inception.

COSTP's aim is to use California State K-12 Standards to develop open-licensed eBooks and printed textbooks that will be approved for adoption by California's State Board of Education for use in California public schools at far less cost than current commercial textbook offerings, thus helping the State of California save money (more than $200M per year) while providing more robust content for its public schools.

In order for open source books to pass peer review (and thus approval for public school adoption) at the California State Board level (this is also true in most other states), textbook content must conform to the written state K-12 education framework standard, or it can be specially submitted to the Governor for approval. This is a sine qua non for adoption; no exceptions are made.

The COSTP World History Project on Wikipedia was used a placeholder pilot that helped to prove the open source concept in the K-12 textbook sector. The COSTP World History Project was successful in helping California education officials understand - even in its current basic beginnings - the value of the open source content approach applied to K-12 textbooks.

Please visit http://www.opensourcetext.org for more.

title: COSTP World History Project/Project


text:
Wikibooks:A-level bookshelf

Maths, Science and Computing

 * Applied Science
 * Biology
 * Chemistry
 * Computing
 * Mathematics
 * Advanced A-level Mathematics
 * Physics

Humanities and Social Science

 * Geography
 * Modern and Ancient History
 * Government and Politics

Languages

 * English Language and Literature

Business

 * Economics

General

 * General Studies

This is a basic list of A-level subjects, feel free to add more, provided that they are available at A-level.

title: Wikibooks:A-level bookshelf


text:
Buddhist Philosophy

Buddhist Philosophy

Contents

 * 1) /Introduction/
 * 2) /Details/
 * 3) /Meditation/
 * 4) /Mindfulness/
 * 5) /Sutra/
 * 6) /Schools/
 * 7) /Esoteric Buddhism/
 * 8) /Yinyana/
 * 9) /Developments/
 * 10) /Quips/
 * 11) Glossary
 * 12) References and Links

License and copyright
Copyright 2004–2024 Wikibooks Contributors.

title: Buddhist Philosophy


text:
User:Dori

See w:User:Dori

title: User:Dori


text:
User talk:Dori

Only at w:User talk:Dori please

title: User talk:Dori


text:
User:Ish ishwar~enwikibooks

new (global) name ==> User:Ish ishwar

bright moments!

User:Ish_ishwar/vector.css

User:Ish ishwar/monobook.css

w:user:ish ishwar

title: User:Ish ishwar~enwikibooks


text:
QBasic/Basic Input

The INPUT command is used to gather input from the user. This section will attempt to teach you how to gather input upon request from the user. For real-time input, see QBasic/Advanced Input.

Here is the syntax of the input command: or

Example:

or

When a semicolon is used after the text output to the user, a question mark (?) and space  are added to the output. When a comma is used, no question mark is added.

If a string is specified (e.g., 'name$'), anything the user enters before pressing the 'return' key will be accepted.

If a numeric variable (e.g., 'age') is specified, the user must enter a number. If any non-numeric key is entered, the error message "Redo from start" will be output and the INPUT command rerun.

6INPUT.BAS
Please note: In the PRINT command, the function concatenates (joins) the contents of the string variables with the text between the quotes (" "). Note the use of spaces so that the final printed text reads properly.

If a numerical variable is specified within the PRINT command, additional space is automatically added both before and after the number.

See also:  command to read a line of text from a file (and place the result in a string variable) or to input a series of variables (in which case any comma found will be treated as a delimiter between fields).

INPUT # and LINE INPUT
INPUT # uses an open file stream to collect data from the file itself. The file may be a data file, a bitmap, or a text file. The syntax is:

LINE INPUT is used to collect an entire line of a text file. Syntax:

WARNING: If input is taken beyond the file end, the error : "Input past end of file " is issued. You can use  and   functions to prevent errors. (LOF stands for LENGTH OF FILE while EOF stands for END OF FILE)

title: QBasic/Basic Input


text:
Ada Programming/Keywords/interface

Used to declare an interface. Interfaces are the most important innovation in Ada 2005. The basic semantic has been taken from the interface concept of the Java programming language. Interface inheritance is a reduced form of multiple inheritance.

Interface types
There are various forms of interfaces available:

Normal interface
The normal interface is declared as:

Printable ;

Limited interface
Can be used as interface to limited tagged type.

Printable  ;

Synchronized interface
Printable  ;

All synchronized interfaces are also limited.

Task interface
Can be used as an interface to a task type.

Printable  ;

All task interfaces are also synchronized.

Protected interface
Can be used as an interface to a protected type.

Printable  ;

All protected interfaces are also synchronized.

Wikibook

 * Ada Programming
 * Ada Programming/Keywords
 * Ada Programming/Object Orientation
 * Ada Programming/Multiple Inheritance
 * Ada Programming/Tasking
 * Ada Programming/Pragmas/Interface (obsolescent)

Ada Quality and Style Guide

|Interface

title: Ada Programming/Keywords/interface


text:
Template:Ada/2005

This language feature is only available from Ada 2005 on. /Ada 2005 feature Ada:2005

title: Template:Ada/2005


text:
Ada Programming/Libraries/Ada.Containers

is a unit of the Predefined Language Environment since Ada 2005.

Specification
A typical —almost empty— root package. All the interesting stuff happens inside the child packages.

Pure Containers Hash_Type  implementation_defined Count_Type  0  implementation_defined AdaContainers

Child units

 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * Ada.Containers.Bounded_Indefinite_Holders (Ada 2022)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2005)
 * (generic procedure) (Ada 2005)
 * (generic procedure) (Ada 2005)
 * (Ada 2005)
 * (Ada 2005)
 * (Ada 2005)
 * (Ada 2005)
 * (Ada 2005)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2005)
 * (Ada 2005)
 * (Ada 2005)
 * (Ada 2012)
 * (Ada 2005)
 * (Ada 2005)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2005)

Wikibook

 * Ada Programming
 * Ada Programming/Containers
 * Ada Programming/Libraries
 * Ada Programming/Libraries/Ada


text:
User talk:Uaxuctum~enwikibooks

G'day, thanks heaps for your edits to the quechua book. You seem to understand either quechua or phonetics (or both) far better than i. I would just like to know what happened to the bit on dipthongs, and how the table you put in relates to the oficial spelling changes approved by the Peruvian government in 1985 (which legilates 5 written vowels)? Another note, i started this book because i thought it was in desperate need of being written, not because i knew about anything on the subject. My main source (other than the wikipedia article) is a the lonley planet phrasebook, so please excuse my stupid questions, and bad phrasing of ideas. The bellman 12:07, 17 Dec 2004 (UTC)

 * I haven't entered the Wikibooks site for ages, so sorry for being so late to answer. Quechua (unlike English) has no phonemic diphthongs (the phonetic diphthongs are phonemically merely semivocalic consonants juxtaposed to simple vowels; e.g., /aw/ = vowel /a/ followed by consontant /w/, while the English diphthong /aU/ as in "how" is a single, undecomposable phoneme). That's why they do not belong in a description of Quechua's phonemes (they would belong in a description of Quechua's phonotactics, i.e. syllable structure and such, which would also include the description of consonant clusters). As for the former practice of spelling with five vowels, that's due to the misinterpretation that Spanish speakers tend to make about Quechua's vowel phonology. Quechua has only three vowel phonemes, while Spanish has five. As in other languages with only 3 vowels (such as Arabic and Inuktitut), these feature a wide range of allophonic variation, meaning that phonetically one can actually hear sounds similar to [e] and [o] in Quechua, but that phonemically these are merely contextual and predictable realizations of /i/ and /u/ (basically, when they are next to an uvular consonant such as /q/). But to a Spanish speaker, used to thinking of the sounds [i] and [e] as belonging to what in Spanish are completely different phonemes /i/ and /e/, it is frequently difficult to grasp the idea that in some other language they may be considered as mere variants of "the same sound" (as they are for a native Quechua speaker). That is why in former orthographies devised by the educated elite in Peru (who were native speakers of Spanish), the Spanish distinction of /i/ vs. /e/ and /u/ vs. /o/ was artificially forced into Quechua orthography according to how the contextual allophone of /i/ and /u/ sounded to a Spanish ear. Imagine that English orthography had been devised by Quechua speakers; if so, then English consonant /k/ would be spelled differently in the words "key" and "ski", because even though for a native English speaker it is clear that they have the same /k/ sound, to a Quechua speaker's ear they sound totally different (the former is aspirated like Quechua "kh" and the latter is unaspirated like Quechua "k"), so they would insist in spelling the two allophones of English /k/ differently according to what phoneme the sound would correspond to in Quechua, just like Spanish speakers insisted in spelling the two sounds of Quechua /i/ and of Quechua /u/ differently according to what phoneme the sound would correspond to in Spanish. Uaxuctum 22:29, 1 September 2006 (UTC)

 * Thanks for that clarification. I have been learning linguistics in the mean-time and it all makes a lot more sense now. The bellman 04:00, 17 September 2006 (UTC)

Your account will be renamed
Hello,

The developer team at Wikimedia is making some changes to how accounts work, as part of our on-going efforts to provide new and better tools for our users like cross-wiki notifications. These changes will mean you have the same account name everywhere. This will let us give you new features that will help you edit and discuss better, and allow more flexible user permissions for tools. One of the side-effects of this is that user accounts will now have to be unique across all 900 Wikimedia wikis. See the announcement for more information.

Unfortunately, your account clashes with another account also called Uaxuctum. To make sure that both of you can use all Wikimedia projects in future, we have reserved the name Uaxuctum~enwikibooks that only you will have. If you like it, you don't have to do anything. If you do not like it, you can pick out a different name.

Your account will still work as before, and you will be credited for all your edits made so far, but you will have to use the new account name when you log in.

Sorry for the inconvenience.

Yours, Keegan Peterzell Community Liaison, Wikimedia Foundation 23:51, 17 March 2015 (UTC)

Renamed
 This account has been renamed as part of single-user login finalisation. If you own this account you can |log in using your previous username and password for more information. If you do not like this account's new name, you can choose your own using this form after logging in: . -- Keegan (WMF) (talk) 05:37, 19 April 2015 (UTC)

title: User talk:Uaxuctum~enwikibooks


text:
Linux Guide/Audacity to MP3

Setting Up Audacity
Before we can use Audacity, we need to install it.

MP3s and Audacity
To make MP3s, Audacity needs the LAME library installed. First we need to create LAME, then tell Audacity where it is. You can list all compatible files in /usr with the command find /usr |grep -E 'lib[^*]*lame[^*]*.so' or your whole computer with find / | grep -E 'lib[^*]*lame[^*]*.so' If you find a libmp3lame.so file (using Debian Sarge 3.1r1), just tell Audacity were it is (below).

Otherwise, you will need to make LAME first:

Install LAME

 * Make sure that GNU make and gcc are installed. To do this, you can type make -v and gcc -v and make sure you don't get a "command not found" error. The -v option just prints the version.

 * The LAME library is available from . Download the latest version from the file releases.

 * The download is a .tar.gz, you can use ark to extract the files into a folder.

 * Go to the console
 * In the Linspire menu this is L > Programs > Utilities > Console
 * In Konquer press F4

cd " " replacing   with the directoy LAME was extracted to; and press enter. e.g.: ''' cd "/home/user/lame"
 * In the Console, type

cd "lame*" to go into a directory called something like "lame-3.96.1". You can use cd "lame-3.96.1" instead. You may need to go deeper into the DIR,...so once again;
 * Now type

cd lame*

such that you may end up here (or similar); /LAME/lame-3.96.1/lame-3.96.1

Once you are able to type in;

./configure --help

and get back an output of useful info, instead of a bash/shell error you know then you are in the correct DIR.

./configure
 * LAME configures itself automatically - type dot slash configure and press enter:

 * However; Please read either the INSTALL file, the README file, or review the ./configure --help output (if more advanced) to determine your build options. I chose to include these --enable-mp3x and --enable-debug=norm. Notice many options are defaulted to yes.

make and press enter.
 * When it returns to the command prompt you would type

make install and press enter. If you aren't root, type: su -c "make install" and press enter. Type the root password when asked (it will be invisible) and press enter.
 * LAME is now made in that directory, we'd like it installed into the system. This installation requires you to be root (super-user). If you are root (the prompt will be root@something# ) then type:

Install to Audacity
When LAME is installed, we need to tell Audacity about it. The first time you go to export to an MP3 Audacity will ask you where libmp3lame.so is located. You can simply point it to the libmp3lame.so file, normally in the /usr/local/lib folder, and click OK and you should be all set.

title: Linux Guide/Audacity to MP3


text:
Talk:JLPT Guide

Starting point
We must remember that these guides were created to help people pass the JLPT level 4 test. Work on the JLPT 4 test first, and then if you wish, go to level 3,2, and then 1. —Preceding unsigned comment added by 209.7.140.15 (discuss • contribs) 09:56, 17 December 2004

 * I'll have to disagree here. Not everyone comes to this book looking for basic stuff. Aside from that, this is a volunteer-based collaborative project. Just work on whatever you like and think is best. --Swift (talk) 03:41, 11 April 2009 (UTC)

 * Like Swift said, I think we should work on what we think is best. These guides are not limited to the beginner level, but cover (or can cover) all levels. --211.120.119.94 (talk) 01:41, 2 December 2010 (UTC)

Categorization
I put this into Category:Standard curricula because many other college admissions tests reside there as well and Category:Standardized tests is pretty much empty and not worthy of a top-level category. On JLPT Guide/About JLPT it states this test was a requirement for admission into Japanese colleges until 2003. Thus, I feel Category:Standard curricula is acceptable. If there were an easy way to refile everything in Standard curricula in Standardized tests and then rename Subject:Standard curricula to Subject:Standardized tests, it might be that the latter would be preferable. -- Adrignola talk contribs 15:19, 1 May 2009 (UTC)

 * There is a difference between a test and a curriculum. While JLPT certification is often used as a requirement for school and work, there is no openly published curriculum. There is even no official list of things to study. Only the test itself is standardised in the sense that scores should accurately reflect abilities, and the evaluation is consistent over time.
 * I see a use for both subjects. Both SATs and GREs are standardised tests, but there are also some books here on Wikibooks that are designed specifically to fit standard curricula (e.g. the South African Home Economics ... can't remember an actual example, but I can try to dig it up if you like). --Swift (talk) 01:42, 5 May 2009 (UTC)

Use of Japanese in describing test contents
On many of the pages, grammar terms and table headers are written in Japanese. The focus of the test is learning Japanese, so this is understandable. However, for N5 and N4 test takers, the focus of the test is on test contents -- not on learning more complicated kanji in order to learn what the test contents are. Is it reasonable to use table headers like "meaning" instead of "意味", particularly on N5 and N4 pages? Astrochicken (talk) 23:48, 30 November 2010 (UTC)

Using ruby on kanji lists
In the kanji lists, I think we should use the following formatting

The following formatting is common for longer texts, but not so good for lists of kanji that already show the onyomi and kunyomi.
 * べ

Thoughts? --Astrochicken (talk) 01:12, 9 December 2010 (UTC)

title: Talk:JLPT Guide


text:
Talk:Japanese/Random Lessons

This page is being built little by little. If you wish to help, you could help divide the main page for me into catagories such as.

1. Watashi. 2. Nihon:go,jin 3. Arimasu ka?

title: Talk:Japanese/Random Lessons


text:
Wikijunior talk:Solar System/Saturn

Enceladus
I can't find a non-wikipedia source for "It is denser than other icy moons. That suggests it also has some rock and iron inside." Help!--Shanel 22:47, 28 September 2005 (UTC)

 * I did a quick search on enceladus and came up with http://en.wikipedia.org/wiki/Enceladus_(moon)#Interior

However, I think this whole discussion is complicated for the 8-11 crowd. In general, there is WAY too much information in this wikibook. That's what you get when you write a textbook by committee! --SV Resolution 00:18, 29 September 2005 (UTC)

Iapetus

 * ...The ridge...is up to 20 km high, which is over 20 times higher than Mount Everest
 * Well, all your references say it's up to 20 km wide (not high) and up to 13 km high.
 * Mount Everest is 8.8 km high, so the ridge is 1.5 times higher than 13 km (or just 2.3 times higher compared with 20 km) Knightowld 10:35, 12 March 2006 (UTC)

title: Wikijunior talk:Solar System/Saturn


text:
Talk:Algorithms/Introduction

Todo

 * 1) It would be nice in the end of this section, wherein each of the techniques are described, to show pictures for each technique. For example, the backtracking discussion can show a tree, while the DP discussion can show a tree with colored branches where the same color represents redundantly solved subproblems. Similarly, DnC can be show in its own division tree. I think it's helpful to descirbe semantics with pictures, and it would just be another way to drive these points home.

What You Will Learn

 * [NOTE: This is a final section of Chapter 1, to be placed in after the book has evolved enough to make the claim true.]

The primary aim of this book is to help you separate the wheat from the chaff from the large field of algorithms. The book is short enough so that it could be read over the course of one semester, primarily to encourage you to be aware of all of the topics we cover, and how they relate to each other. The comprehensive texts that we recommend in the preamble are useful when you encounter specific problems in software development or research, but often the key points can be lost in such a large treatment. Through the guidance of our own teachers we have beter learned what's important and what's not. This book is dedicated to those teachers.

 * On note to massage into this: "The books by (Knuth) and (CLRS) also separate the wheat from the chaff, but in another sense. These authors will literally review all of the technical literature available to find the best and most useful results and present them all in the same notational framework. Thus, part of the purpose they serve is to filter out unimportant results. While we whole-heartedly recommend these books as references it is a rare person who can read so fast or have enough spare time to read them cover-to-cover." MShonle 15:32, 18 Dec 2004 (UTC) (I'd like the end of chapter one to have the dedication, and not the qualification of "Knuth is good... but", but it's an important point, I believe.)

A routine for converting a single character to lower case is required This is not really true, and in fact most real-world ASCII tolower routines are written without a separate routine. Here, the author is abstracting the character routine ahead of time, so that he can reuse the routine in a future function; a beginning programmer may think that they are expected to anticipate such abstractions before writing their code. It may be more instructive to either explain the abstraction ahead of time (and not implying that it is obvious), or to leave the character routine within the string tolower function and refactor it out only after observing that the character comparision function shares the same functionality. There should also probably be a note that these routines only apply to lower 128-bit ASCII encodings.

Joe Lee 21:03, 5 Jun 2005 (UTC)

 * There's no reason at all that these apply to only 7-bit ASCII (for starters, it applies to many other encodings). The text itself allows for unicode (the comment "These techniques depend upon the character encoding" covers this quite well). Also, I think the quotes around "obvious" make it clear that it's not expected for someone to think of it immediately. But this is an advanced text and we should limit hand holding. If a programmer cannot reflect that an entire string needs to be read by a string handling routine, this book is probably too advanced for them. If anything, there is already too much hand holding, covering such a basic concept suitable to introductory programming students.

 * I have cleaned up the text to address your concerns. Thanks! MShonle 21:56, 5 Jun 2005 (UTC)

Precomputing string lengths
The book currently states "Note that for a pair of strings, it is also possible to have the length precomputed to avoid the second pass, but that can have its own drawbacks at times."; however as far as I can tell, C and C++ are essentially the only programming languages that usually don't carry around string length data with the string, so I think that statement is misleading at best. -- intgr 13:20, 3 April 2007 (UTC)

title: Talk:Algorithms/Introduction


text:
User:Yacht/Listening Tank

A person can not be said to be fully mastering a language without being able to understand what other people are saying in that language. Listing ability of foreign language is a very important skill in learning a foreign language. Since there are a lot of contributors from all over the world in wiki, it’s possible to gather everyone’s effort to set up a Multilanguage Listening Tank for language learners.

How to help?
It’s very easy to help if you are interested in this project. What you need to do is 1) find an appropriate material in that language, 2) record your voice when you read that. Since everyone speaks at least one language, everyone can make contribution. You don’t have to be a native speaker to make contribution to certain language. For example, if you are a native French speaker, you can still make effort in making English listening material. A master language learner should be able to understand when this language is spoken by non-native speakers.

Material
You can find articles in a certain language release in any copyleft license.

Approaches
There is a lot of forms of listening test for learners. You can simply make it as “multiplied choices”, “dictation”, “answer the question”.

Record your voice
Find appropriate software to record your voice.

Level
If you are a native speaker, mark that at the very first beginning of the listening material; if you are not a native speaker, mark that too, so that learner can decide what level it is.

title: User:Yacht/Listening Tank