text:
User talk:67.161.38.65

Welcome!
Welcome to Wikibooks, a collection of open-content textbooks! You don't have to log in to read or edit articles on Wikibooks, but creating an account is quick, free and non-intrusive, requires no personal information, and gives you many benefits, including:
 * The use of a username of your choice
 * The ability to view all your contributions via a "My contributions" link
 * Your own user page
 * Your own talk page which, if you choose, also allows users to send you messages without knowing your e-mail address
 * The use of your own personal watchlist to which you can add articles that interest you
 * The ability to rename pages.
 * The ability to upload images
 * The ability to customize the appearance and behavior of the website
 * The eligibility to become an administrator
 * The right to be heard in votes and elections
 * Your IP address will no longer be visible to other users.

We hope that you choose to become a Wikibookian and create an account. Feel free to ask me any questions you may have on my talk page. By the way, make sure to sign your posts and comments with four tildes (~~~~), which will let others know who left it.

title: User talk:67.161.38.65


text:
Geometry for Elementary School/Bisecting an angle

BISECT ANGLE $$\angle ABC $$
 * 1) Use a compass to find points D and E, equidistant from the vertex, point B.
 * 2)  Draw the line $$\overline{DE}$$. [[Image:Geom bisect angle 04.png|396 px]]
 * 3) Construct an equilateral triangle on $$\overline{DE}$$ with third vertex F and get $$\triangle DEF $$. (Lines DF and EF are equal in length). [[Image:Geom bisect angle 05.png|396 px]]
 * 4)   Draw the line $$\overline{BF}$$. [[Image:Geom bisect angle 06.png|396 px]]

Claim

 * 1) The angles $$\angle ABF $$, $$\angle FBC $$ equal to half of $$\angle ABC $$.

The proof

 * 1) $$\overline{DE}$$ is a segment from the center to the circumference of $$\circ B,\overline{BD} $$ and therefore equals its radius.
 * 2) Hence, $$\overline{BE}$$ equals $$\overline{BD}$$.
 * 3) $$\overline{DF}$$ and $$\overline{EF}$$ are sides of the equilateral triangle $$\triangle DEF $$.
 * 4) Hence, $$\overline{DF}$$ equals $$\overline{EF}$$.
 * 5) The segment $$\overline{BF}$$ equals to itself
 * 6) Due to the Side-Side-Side congruence theorem the triangles $$\triangle ABF $$ and  $$\triangle FBC $$ congruent.
 * 7) Hence, the angles $$\angle ABF $$, $$\angle FBC $$ equal to half of $$\angle ABC $$.

Note
We showed a simple method to divide an angle to two. A natural question that rises is how to divide an angle into other numbers. Since Euclid's days, mathematicians looked for a method for trisecting an angle, dividing it into 3. Only after years of trials it was proven that no such method exists since such a construction is impossible, using only ruler and compass.

Exercise

 * 1) Find a construction for dividing an angle to 4.
 * 2) Find a construction for dividing an angle to 8.
 * 3) For which other number you can find such constructions?

Geometria per scuola elementare/Bisettrice di un angolo

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


text: User talk:213.49.115.167

title: User talk:213.49.115.167


text:
User talk:81.174.170.80

Please stop adding nonsense to Wikibooks. It is considered vandalism. If you would like to experiment, use the sandbox. Thank you.

title: User talk:81.174.170.80


text:
Geometry for Elementary School/Bisecting a segment

In this chapter, we will learn how to bisect a segment. Given a segment $$\overline{AB}$$, we will divide it to two equal segments $$\overline{AC}$$ and $$\overline{CB}$$. The construction is based on book I, proposition 10.

The construction

 * 1) Construct the equilateral triangle  $$\triangle ABD $$ on $$\overline{AB}$$.
 * 2) Bisect an angle on $$\angle ADB $$  using the segment $$\overline{DE}$$.
 * 3)  Let C be the intersection point of $$\overline{DE}$$ and $$\overline{AB}$$.

Claim

 * 1) Both $$\overline{AC}$$ and $$\overline{CB}$$ are equal to half of $$\overline{AB}$$.

The proof

 * 1) $$\overline{AD}$$ and $$\overline{BD}$$ are sides of the equilateral triangle $$\triangle ABD $$.
 * 2) Hence, $$\overline{AD}$$ equals $$\overline{BD}$$.
 * 3) The segment $$\overline{DC}$$ equals to itself.
 * 4) Due to the construction $$\angle ADE $$ and $$\angle EDB $$ are equal.
 * 5) The segments $$\overline{DE}$$ and $$\overline{DC}$$ lie on each other.
 * 6) Hence, $$\angle ADE $$ equals to $$\angle ADC$$  and $$\angle EDB $$ equals to $$\angle CDB $$.
 * 7) Due to  the Side-Angle-Side congruence theorem the triangles $$\triangle ADC $$ and  $$\triangle CDB $$ congruent.
 * 8) Hence, $$\overline{AC}$$ and $$\overline{CB}$$ are equal.
 * 9) Since $$\overline{AB}$$ is the sum of $$\overline{AC}$$ and $$\overline{CB}$$, each of them equals to its half.

Geometria per scuola elementare/Bisezione di un segmento


text:
User talk:129.188.33.222

Welcome!
Welcome to Wikibooks, a collection of open-content textbooks! You don't have to log in to read or edit articles on Wikibooks, but creating an account is quick, free and non-intrusive, requires no personal information, and gives you many benefits, including:
 * The use of a username of your choice
 * The ability to view all your contributions via a "My contributions" link
 * Your own user page
 * Your own talk page which, if you choose, also allows users to send you messages without knowing your e-mail address
 * The use of your own personal watchlist to which you can add articles that interest you
 * The ability to rename pages.
 * The ability to upload images
 * The ability to customize the appearance and behavior of the website
 * The eligibility to become an administrator
 * The right to be heard in votes and elections
 * Your IP address will no longer be visible to other users.

We hope that you choose to become a Wikibookian and create an account. Feel free to ask me any questions you may have on my talk page. By the way, make sure to sign your posts and comments with four tildes (~~~~), which will let others know who left it.

title: User talk:129.188.33.222


text: User talk:213.73.116.110

title: User talk:213.73.116.110


text: User talk:71.113.242.85

title: User talk:71.113.242.85


text:
Java Programming/Comments

A comment allows to insert text that will not be compiled nor interpreted. It can appear anywhere in the source code where whitespaces are allowed.

It is useful for explaining what the source code does by:
 * explaining the adopted technical choice: why this given algorithm and not another, why calling this given method...
 * explaining what should be done in the next steps (the TODO list): improvement, issue to fix...
 * giving the required explanation to understand the code and be able to update it yourself later or by other developers.

It can also be used to make the compiler ignore a portion of code: temporary code for debugging, code under development...

Syntax
The comments in Java use the same syntax as in C++.

An end-of-line comment starts with two slashes and ends with the end of the line. This syntax can be used on a single line too.

A comment on several lines is framed with '/' + '*' and '*' + '/'.

By convention, subsequent lines of slash-star comments begin with a star aligned under the star in the open comment sequence, but this is not required. Never nest a slash-star comment in another slash-star comment. If you accidentally nest such comments, you will probably get a syntax error from the compiler soon after the first star-slash sequence.

If you need to have the sequence */ inside a comment you can use html numeric entities:.

Slash-star comments may also be placed between any Java tokens, though not recommended:

However, comments are not parsed as comments when they occur in string literals.

It results in a 33 character string.

Question 3.26: Consider the following code:

What is printed in the standard output?

The highlighted lines are code lines but line 11 does nothing and only the first part of line 12 is code.

Comments and unicode
Be aware that Java still interprets Unicode sequences within comments. For example, the Unicode sequence  (whose codepoints correspond to */) is processed early in the Java compiler's lexical scanning of the source file, even before comments are processed, so this is a valid star-slash comment in Java:

and is lexically equivalent to

(The  character is Unicode   and the   character is Unicode  .)

Similar caveats apply to newline characters in slash-slash comments.

For example:

That is because  is Unicode for a new line, making the compiler think that you have added a new line when you haven't.

Javadoc comments
Javadoc comments are a special case of slash-star comments.

title: Java Programming/Comments


text:
User talk:Orderud

Computing Bookshelves
Hey Orderud, I don't think we need to merge the three book shelves. Here's what an ideal organization would be: That's just my two cents, but the differences between CS and IT are so great that they shouldn't belong on the same shelf. --MShonle 18:42, 9 October 2005 (UTC)
 * 1) Computer Science -- the more "math-like" stuff you would get in college
 * 2) Programming -- language guides, library tutorials, programming tips and recipies
 * 3) IT -- about computer programs, using them, set up of networks, so long as you aren't writing much "code"
 * There's a reply for you on my user page. --MShonle 22:16, 9 October 2005 (UTC)

Programming:MS Visual Studio
Hello there Orderud,

What is your view on moving all C++ content from Programming:MS Visual Studio to Programming:C plus plus this is already a Win32 and MFC section there if the content in the future gets to big a separate book can be created to keep it as I see now it consists only on some wikipedia links and a single module also consider that in the C++ book it will get more visibility and probably more contributions, if not consider at least on using transclusion for content that relates only to C++ (non Visual Studio dependent)--Panic 18:45, 16 October 2005 (UTC)

 * Sounds like a good suggestion. Feel free to move the content as you please :) --Orderud 19:34, 16 October 2005 (UTC)

 * Txs, new location of the content is [Using Static Libraries], if you have more just add to it's parent...--Panic 04:45, 17 October 2005 (UTC)

C++ Libraries, linker and navigation
Can you provide a motive for the page moves of the library sections (I've read the comments) and they don't make sense, since it was evolving toward the other side of the spectrum, (it's been implement across the book, so retracing it would require a major restructure) we do sacrifice clarity of path to enable easier navigability (better that using navigational aids and templates), even what you said on the comment is incorrect, since C++ (and C also) "programs" will consists of one or more translation units that are compiled separately, this results in separated object files are then linked together to produce an executable file. Keeping the navigational structure intact is very important and rational on this case (I have fixed the one I know, broke the book structure and the print version), if you agree with the concept, can you see if you can undo the moves and correction of paths ? --Panic (talk) 18:04, 5 January 2009 (UTC) We can use redirects also to improve path visibility if you think it is important, I was going to experiment with those to enable more logical navigation but I'm going from start to end (in relation to the TOC), another example of the use of this navigational structure that is still incomplete is on the /Code/ this will slowly extend to the rest of the book see C++ Programming/Programming Languages/C++/Code/Style Conventions/Documentation... --Panic (talk) 18:06, 5 January 2009 (UTC)

 * Sorry for breaking the book structure. I'm not that experienced when it comes to wikibook editing, and have no idea about book structure and how print versions are built. My intention was only to make the module paths more intuitive. Especially, I found the /Compiler/Linker/Libraries/ path structure very strange, and therefore moved some modules beneath /Libraries/ instead. As for navigation, I don't see any prev or next links or a navigation bar anywhere to navigate between the modules. How are users supposed to navigate through the book? --Orderud (talk) 00:06, 6 January 2009 (UTC)

 * No big problem, so far I only detected that break and you fixed most of the links and didn't tag the redirects for deletion (so they are virtual placeholders) for the previous content. As for prev and next I the first part of the book addresses it by including references to those section that are relevant (you corrected some of those links they are labeled as something Section, and I also used old Wikipedia (were possible and on scope) to local book pages that cover the issues as for the navigation one must use the ones provided by the strange paths (like the example I gave above C++ Programming/Programming Languages/C++/Code/Style Conventions/Documentation or use the category link Category:C++ Programming (that will show all pages of the book, this is not as great as using a navigational template, but come close and is easier to maintain, especially if we move pages about, the normal way people navigate book is to use the toc and the browser back or history function will cover that, the major problem is that the root page or cover page doesn't hold the real toc of the book (were clicking on C++ Programming would show the toc), there is a pending request for the administration to fix that... --Panic (talk) 00:55, 6 January 2009 (UTC)
 * The book had a navigational scheme in the past but was not maintained and was voted for removal, this method can be more confusing but if you look at toc1 is easy to fallow he arrangement, and enables users not professional with templates to make changes due to the use of transclusiom... --Panic (talk) 00:57, 6 January 2009 (UTC)

title: User talk:Orderud


text:
Georgia Water

Note: "Georgia Water" is the shorthand book name and refers to the United States state.

Table of contents

 * 1) Policies
 * 2) /Laws/
 * 3) /Management Programs/
 * 4) /Information/
 * 5) /Planning/
 * 6) /Best Practices/
 * 7) /Statewide Plan/
 * 8) /Regional Plans/
 * 9) *Savannah and Ogeechee Rivers
 * 10) *Satilla, Suwannee and St. Marys Rivers
 * 11) *Oconee, Ocmulgee and Altamaha Rivers
 * 12) *Flint and Ochlockonee Rivers
 * 13) *7.6. Chattahoochee River
 * 14) *Coosa, Tallapoosa, Tennessee Rivers
 * 15) *Georgia Coastal Area (Floridan Aquifer)
 * 16) /References/
 * 17) /External Links/

title: Georgia Water


text:
Muggles' Guide to Harry Potter/Magic/Invisibility Cloak

Overview
An invisibility cloak is a cloak designed to conceal its wearer. It is made of a special type of material that makes its occupant invisible. When nobody is inside it, it looks like a silvery, almost transparent fabric.

Extended Description
Invisibility cloaks are very rare, but Harry receives one for Christmas in his first year; it turns out to have been originally the property of Harry's father, and was given to Harry by Professor Dumbledore. Harry uses it a number of times in the books, whenever he needs to go somewhere unobserved, often with one or more of his friends; he does note that it is a mixed blessing, as it hides you from vision, but you still have to be careful about making sounds or bumping into things or people.

Alastor Moody apparently owns two Invisibility Cloaks; Sturgis Podmore is wearing one of them when he is arrested in the Ministry, and Arthur Weasley is wearing the other when he is attacked by the snake, in Harry Potter and the Order of the Phoenix.

Analysis
The invisibility cloak is the perfect device for moving around undetected. As Harry often has the need to break rules, he needs a device such as this and an invisibility cloak seems like the perfect choice. Unlike the Disillusionment charm, which makes an object a near-perfect chameleon, the invisibility cloak makes the object transparent, and can only be pierced by magical – or possibly cat – eyes: Professor Moody's magical eye seems to be able to see through it easily, and there is the suggestion that both Mrs. Norris and Crookshanks can sense Harry under it, though in fact the cats may be hearing rather than seeing the passage of those within. Peeves also senses Harry, Ron, and Hermione under the Cloak in Harry Potter and the Philosopher's Stone, though it is obvious that he is hearing rather than seeing them. Additionally, in Harry Potter and the Chamber of Secrets, Professor Dumbledore looks right at Harry and Ron underneath the Invisibility Cloak while in Hagrid's hut, suggesting that Dumbledore might actually be able to see through the Invisibility Cloak. Dumbledore had hinted at this ability in Harry Potter and the Philosopher's Stone, when he caught Harry in front of the Mirror of Erised.

Greater Picture
It is noted elsewhere that Dumbledore is able to make himself invisible without using a cloak; Dumbledore says this himself in Harry Potter and the Philosophers' Stone. And yet, James Potter left his invisibility cloak in Dumbledore's care. What need of an invisibility cloak would Dumbledore have? The author has stated that this is an important question to ponder.

In Harry Potter and the Deathly Hallows, we learn that this is because James Potter's Invisibility Cloak is, indeed, something special. Talking with Xeno Lovegood, the Trio learn of the possible existence of the three Deathly Hallows. Xeno reminds them that most Invisibility Cloaks are either simple traveling cloaks to which a Disillusionment Charm has been applied, or are woven out of the hair of a Demiguise, but all such become damaged or fade into visibility with time. Only one Invisibility Cloak, the third of the three Hallows, and supposedly the Cloak of Death himself, does not suffer the ravages of time, and cannot be damaged by magic. Harry, Ron, and Hermione are uncomfortably aware at this point that the Cloak in Harry's possession matches this description perfectly.

It turns out that Dumbledore, in his youth, had heard the legend of the three Hallows, and had been trying to find them. Though his active search for them had stopped by the time he was a teacher at Hogwarts, his youthful obsession with them had never completely faded, and he had borrowed James' Cloak, once he had heard of its properties, because he recognized it as a Hallow. It was while he was examining it that Voldemort killed James and Lily, and tried to kill Harry.

There is some question as to exactly how functional an Invisibility Cloak is, given that Alastor Moody's magical eye can see through it without difficulty, Harry's presence on the Marauder's Map is not changed by his being under his cloak, and Nagini evidently can see Arthur Weasley in the Ministry. In the latter case, however, we note that a careful reading of the text would suggest strongly that Arthur has fallen asleep and the cloak has slipped partially off him. As such, we believe that snakes (notably pit vipers, who have infrared sensors as well as eyes) may be able to detect the presence of someone under a cloak, but only by the heat they radiate; it is unlikely that they can directly see the person under the cloak. There is no mention of Voldemort having added extra senses in his efforts to make himself appear more snake-like.

On Professor Dumbledore's ability to sense Harry underneath the Invisibility Cloak, we believe that Dumbledore is actually being rather more devious than we expect him to be so early in the series; we learn, gradually, as the story arc progresses, exactly how little of his knowledge Dumbledore is allowing to escape. We feel it is most likely that Dumbledore is actually not perceiving Harry under the cloak, but rather is using Legilimency to see what Harry is seeing, and working backwards from that to determine where he is. We suspect Professor Snape attempts to do this as well, in Harry Potter and the Deathly Hallows.

It is noted also that Dementors are not impeded by Invisibility Cloaks. It is noted that Invisibility Cloaks only stop one from seeing someone who is wearing it; Harry, for instance, has difficulty making his way through the Hogwarts Express, while wearing his cloak, because of the extreme care he must take not to bump into anyone or step on feet. Since Dementors do not have eyes, the senses they use to detect and identify people must be somehow other than visual, probably related to the mental effects they have on people. Clearly, these senses are not stopped by Invisibility Cloaks.

From the above, we believe that an Invisibility Cloak will completely shield the user from anyone else's eyes. The few exceptions that we have noted are Moody's magical eye, and those artifacts and creatures that use something other than eyes to perceive the individual. (Note that Moody's magical eye likely is, in fact, just such an artifact. Moody, being nearly paranoid, would charm his magical eye with any additional information-gathering charms he could, and if the Marauders can do it with the Marauder's Map, it is extremely likely a wizard of Moody's ability could charm his Eye the same way.)


text:
Movie Making Manual/Sales and Exhibition/Putting Videos Online

MPEG4-AVC provides the most efficient compression compared to every other codec out there.

There are some opensource H.264 encoders (e.g. x264), and people have used them to successfully compress video, but they are buggy at present.

Probably the most cost effective way to produce H.264 is to use Apple Quicktime 7 Pro. The video really deteriorates below about 512kbps but 1Mbps is pretty nice.

Encoding H.264 Quick Times from Premiere Pro
First, download the most recent version of Apple Quicktime.

Then take a look at Apple's H.264 encoding guide.

Beware: encoding H.264 using two passes on QT Pro 7.0.3 takes a long time (a 3 minute SD video took 2 hours to encode on an Athlon64 2.4GHz).

Problems setting datarate
For some reason, if you try to use the Adobe Media Encoder from within Premiere Pro 1.5.1 then you can't set the datarate. So export from PPro as an uncompressed AVI, import into Quicktime 7 Pro, compress as MP4 and set as H.264. Or, alternatively, change the "export size". In premiere when you look at your transcode settings in the Media encoder, it is under the Video area. Underneath where you choose the video codec settings, you can tell the encoder a frame size.

 * "Can't set bitrate when encoding QT H.264 using Adobe Media Encoder" thread on Creative Cow.

Gamma problems
RGB movies can look washed out when converted to H.264. You need to convert to YUV colour space first.

Banding
There seem to be some serious problems with banding. Any ideas?!

Encoding PAL 16:9 at 1500kbps

 * 1) Download "WM9 PAL 16-9 1500kbps 720x576.vpr" by right clicking on this link and selecting "Save link as".
 * 2) Save this file to C:\Program Files\Adobe\Premiere Pro 1.5\MediaIO\presets\system
 * 3) In Premiere Pro, go to File > Export > Adobe Media Encoder
 * 4) Select Format: Windows Media
 * 5) Select Preset: WM9 PAL 16-9 1500kbps 720x576
 * 6) Make any changes necessary (note that the datarate, audio format, pixel size and aspect ratio are set in the "Audiences" tab)
 * 7) Click OK
 * 8) Select a file name and whether or not you want to export the entire sequence and click Save
 * 9) Note that this preset is two-pass so you'll get two "Encoding" progress bars.

/Tools and equipment /Editing /Sales and exhibition


text:
User talk:62.171.194.6

Given the record on Wikipedia - blocked -- Herby talk thyme 09:28, 15 March 2007 (UTC)

title: User talk:62.171.194.6


text:
Movie Making Manual/Post-production/Importing From a DVD

This is a bit long winded and there's probably a better solution out there... but this works:

 * 1) Decrypt and copy the VOBs to your hard disk (e.g. using DVD Decrypter.  Note that decrypting DVDs that you do not own the copywrite for is illegal!)
 * 2) Convert the video to an uncompressed AVI using DVD2AVI 1.9
 * 3) Rename the .VOB to .MPG
 * 4) Import both the uncompressed AVI and the .MPG into Premiere Pro
 * 5) Use the audio from the .MPG and the video from the AVI

For some reason, DVD2AVI doesn't export the audio properly. And, for some reason, Premiere Pro really doesn't like decoding the .MPG video! So you have to use the two together. If Premiere Pro behaved itself, it would be possible to import the .VOB directly into PPro (after renaming it to .MPG).

The core of the problem with Premiere's MPEG handling is caused by the fact that Premiere asks Windows to connect it to the MPEG decoder. (This is as opposed to how it handles DV, for which it uses the MainConcept codec exclusively.) Any given computer probably has at least 2 or 3 decoders on it, and whatever is the most recently installed will be what Windows feeds back to Premiere. The decoder in use may or may not play nicely with Premiere. In particular, the Intervideo WinDVD decoder seems to be especially unfriendly.

The solution is to change which DVD decoder has highest priority. Preferably the MainConcept decoder, which Premiere installs, will be the one. Try searching the Premiere Pro forum on the Adobe site, there have been some tools mentioned there that will change MPEG decoder priority (or you can just hack the registry if you know where to go).

Another solution that has been reccomended on the Premiere Elements forum is to install the free K-Lite codec package. It includes the MainConcept decoder (which calls into question the legality of this package), and if you select MC to be the default during the K-Lite install, all seems to be fine with at least Premiere Elements and MPEG handling. PrPro shouldn't behave differently. Basically, with this solution, you're just pasting another version of the MC codec on top of whatever's already there.

=Handbrake=

Handbrake is an all-in-one system for converting from DVD to MPEG-4 (even AVC). At the time of writing it runs well on Mac OS X and Linux and a port is available for Windows although it's currently unstable.

http://handbrake.m0k.org/

However, it should be noted that MPEG-4 is not a good choice of codec for video editing.

/Editing /Post-production


text:
Budget Watch Collecting/Other Budget Watch resources

Discussion forums:

National Association of Watch and Clock Collectors Lots of practical info on watch repair

alt.horology Google's view of the alt.horology newsgroup.

WatchUSeek watch forums

Seiko-Citizen watch forum for discussion of all Asian watches

Timex Watch Forum, the inspiration for this wiki

Poor Man Watch Forum for discussion of all watches under $1000 USD (mostly Budget watches)


text:
Guide to Unix/Explanations/Finding Additional Help

Google
Google is your friend. The Internet has a lot of example and command samples to perform tasks. All you have to do is run a search. This is often the only approach because the built in help really requires you to know the command name to start with which is not very useful.

For samples of actual code, you can try the Google code search with the option lang:shell.

Friends and support groups
You should never be shy of asking for help from knowledgeable people around you. They often will give you a quick answer that you have to research or tune to get the complete answer however it will give you a starting point for the following commands to be truly useful.


text:
Blended Learning in K-12/Work and Learning

Work and Learning

Although this Wikibook is primarily focused on Blended Learning in the K-12 envirornment, it is worth pointing out that Blended Learning occurs most often at the university level, and as a method of professional development in the business world.

One of the distinct advantages of Blended Learning in the workplace is that it allows employees to continue their professional development, while customizing their learning to fit their own needs. Thus an employee can immediately apply what he or she learns to their job. (Singh and Reed, 2001).

This is less applicable to a K-12 setting, except in terms of differentiation. It seems unlikely that a K-12 student would be participating in the type of work that would benefit from this type of course design. On the other hand, a Blended Learning course could allow a student to apply knowledge to other tasks, i.e. extra-curricular activities.


text:
Blended Learning in K-12/Pedagogical Models- blending constructivism, behaviorism and cognitivism

One of the harshest criticisms of Blended Learning is that the focus tends to be on the instructor, rather than on the learner. (Oliver and Trigwell, 2005).

Alonzo et al. point out that the concept of e-learning is new enough that practitioners have not yet begun to apply pedagogical principals to the process of e-learning. (2005)

Ideally, they continue, e-learning (and therefore Blended Learning) should be focused on the individual learner. The course designer should be able to utilize cognitive and constructionist theory to design an effective course. (Alonzo et al., 2005)

This course would be carefully organized so that students can easily insert new knowledge into their pre-existing schema. The organization should then reinforce the acquisition of new knowledge and activities should provide a scaffolded approach to help learners practice new skills by applying their knowledge. All of this is consistent with cognitive theories of learning, which tend to focus on the processes of information acquisition, organization, retrieval, and application.

Constructivist theories of learning describe learning as a process whereby the learner takes in new information, and inserts it into existing schema. Each learner constructs meaning differently based upon their own experiences. In other words, there is a disconnect between knowledge that is taught, and knowledge that is learned, because the learner will re-interpret what is being taught, and construct his or her own meaning from that knowledge.

To support the constructivist approach, a learning community should be created, and then guided through the process of collaboration so that learning is constructed by the group, rather than just the individual. (Alonzo et al., 2005)

In a traditional face-to-face learning environment, one of the more common methods of constructing group meaning is through discussion. The instructor typically begins the discussion by posing a question. The instructor then invites members of the class to make an impromptu response. Other class members then respond to the first student, and a discussion develops. In this way, students are exposed to several perspectives, and the answer to the original question is constructed for each learner based upon the individual's assessment of the group's responses.

In a blended environment, this discussion format can be easily adapted and enhanced. The discussion could be held synchronously, in group chat, or could be held asynchronously, in a forum to which learners post responses. In a blended environment, students have the capability of responding to several points at once. Since an asynchronous discussion can continue over a longer period of time, students can take time to formulate responses, and can respond to a particular part of a comment, even if the discussion has taken another route.


text:
Arabic/Verbs/fa3ala

فعل (fa-3a-la)

This is the verb with the meaning "to do". Lets conjugate it for هو (hu-wa) {meaning "he"}.
 * هو فعل شيئا

huwa fa`ala shai'an hu-wa—fa-`a-la--shai-an he did something.

 * هو يفعل شيئا

huwa yaf`alu shai'an hu-wa—yaf-`a-lu--shai-an He is doing something/He does something. Now let's conjugate it for هي (hiya) {meaning "she"}.

 * هي فعلت شيئا

hiya fa`alat shai'an hi-ya—fa-`a-lat--shai-an she did something.
 * هي تفعل شيئا

hiya taf`alu shai'an hi-ya—taf-`a-lu—shai-an She is doing something.

title: Arabic/Verbs/fa3ala


text:
Talk:Energy Efficiency Reference/Residential/How to Reduce Energy Usage

Theinformation given makes no mention of solar heating to use the energy to feed back into the electricity grid,how can this comment be inserted into the energy debate.In Ausralia a country will plenty of sunlight feww home s have solar panels if this were compulsory Iwonder how much electricity could be fed into the electricity supply. Thanky ou harryhaber@hotmail,com

merging this wikibook
Would anyone be opposed to merging this book with the wikibook "Energy Efficiency Reference"?? I think this would allow for a much more robust wikibook to be created. Comments? --Michael Koch (talk) 08:05, 18 February 2009 (UTC)

moving this page
it would be more sensible to have this book's title changed from "How to reduce home energy costs" to "How to reduce home energy usage," as this encompasses positive environmental effects of reducing usage, as well as economic ones. if no one objects, this page should be moved. --- Edited - 03/10/06 *added/bolded two cautions of existing tips.

format and topics
This "book" is more of a checklist. The format should be changed, the elements expanded and explained, diagrams and photos added where appropriate, and similar items.

I would recommend going area by area, rather than as it is now. For example, a section could be on "central heating", another on "water", and another on "electricity" ...

Each element should be tested for relevance to the topic; many items are not. For example: How does buying bigger items help with home energy conservation? (answer: it doesn't ). Another example: how does recycling help with home energy conservation? (answer: it doesn't ).

Now if I just would have logged in first.... 69.95.160.14 16:23, 6 April 2006 (UTC)

Domestic ventilation
Some of the advice given is unsound. If I understand correctly, using a fan to blow house air into the roofspace is OK. In the UK, this most certainly would not be OK. House air has a sufficiently high moisture content to cause loft ( roofspace) condensation, and indeed in the UK we seek to seal out the ceiling as much as possible. There are one or two exotic ventilation systems which supply air form the roof, but these are not in general use.

Modesty forbids me from referring readers to my book "Handbook of Domestic Ventilation" (Elsevier) for more detailed information........

Check the degrees celcius conversions. You're about 5 degrees off. 25.5C = 78F, not 30C.

Transwiki
This transwiki may yield useful content: Transwiki:Weatherization – Mike.lifeguard  | talk 05:05, 8 October 2007 (UTC)

Fan in Reverse?!
What moron would run the fan in reverse to, as this entry says "move the air up to the ceiling."

The second the heat leaves the insert ... it's headed straight for the ceiling! Why on earth would you waste your time using a ceiling fan to do what its alreay doing?

You run the fan COUNTER CLOCKWISE to pull the heat down from the ceiling, dispersing it out and into other rooms.

This whole entry was written by someone pretending to have credentials which anyone with 2nd grade physics knowledge can spot.


text:
Bourne Shell Scripting/Environment

No program is an island unto itself. Not even the Bourne Shell. Each program executes within an environment, a system of resources that controls how the program executes and what external connections the program has and can make. And in which the program can itself make changes.

In this module we discuss the environment, the habitat in which each program and command lives and executes. We look at what the environment consists of, where it comes from and where it's going... And we discuss the most important mechanism that the shell has for passing data around: the environment variable.

The Environments
When discussing a Unix shell, you often come across the term "environment". This term is used to describe the context in which a program executes and is usually meant to mean a set of "environment variables" (we'll get to those shortly). But in fact there are two different terms that are somehow a program's environment and which often get mixed up together in "environment". The simpler one of these really is the collection of environment variables and actually is called the "environment". The second is a much wider collection of resources that influence the execution of a program and is called the command execution environment.

The command execution environment
Each running program, either started directly by the user from the shell or indirectly by another process, operates within a collection of global resources called its command execution environment (CEE).

A program's CEE contains important information such as the source and destination of data upon which the program can operate (also known as the standard input, standard output and standard error handles). In addition, variables are defined that list the identity and home directory of the user or process that started the program, the hostname of the machine and the kind of terminal used to start the program. There are other variables too, but that's just some of the main ones. The environment also provides working space for the program, as well as a simple way of communicating with other, future programs, that will be run in the same environment.

The complete list of resources included in the shell's CEE is:

 * Open files held in the parent process that started the shell. These files are inherited. This list of files includes the files accessed through redirection (such as standard input, output and error files).
 * The current working directory: the "current" directory of the shell.
 * The file creation mode:The default set of file permissions set when a new file is created.
 * The active traps.
 * Shell parameters and variables set during the call to the shell or inherited from the parent process.
 * Shell functions inherited from the parent process.
 * Shell options set by set or shopts, or as command line options to the shell executable.
 * Shell aliases (if available in your shell).
 * The process id of the shell and of some processes started by the parent process.

Whenever the shell executes a command that starts a child process, that command is executed it its own CEE. This CEE inherits a copy of part of the CEE of its parent, but not the entire parent CEE. The inherited copy includes:

 * Open files.
 * The working directory.
 * The file creation mode mask.
 * Any shell variables and functions that are marked to be exported to child processes.
 * Traps set by the shell.

The 'set' command
The 'set' command allows you to set or disable a number of options that are part of the CEE and influence the behavior of the shell. To set an option, set is called with a command line argument of '-' followed by one or more flags. To disable the option, set is called with '+' and then the same flag. You probably won't use these options very often; the most common use of 'set' is the call without any arguments, which produces a list of all defined names in the environment (variables and functions). Here are some of the options you might get some use out of:

 * +/-a:When set, automatically mark all newly created or redefined variables for export.
 * +/-f:When set, ignore filename metacharacters.
 * +/-n:When set, only read commands but do not execute them.
 * +/-v:When set, causes the shell to print commands as they are read from input (verbose debugging flag).
 * +/-x:When set, causes the shell to print commands as they will be executed (debugging flag).

Again, you'll probably mostly use set without arguments, to inspect the list of defined variables.

The environment and environment variables
Part of the CEE is something that is simply called the environment. The environment is a collection of name/value pairs called environment variables. These variables technically also contain the shell functions, but we'll discuss those in a separate module.

An environment variable is a piece of labelled storage in the environment, where you can store anything you like as long as it fits. These spaces are called variables because you can vary what you put in them. All you need to know is the name (the label) that you used for storing the content. The Bourne shell also makes use of these "environment variables". You can make scripts that examine these variables, and those scripts can make decisions based on the values stored in the variables.

An environment variable is a name/value pair of the form

which is also the way of creating a variable. There are several ways of using a variable which we will discuss in the module on substitution, but for now we will limit ourselves to the simple way: if you prepend a variable name with a $-character, the shell will substitute the value for the variable. So, for example:

Simple use of a variable

As you can see from the example above, an environment variable is sort of like a bulletin board: anybody can post any kind of value there for everybody to read (as long as they have access to the board). And whatever is posted there can be interpreted by any reader in whatever way they like. This makes the environment variable a very general mechanism for passing data along from one place to another. And as a result environment variables are used for all sorts of things. For instance, for setting global parameters that a program can use in its execution. Or for setting a value from one shell script to be picked up by another. There are even a number of environment variables that the shell itself uses in its configuration. Some typical examples:

 * IFS:This variable lists the characters that the shell considers to be whitespace characters.
 * PATH:This variable is interpreted as a list of directories (separated by colons on a Unix system). Whenever you type the name of an executable for the shell to execute but do not include the full path of that executable, the shell will look in all of these directories in order to find the executable.
 * PS1:This variable lists a set of codes. These codes instruct your shell about what the command-line prompt in the interactive shell should look like.
 * PWD:The value of this variable is always the path of the working directory.

The absolute beauty of environment variables, as mentioned above, is that they just contain random strings of characters without an immediate meaning. The meaning of any variable is to be interpreted by whatever program or process reads the variable. So a variable can hold literally any kind of information and be used practically anywhere. For instance, consider the following example:

Environment variables are more flexible than you thought...

There's nothing wrong with setting a variable to the name of an executable, then executing that executable by calling the variable as a command.

Different kinds of environment variables
Although you use all environment variables the same way, there are a couple of different kinds of variables. In this section we discuss the differences between them and their uses.

Named variables
The simplest and most straightforward environment variable is the named variable. We saw it earlier: it's just a name with a value, which can be retrieved by prepending a '$' to the name. You create and define a named variable in one go, by typing the name, an equals sign and then something that results in a string of characters.

Earlier we saw the following, simple example:

Assigning a simple value to a variable

This just assigns a simple value. Once a variable has been defined, we can also redefine it:

Assigning a simple value to a variable

We aren't limited to straightforward strings either. We can just as easily assign the value of one variable to another:

Assigning a simple value to a variable

We can even go all-out and combine several commands to come up with a value:

Assigning a combined value to a variable

In this case, we're taking the output of the three commands 'whoami', 'hostname', and 'pwd', then we add the '$' symbol, and some spacing and other formatting just to pad things out a bit. Whew. All that, just in one piece of labeled space. As you can see environment variables can hold quite a bit, including the output of entire commands.

There are usually lots of named variables defined in your environment, even if you are not aware of them. Try the 'set' command and have a look.

Positional variables
Most of the environment variables in the shell are named variables, but there are also a couple of "special" variables. Variables that you don't set, but whose values are automatically arranged and maintained by the shell. Variables which exist to help you out, to discover information about the shell or from the environment.

The most common of these are the positional or argument variables. Any command you execute in the shell (in interactive mode or in a script) can have command-line arguments. Even if the command doesn't actually use them, they can still be there. You pass command-line arguments to a command simply by typing them after the command, like so:

This is allowed for any command. Even your own shell scripts. But say that you do this (create a shell script, then execute it with arguments); how do you access the command-line arguments from your script? This is where the positional variables come in. When the shell executes a command, it automatically assigns any command-line arguments, in order, to a set of positional variables. And these variables have numbers for names: 1 through 9, accessed through $1 through $9. Well, actually zero through nine; $0 is the name of the command that was executed. For example, consider a script like this:

WithArgs.sh: A script that uses command-line arguments

And a call to this script like this:

Calling the script

As you can see, the shell automatically assigned the values 'Hello' and 'World' to $1 and $2 (okay, technically to the variables called 1 and 2, but it's less confusing in written text to call them $1 and $2). What happens if we call this script with more than two arguments?

Calling the script with more arguments

This is no problem whatsoever — the extra arguments get assigned to $3 and $4. But we didn't use those variables in the script, so those command-line arguments are ignored. What about the opposite case (too few arguments)?

Calling the script with too few arguments...

Again, no problem. When the script accesses $2, the shell simply substitutes the value of $2 for $2. That value is nothing in this case, so we print exactly that. In this case it's not a problem, but if your script has mandatory arguments you should check whether or not they are actually there.

What about if we want 'Hello' and 'World' to be treated as one command-line argument to be passed to the script? I.e. 'Hello World' rather than 'Hello' and 'World'? We'll get deeply into that when we start talking about quoting, but for now just surround the words with single quotes:

Calling the script with multi-word arguments

Shifting
So what happens if you have more than nine command line arguments? Then your script is too complicated. No, but seriously: then you have a little problem. It's allowed to pass more than nine arguments, but there are only nine positional variables (in Bourne Shell at least). To deal with this situation the shell includes the shift command:

Shift causes the positional arguments to shift left. That is, the value of $1 becomes the old value of $2, the value of $2 becomes the old value of $3 and so on. Using shift, you can access all the command-line arguments (even if there are more than nine). The optional integer argument to shift is the number of positions to shift (so you can shift as many positions in one go as you like). There are a couple of things to keep in mind though:

 * No matter how often you shift, $0 always remains the original command.
 * If you shift n positions, n must be lower than the number of arguments. If n is greater than the number of arguments, no shifting occurs.
 * If you shift n positions, the first n arguments are lost. So make sure you have them stored elsewhere or you don't need them anymore!
 * You cannot shift back to the right.

In the module on Control flow we'll see how you can go through all the arguments without knowing exactly how many there are.

Other, special variables
In addition to the positional variables the Bourne Shell includes a number of other, special variables with special information about the shell. You'll probably not use these as often, but it's good to know they're there. These variables are

 * $#:The number of command-line arguments to the current command (changes after a use of the shift command!).
 * $-:The shell options currently in effect (see the 'set' command).
 * $?:The exit status of the last command executed (0 if it succeeded, non-zero if there was an error).
 * $$:The process id of the current process.
 * $!:The process id of the last background command.
 * $*:All the command-line arguments. When quoted, expands to all command-line arguments as a single word (i.e. "$*" = "$1 $2 $3 ...").
 * $@:All the command-line arguments. When quoted, expands to all command-line arguments quoted individually (i.e. "$@" = "$1" "$2" "$3" ...).

Exporting variables to a subprocess
We've mentioned it a couple of times before: Unix is a multi-user, multiprocessing operating system. And that fact is very much supported by the Bourne Shell, which allows you to start up new processes right from inside a running shell. In fact, you can even run multiple processes simultaneously next to each other (but we'll get to that a little later). Here's a simple example of starting a subprocess:

Starting a new shell from the shell

We've also talked about the Command Execution Environment and the Environment (the latter being a collection of variables). These environments can affect how programs run, so it's very important that they cannot inadvertently affect one another. After all, you wouldn't want the screen in your shell to go blue with yellow letters simply because somebody started Midnight Commander in another process, right?

One of the things that the shell does to avoid processes inadvertently affecting one another, is environment separation. Basically this means that whenever a new (sub)process is started, it has its own CEE and environment. Of course it would be damned inconvenient if the environment of a subprocess of your shell were completely empty; your subprocess wouldn't have a PATH variable or the settings you chose for the format of your prompt. On the other hand there is usually a good reason NOT to have certain variables in the environment of your subprocess, and it usually has something to do with not handing off too much environment data to a process if it doesn't need that data. This was particularly true when running copies of MS-DOS and versions of DOS under Windows. You only HAD a limited amount of environment space, so you had to use it carefully, or ask for more space on startup. These days in a UNIX environment the space issues aren't the same, but if all your existing variables ended up in the environment of your subprocess you might still adversely affect the running of the program that you started in that subprocess (there's really something to be said for keeping your environment lean and clean in the case of subprocesses).

The compromise between the two extremes that Stephen Bourne and others came up with is this: a subprocess has an environment which contains copies of the variables in the environment of its parent process — but only those variables that are marked to be exported (i.e. copied to subprocesses). In other words, you can have any variable copied into the environment of your subprocesses, but you have to let the shell know that's what you want first. Here's an example of the distinction:

Exported and non-exported variables

In the example above, the PATH variable (which is marked for export by default) gets copied into the environment of the shell that is started within the shell. But the VAR variable is not marked for export, so the environment of the second shell doesn't get a copy.

In order to mark a variable for export you use the export command, like so:

As you can see, you can export as many variables as you like in one go. You can also issue the export command without any arguments, which will print a list of variables in the environment marked for export. Here's an example of exporting a variable:

Exporting a variable

More modern shells like Korn Shell and Bash have more extended forms of export. A common extension is to allow for definition and export of a variable in one single command. Another is to allow you to remove the export marking from a variable. However, Bourne Shell only supports exporting as explained above.

Your profile
In the previous sections we've discussed the runtime environment of every program and command you run using the shell. We've talked about the command execution environment and at some length about the piece of it simply called "the environment", which contains environment variables. We've seen that you can define your own variables and that the system usually already has quite a lot of variables to start out with.

Here's a question about those variables that the system starts out with: where do they come from? Do they descend like manna from heaven? And on a related note: what do you do if you want to create some variables automatically every time your shell starts? Or run a program every time you log in?

Those readers who have done some digging around on other operating systems will know what I'm getting at: there's usually some way of having a set of commands executed every time you log in (or every time the system starts at least). In MS-DOS for instance there is a file called autoexec.bat, which is executed every time the system boots. In older versions of MS-Windows there was system.ini. The Bourne Shell has something similar: a file in every user's home directory called .profile. The $HOME/.profile (HOME is a default variable whose value is your home directory) file is a shell script like any other, which is executed automatically right after you login to a new shell session. You can edit the script to have it execute any login-commands that you like.

Each specific Unix system has its own default implementation of the .profile script (including none — it's allowed not to have a .profile script). But all of them start with some variation of this:

A basic (but typical) $HOME/.profile

This .profile might surprise you a bit: where are all those variables that get set? Most of the variables that get set for you on a typical Unix system, also get set for all other users. In order to make that possible and easily maintainable, the common solution is to have each $HOME/.profile script start by executing another shell script: /etc/profile. This script is a systemwide script whose contents are maintained by the system administrator (the user who logs in with username root). This script sets all sorts of variables and calls scripts that set even more variables and generally does everything that is necessary to provide each user with a comfortable working environment.

As you can see from the example above, you can add any personal configuration you want or need to the .profile script in your directory. The call to execute the system profile script doesn't have to be first, but you probably don't want to remove it altogether.

Multitasking and job control
With the arrival of fast computers, CPUs that can switch between multiple tasks in a very small amount of time, CPUs that can actually do multiple things at the same time and networks of multiple CPUs, having the computer perform multiple tasks at the same time has become common. Fast task switching provides the illusion that the computer really is running multiple tasks simultaneously, making it possible to effectively serve multiple users at once. And the ability to switch to a new CPU task while an old task is waiting for a peripheral device makes CPU use vastly more efficient.

In order to make use of multitasking abilities as a user, you need a command environment that supports multitasking. For example, the ability to set one program to a task, then move on and start a new program while the old one is still running. This kind of ability allows you as a user to do multiple things at once on the same machine, as long as those programs do not interfere. Of course, you cannot always treat each program as a "fire and forget" affair; you might have to input a password, or the program might be finished and want to tell you its results. A multitasking environment must allow you to switch between the multiple programs you have running and allow those programs to send you some sort of message if your attention is needed.

To make things a little more tangible think of something like downloading files. Usually, while you're downloading files, you want to do other stuff as well — otherwise you're going to be sitting at the keyboard twiddling your thumbs a really long time when you want to download a whole CD worth of data. So, you start up your file downloader and feed it a list of files you want to grab. Once you've entered them, you can then tell it "Go!" and it will start off by downloading the first file and continue until it finishes the last one, or until there's a problem. The smarter ones will even try to work through common problems themselves, such as files not being available. Once it starts you get the standard shell prompt back, letting you know that you can start another program.

If you want to see how far the file downloader has gotten, simply checking the files in your system against what you have on your list will tell you. But another way to notify you is via the environment. The environment can include the files that you work with, and this can help provide information about the progress of currently running programs like that file downloader. Did it download all the files? If you check the status file, you'll see that it's downloaded 65% of the files and is just working on the last three now.

Other examples of programs that don't need their hand held are programs that play music. Quite often, once you start a program that plays music tracks, you don't WANT to tell the program "Okay, now play the next track". It should be able to do that for itself, given a list of songs to play. In fact, it should not even have to hold on to the monitor; it should allow you to start running other software right after you hit the "play" button.

In this section we will explore multitasking support within the Unix shell. We will look at enabling support, at working with multiple tasks and at the utilities that a shell has available to help you.

Some terminology
Before we discuss the mechanics of multitasking in the shell, let's cover some terminology. This will help us discuss the subject clearly and you'll also know what is meant when you run across these terms elsewhere.

First of all, when we start a program running on a system in a process of its own, that process with that one running instance of the program is called a job. You'll also come across terms like process, task, instance or similar. But the term used in Unix shells is job. Second, the ability of the shell to influence and use multitasking (starting jobs and so on) is referred to as job control.

 * Job:A process that is executing an instance of a computer program.
 * Job control:The ability to selectively stop (suspend) the execution of jobs and continue (resume) their execution at a later point.

Note that these terms are used this way for Unix shells. Other circumstances and other contexts might allow for different definitions. Here are some more terms you'll come across:

 * Job ID: An ID (usually an integer) that uniquely identifies a job. Can be used to refer to jobs for different tools and commands.
 * Process ID (or PID): An ID (usually an integer) that uniquely identifies a process. Can be used to refer to processes for different tools and commands. Not the same as a Job ID.
 * Foreground job (or foreground process): A job that has access to the terminal (i.e. can read from the keyboard and write to the monitor).
 * Background job (or background process): A job that does not have access to the terminal (i.e. cannot read from the keyboard or write to the monitor).
 * Stop (or suspend): Stop the execution of a job and return terminal control to the shell. A stopped job is not a terminated job.
 * Terminate: Unload a program from memory and destroy the job that was running the program.

Job control in the shell: what does it mean?
A job is a program you start within the shell. By default a new job will suspend the shell and take control over the input and output: every stroke you type at the keyboard will go to the job, as will every mouse movement. Nothing but the job will be able to write to the monitor. This is what we call a foreground job: it's in the foreground, clearly visible to you as a user and obscuring all other jobs in the system from view.

But sometimes that way of working is very clumsy and irritating. What if you start a long-running job that doesn't need your input (like a backup of your harddrive)? If this is a foreground process you have to wait until it's done before you can do anything else. In this situation you'd much rather start the program as a background process: a process that is running, but that doesn't listen to the input devices and doesn't write to the monitor. Unix supports them and the shell (with job control) allows you to start any job as a background job.

But what about a middle ground? Like that file downloader? You have to start it, log into a remote server, pick your files and start the download. Only after all that does it make sense for the job to be in the background. But how do you accomplish that if you've already started the program as a foreground job? Or how about this: you're busily writing a document in your favorite editor and you just want to step out to check your mail for a moment. Do you have to shut down the editor for that? And then, after you're done with your mail, restart it, re-open your file and find where you'd left off? That's inconvenient. No, a much better idea in both cases is simply to suspend the program: just stop it from running any further and return to the shell. Once you're back in the shell, you can start another program (mail) and then resume the suspended program (editor) when you're done with that — and return to the program exactly where you left it. Conversely, you can also decide to let the suspended process (downloader) continue running, but now in the background.

When we talk about job control in the shell, we are talking about the abilities described above: to start programs in the background, to suspend running programs and to resume suspended programs, either in the foreground or in the background.

Enabling job control
In order to do all the things we talked about in the previous section, you need two things:

 * An operating system that supports job control.
 * A shell that supports job control and has job control enabled.

Unix systems support multitasking and job control. Unix was designed from the ground up to support multitasking. If you come across a person claiming to be a Unix vendor but whose software doesn't support job control, call him a fraud. Then throw his install CDs away. Then throw him away.

Of course you've already guessed what comes next, right? I'm going to tell you Bourne Shell supports job control. And that you can rely on the same mechanisms to work in all compatible shells. Guess what: you're not correct. The original Bourne Shell has no job control support; it was a single-tasking shell. There was an extended version of the Bourne Shell though, called jsh (guess what the 'j' stands for...) which had job control support. To have job control in the original Bourne Shell, you had to start this extended shell in interactive mode like this:

Within that shell you had the job control tools we will discuss in the following sections.

Pretty much every other shell written since incorporated job control straight into the basic shell and the POSIX 1003 standard has standardized the job control utilities. So you can pretty much rely on job control being available nowadays and usually also enabled by default in interactive mode (some older shells like Korn shell had support but required you to enable that support specifically). But just in case, remember that you might have to do some extra stuff on your system to use job control. There is one gotcha though: in shell scripts, you usually include an interpreter hint that calls for a Bourne Shell (i.e. #!/bin/sh). Since the original Bourne Shell doesn't have job control, several modern shells turn off job control by default in non-interactive mode as a compatibility feature.

Creating a job and moving it around
We've already talked at length about how to create a foreground job: type a command or executable name at the prompt, hit enter, there's your job. Been there, done that, bought the T-shirt.

We've also already mentioned how to start a background job: by adding an ampersand at the end of the command.

Creating a background job

But that suddenly looks different than when we issued commands previously; there's a "[1]" and some number there. The "[1]" is the job ID and the number is the process ID. We can use these numbers to refer to the process and the job that we just created, which is useful for using tools that work with jobs. When the task finishes, you will receive a notice similar to the following:

Job done

One of the tools that you use to manage jobs is the 'fg' command. This command takes a background job and places it in the foreground. For instance, consider a background job that actually takes some time to complete:

A heftier job

We haven't gotten into flow control yet, but this writes 200,000 integers to a file and takes some time. It also runs in the background. Say that we start this job:

Starting the job

The job is given job ID 1 and process ID 11246. Let's move the process to the foreground:

Moving the job to the front

The job is now running in the foreground, as you can tell from the fact that we are not returned a prompt. Now type the CTRL+Z keyboard combination:

Stopping the job

Did you notice the shell reports the job as stopped? Try using the 'cat' command to inspect the outp.txt file. Try it a couple of times; the contents won't change. The job is not a background job; it's not running at all! The job is suspended. Many programs recognize the CTRL+Z combination to suspend. And even those that don't usually have some way of suspending themselves.

Moving to the background and stopping in the background
Once a job is suspended, you can resume it either in the foreground or the background. To resume in the foreground you use the 'fg' command discussed earlier. You use 'bg' for the background:

To resume our long-lasting job that writes numbers, we do the following:

Resuming the job in the background

The output indicates that the job is running again. In the background this time, since we are also returned a prompt.

Can we also stop a process in the background? Sure, we can move it to the foreground and hit 'CTRL+Z'. But can we also do it directly? Well, there is no utility or command to do it. Mostly, you wouldn't want to do it — the whole point of putting it in the background was to let it run without bothering anybody or requiring attention. But if you really want to, you can do it like this:

or

We'll get back to what this does exactly later, when we talk about signals.

Job control tools and job status
We mentioned before that the POSIX 1003.1 standard has standardized a number of the job control tools that were included for job control in the jsh shell and its successors. We've already looked at a couple of these tools; in this section we will cover the complete list.

The standard list of job control tools consists of the following:

 * bg:Moves a job to the background.
 * fg:Moves a job to the foreground.
 * jobs:Lists the active jobs.
 * kill:Terminate a job or send a signal to a process.
 * CTRL+C:Terminate a job (same as 'kill' using the SIGTERM signal).
 * CRTL+Z:Suspend a foreground job.
 * wait:Wait for background jobs to terminate.

All of these commands can take a job specification as an argument. A job specification starts with a percent sign and can be any of the following:

 * %n:A job ID (n is number).
 * %s:The job whose command-line started with the string s.
 * %?s:The jobs whose command-lines contained the string s.
 * %%:The current job (i.e. the most recent one that you managed using job control).
 * %+:The current job (i.e. the most recent one that you managed using job control).
 * %-:The previous job.

We've already looked at 'bg', 'fg', and CTRL+Z and we'll cover 'kill' in a later section. That leaves us with 'jobs' and 'wait'. Let's start with the simplest one:

'Wait' is what you call a synchronization mechanism: it causes the invoking process to suspend until all background jobs terminate. Or, if you include one or more job specifications, until the jobs you list have terminated. You use 'wait' if you have fired off multiple jobs (simply to make use of a system's parallel processing capabilities) and you cannot proceed safely until they're all done.

The 'wait' command is used in quite advanced scripting. In other words, you might not use it all that often. Here's a command that you probably will use regularly though:

The jobs command reports information and status about active jobs (don't confuse active with running!). It is important to remember though, that this command reports on jobs and not processes. Since a job is local to a shell, the 'jobs' command cannot see across shells. The 'jobs' command is a primary source of information on jobs that you can apply job control to; for starters, you'll use this command to retrieve job IDs if you don't remember them. For example, consider the following:

Using 'jobs' to report on jobs

Speaking of state (which is reported by the 'jobs' command), this is a good time to talk about the different states we have. Jobs can be in any of several states, sometimes even in more than one state at the same time. The 'jobs' command reports on state directly after the job id and order. We recognize the following states:

 * Running:This is where the job is doing what it's supposed to do. You probably don't need to interrupt it unless you really want to give the program your personal attention (for example, to stop the program, or to find out how far through a file download has proceeded). You'll generally find that anything in the foreground that's not waiting for your attention is in this state, unless it's been put to sleep.
 * Sleeping:When programs need to retrieve input that's not yet available, there is no need for them to continue using CPU resources. As such, they will enter a sleep mode until another batch of input arrives. You will see more sleeping processes, since they are not as likely to be processing data at an exact moment of time.
 * Stopped:The stopped state indicates that the program was stopped by the operating system. This usually occurs when the user suspends a foreground job (e.g. pressing CTRL-Z) or if it receives SIGSTOP.  At that point, the job cannot actively consume CPU resources and aside from still being loaded in memory, won't impact the rest of the system.  It will resume at the point where it left off once it receives the SIGCONT signal or is otherwise resumed from the shell. The difference between sleeping and stopped is that "sleep" is a form of waiting until a planned event happens, whereas "stop" can be user-initiated and indefinite.
 * Zombie:A zombie process appears if the parent's program terminated before the child could provide its return value to the parent. These processes will get cleaned up by the init process but sometimes a reboot will be required to get rid of them.

Other job control related tools
In the last section we discussed the standard facilities that are available for job control in the Unix shell. However, there are also a number of non-standard tools that you might come across. And even though the focus of this book is Bourne Shell scripting (particularly as the lingua franca of Unix shell scripting) these tools are so common that we would be remiss if we did not at least mention them.

Shell commands you might come across
In addition to the tools previously discussed, there are two shell commands that are quite common: 'stop' and 'suspend'.

The 'stop' command is a command that occurs in the shells of many System V-compatible Unix systems. It is used to suspend background processes — in other words, it is the equivalent of 'CTRL+Z' for background processes. It usually takes a job ID, like most of these commands. On systems that do not have a 'stop' command, you should be able to stop background processes by using the 'kill' command to send a SIGSTOP signal to the background process.

The other command you might come across is the 'suspend' command. The 'suspend' command is a little tricky though, since it doesn't always mean the same thing on all systems and all shells. There are two variations known to the authors at this time, both of which are shown above. The first, obvious one takes a job ID argument and suspends the indicated job; really it's just the same as 'CTRL+Z'.

The second variant of 'suspend' doesn't take a job ID at all, which is because it doesn't suspend any random job. Rather, it suspends the execution of the shell in which the command was issued. In this variant the -f argument indicates the shell should be suspended even if it is a login shell. To resume the shell execution, send it a SIGCONT signal using the 'kill' command.

The process snapshot utility
The last tool we will discuss is the process snapshot utility, 'ps'. This utility is not a shell tool at all, but it occurs in some variant on pretty much every system and you will want to use it often. Possibly more often even than the 'jobs' tool.

The 'ps' utility is meant to report on running processes in the system. Processes, not jobs — meaning it can see across shell instances. Here's an example of the 'ps' utility:

Using the 'ps' utility

Typical process output includes the process ID, the ID of the terminal the process is connected to (or running on), the CPU time the process has taken and the command issued to start the process. Possibly you also get a process state. The process state is indicated by a letter code, but by-and-large the same states are reported as for job reports: Running, Sleeping, sTopped and Zombie. Different 'ps' implementations may use different or more codes though.

The main problem with writing about 'ps' is that it is not exactly standardized, so there are different command-line option sets available. You'll have to check the documentation on your system for specific details. Some options are quite common though, so we will list them here:

 * -a:List all processes except group leader processes.
 * -d:List all processes except session leaders.
 * -e:List all processes, without taking into account user id and other access limits.
 * -f:Produce a full listing as output (i.e. all reporting options).
 * -g list:Limit output to processes whose group leader process IDs are mentioned in list.
 * -l:Produce a long listing.
 * -p list:Limit output to processes whose process IDs are mentioned in list.
 * -s list:Limit output to processes whose session leader process IDs are mentioned in list.
 * -t list:Limit output to processes running on terminals mentioned in list.
 * -u list:Limit output to processes owned by user accounts mentioned in list.

The 'ps' tool is useful for monitoring jobs across shell instances and for discovering process IDs for signal transmission.

Guia do Linux/Iniciante+Intermediário/Personalização do sistema/Variáveis de Ambientes

title: Bourne Shell Scripting/Environment


text:
Arabic/If-then/(lau)

لو (lau)

لو (lau) means if. But it has a more specific use than the English word "if".  لو (lau) is used for events that didn't happen. For example if the following sentence were translated into Arabic with the word لو (lau) as a translation for the word "if": If I had been trained, I wouldn't have made mistakes. Then a person who read the translation, understands that the person saying the sentence was NOT trained. Using  لو (lau) makes sure this doesn't happen. Speaker 1: If I were stupid, then... Listener 1: Were you stupid? The "then" word for لو is لـ. It is added to the beginning of the word.

 * لو ..1..لـ ...2...ـ

if ...1.... then ...2.... example: If I didn't go to school, my mom would get angry (but I did go to school).

 * لم أهزمهم

lam ahzim-hum lam—ah-zim-hum (I) hadn't beaten them.

 * لو لم أهزمهم لكانو هزموني

lau lam ahzim-hum la-kaanoo hazamoo-nee lau—lam—ah-zim-hum—la-kaa-noo—ha-za-moo-nee If I didn't beat them up they would beat me up. (assuming the speaker did "beat them up")

title: Arabic/If-then/(lau)


text:
Arabic/Verb Type/1

 * Type Meaning

Subtypes
=Conjugation=
 * Regular Conjugation Table

alif

 * Initial
 * Medial
 * Final

waaw

 * Initial
 * Medial
 * Final

yaa

 * Initial
 * Medial
 * Final

title: Arabic/Verb Type/1


text:
Arabic/Verb Type/2

 * Type Meaning

Subtypes
=Conjugation=
 * Regular Conjugation Table

alif

 * Initial
 * Medial
 * Final

waaw

 * Initial
 * Medial
 * Final

yaa

 * Initial
 * Medial
 * Final

title: Arabic/Verb Type/2


text:
Arabic/Verb Type/3

 * Type Meaning

Subtypes
=Conjugation=
 * Regular Conjugation Table

alif

 * Initial
 * Medial
 * Final

waaw

 * Initial
 * Medial
 * Final

yaa

 * Initial
 * Medial
 * Final

title: Arabic/Verb Type/3


text:
Arabic/Verb Type/4

 * Type Meaning

Subtypes
=Conjugation=
 * Regular Conjugation Table

alif

 * Initial
 * Medial
 * Final

waaw

 * Initial
 * Medial
 * Final

yaa

 * Initial
 * Medial
 * Final

title: Arabic/Verb Type/4


text:
Arabic/Verb Type/5

 * Type Meaning

Subtypes
=Conjugation=
 * Regular Conjugation Table

alif

 * Initial
 * Medial
 * Final

waaw

 * Initial
 * Medial
 * Final

yaa

 * Initial
 * Medial
 * Final

title: Arabic/Verb Type/5


text:
Arabic/Verb Type/6

 * Type Meaning

Subtypes
=Conjugation=
 * Regular Conjugation Table

alif

 * Initial
 * Medial
 * Final

waaw

 * Initial
 * Medial
 * Final

yaa

 * Initial
 * Medial
 * Final

title: Arabic/Verb Type/6


text:
Arabic/Verb Type/7

 * Type Meaning

Subtypes
=Conjugation=
 * Regular Conjugation Table

alif

 * Initial
 * Medial
 * Final

waaw

 * Initial
 * Medial
 * Final

yaa

 * Initial
 * Medial
 * Final

title: Arabic/Verb Type/7


text:
Arabic/Verb Type/8

 * Type Meaning

Subtypes
=Conjugation=
 * Regular Conjugation Table

alif

 * Initial
 * Medial
 * Final

waaw

 * Initial
 * Medial
 * Final

yaa

 * Initial
 * Medial
 * Final

title: Arabic/Verb Type/8


text:
Arabic/Verb Type/9

 * Type Meaning

Subtypes
=Conjugation=
 * Regular Conjugation Table

alif

 * Initial
 * Medial
 * Final

waaw

 * Initial
 * Medial
 * Final

yaa

 * Initial
 * Medial
 * Final

title: Arabic/Verb Type/9


text:
Arabic/Verb Type/10

 * Type Meaning

Subtypes
=Conjugation=
 * Regular Conjugation Table

alif

 * Initial
 * Medial
 * Final

waaw

 * Initial
 * Medial
 * Final

yaa

 * Initial
 * Medial
 * Final

title: Arabic/Verb Type/10


text: Adventist Youth Honors Answer Book/Health and Science


text:
Cookbook:Baked Pork Chops

Here's a very simple and remarkably tasty recipe for baked pork chops.

Ingredients

 * 3–4 bone-in pork chops, ¼ inch (6 mm) thin
 * 1 medium apple, cored and sliced thin
 * 1 medium onion, sliced thin
 * 1 tablespoon (15 ml) honey
 * 1 tablespoon (15 ml) caraway seed (can be salvaged from the bag your rye bread comes in)
 * Garlic salt, black pepper, and Dijon mustard, to taste

Procedure

 * 1) Heat oven to 350 °F (180 °C)
 * 2) Layer sliced onion and apple in a baking dish that can be covered; drizzle honey and half the caraway over apple and onion slices
 * 3) Season meat with garlic salt and pepper; spread top of meat with Dijon
 * 4) Sprinkle remainder of caraway
 * 5) Cover and bake for one hour.

title: Cookbook:Baked Pork Chops


text:
Adventist Youth Honors Answer Book/Vocational

Although the Vocational Series Honors were once antiquated as a category they have again returned to regular use. Some of them use outdated forms and skills, their preservation however is excellent for the history and skill development of the youth. If you are considering submitting an updated version of one these Honors to the NAD, please consider creating an additional honor rather than a replacement Honor. Forms for submitting new honors are available through pathfindersonline and Xtremeyouthresources.org, and submitting them for piloting through these resources can give them more public attention.

Skill Level 1 Honors
 category=Adventist Youth Honors Answer Book/ category=Adventist Youth Honors Answer Book/Skill Level 1 order=ascending namespace=0

Skill Level 2 Honors
 category=Adventist Youth Honors Answer Book/ category=Adventist Youth Honors Answer Book/Skill Level 2 order=ascending namespace=0

Skill Level 3 Honors
 category=Adventist Youth Honors Answer Book/ category=Adventist Youth Honors Answer Book/Skill Level 3 order=ascending namespace=0


text:
Category:Shellfish

Types of shellfish.

title: Category:Shellfish


text:
Category:Seafood

For the actual module on Seafood, see Cookbook:Seafood.

nl:Categorie:Vis- of zeevruchtrecept

title: Category:Seafood


text:
User talk:WAS (WB)

Rape: A Do-it-Yourself Guide
Do you think this is funny? Anyway, Wikibooks is not a jokebook, this textbook is completely useless.

Please, for God's sake, keep tabs on people who edit this page. They're probably dangerous psychotics who you'll see on the news some day.

You'd better stop a bit. --Derbeth 07:06, 10 October 2005 (UTC)

title: User talk:WAS (WB)


text: User talk:64.229.217.6

title: User talk:64.229.217.6


text:
Category:Freshwater fish

Fish which live in fresh water.

title: Category:Freshwater fish


text: User talk:138.217.218.113

title: User talk:138.217.218.113


text:
User talk:207.144.26.30

Please stop. If you continue to vandalize pages, you will be blocked from editing Wikibooks.

title: User talk:207.144.26.30


text:
Category:Saltwater fish

Fish which live in bodies of saltwater.

title: Category:Saltwater fish


text: User talk:209.47.142.188

title: User talk:209.47.142.188


text: Template:User es-1

title: Template:User es-1


text: User talk:213.107.161.233

title: User talk:213.107.161.233


text:
Category:User ru

de:Kategorie:User ru eo:kategorio:uzanto ru fr:Catégorie:Utilisateur ru hy:Կատեգորիա:User ru it:Categoria:Utenti ru hu:Kategória:User ru ja:Category:User ru pt:Categoria:Usuário ru ru:Категория:User ru

title: Category:User ru


text:
Talk:Cantonese/Pronunciation

Untitled
I think I have a reasonable suggestion for the Finals section The line:

aau	ow as in "bow"

Is that 'bow' as in a knot ('Tie a bow in the ribbon') or 'bow' as in the front of a ship?

In the first case you could use 'rainbow' and in the second case you could probably use 'power' to prevent any confusion.

- I think I'm going to try to incorporate some IPA (International Phonetic Alphabet) symbols in here. I think it'll be helpful for people who have experience with IPA. Of course, I'm going to leave the current examples for people who don't use IPA. AlexNg 01:46, 15 July 2006 (UTC)

Some of this Yale is being mis-explained. Here are some changes I'm making. Let me say, thank GOODNESS it's Yale that's being used here. It's by far the clearest system around. The other romanisations are bizarre, unnatural, and/or difficult.
 * b - as in 'spa'... this takes away the aspiration from the b sound. This may be barely more correct (not even sure about that), but the difference is really not noticeable, and it's not worth the confusion.  Just use a regular b example.
 * d - as in 'stick'... same issue of unnecessary confusion. Use a regular d.
 * g - same thing.
 * j - z as in Mozart... this is partially correct. It's not a standard j, but it's not strictly that dz as in Mozart.
 * ch - cats... also a blend.
 * gw - same faux non-aspiration.
 * aau - good comment earlier.
 * aam - no l sound...
 * aan - pawn has too much of an o sound.

Uh... et cetera. You can check the history page for the rest. Please add your corrections if you think I got it wrong. Agkcrbs (talk) 23:51, 30 July 2008 (UTC)

title: Talk:Cantonese/Pronunciation


text:
Mac OS X Tiger/Networking your Mac

=Introduction= A Network is essentially a group of computers hooked up by cable or wireless signal. Networks are especially important these days, since they let you share high-speed Internet connections among more than one computer. This chapter will show you how to set up and maintain your very own network of all Macs or a mix of Macs and PCs.

=Types of Network Connections =

Setting Up
=Things You Can Do On A Network=

Share an Internet Connection
You can share your Internet connection by opening System Preferences, and selecting the Sharing pane. Go to the Internet tab, and use the drop-down menu to choose which connection to share. Then check the box(es) of the interfaces you want to share your connection through. If you are sharing through AirPort press the AirPort Options... button to configure the wireless network. Now press the Start button to start sharing your connection. The Start button will change to Stop, which you can press to stop sharing.

title: Mac OS X Tiger/Networking your Mac


text:
Mac OS X Tiger/Advanced Concepts

The Command Line
A more advanced way of accessing the command line is if you have an application like Apple's X11 or XDarwin installed. These allow you to use a range of Unix shells (including bash, csh, ksh, zsh, and tcsh), assuming you have such shells installed on your system.

There are two ways to bypass Apple's Aqua altogether and load Darwin with a Command Line Interface. You can enter a console on a per session basis by entering your username as ">console" (without quotes). (If you have an automated logon, or a selection of user names instead of an area to type the username you can use "System Preferances" and under "Accounts" you can select login options and change "Display login window as" to "Name and Password." If the Mac is booted up and showing you a list of users, you can switch it to the field-based login by pressing option-return. You may need to first move the selection by pressing any key to highlight one of the listed users.) [Note that 'Enable Firewall Logging' must be turned off in Sharing Preferences or this method will not work.]

The second method will drop you in the console each time you start up. To do this open a terminal and type: "sudo nano /etc/ttys" You should see something like this (the #s mark the start of a comment):

# # # console "/System/Library/CoreServices/loginwindow.app/Contents/MacOS/loginwindow"
 * 1)       @(#)ttys        5.2 (Berkeley) 6/10/93
 * 1) name  getty                           type    status          comments
 * 1) If the console is marked insecure, single-user requires
 * 2) the root password.
 * 3) console       "/usr/libexec/getty std.9600"   vt100   on secure

Notice the two lines that start with the word "console"? The first one is commented out, which means that the second is used. The second loads the LoginWindow. To bypass LoginWindow, comment out its line by preceding it with a # mark. The nano editor does not wrap the line, so be careful that during your changes parts of the LoginWindow line don't get pushed down to the next line. If they do, use backspace to move them back, being careful to maintain white space.

Now uncomment the first console line. You've now switched which of the two lines is commented out. Save your changes by pressing Ctrl+O, then Enter, then Ctrl+X. Reboot your system and you should now see your system's complete boot process and then be presented with a standard BSD-style login.

You can swap the two comments round again, if you decide you don't want to boot into the console. When in the console and you decide you want a minimal GUI, you can install X11, and type: "sudo /usr/X11R6/bin/startx" to start the X GUI server.

By typing the following: sudo /usr/sbin/nvram boot-args="-v"  you can stop the graphical loader, and get a chance to see what apple does when booting. You can get this same reaction by pressing Command-v shortly after the startup chime and holding it down until you see plain text appear in the upper-left or the screen.

X11
Outside of Mac OS X, most UNIX applications sporting a graphical interface rely on X11. X11 refers to version 11 of the X Window System protocol. Versions of Mac OS X since 10.3 (Panther) have shipped with Apple's implementation of X11, based heavily on the XFree86 Project. In addition to the actual implementation of the X11 protocol, Apple's X11 distribution includes a window manager (very loosely analogous to a theme or skin in modern graphical interfaces) that makes windows created by most X11 applications appear as standard Mac OS X Aqua windows. Quartz-wm, as it is called, also allows X11 windows to be minimized to the Mac OS X dock.

In addition, Apple's X11 is capable of running both in full screen, or rootless mode. In full screen mode, as its name implies, X11 takes control of the user's entire screen. It is possible to switch back and forth between the standard Mac OS X desktop and X11 on-the-fly, but this is a wholesale switch, and repeating it frequently quickly becomes cumbersome. To alleviate this, rootless mode is provided. Instead of taking control of a user's entire screen area, rootless mode allows X11 and Mac OS X applications to run side by side.

To start X11 in fullscreen mode, call startx from the terminal as: startx -- -fullscreen

To start X11 in rootless mode (default), call startx as startx -- -rootless

Apple's implementation of X11 is designed to allow UNIX and Linux applications to be more easily ported to Mac OS X. It is a fairly standard X11 distribution, and as such is still configured primarily through configuration files stored throughout the system. Setting up a customized X11 environment is not easily done by users who have never before used the X Window System, and most users may never realise the need for, nor use Mac OS X's X11 environment.

title: Mac OS X Tiger/Advanced Concepts