text:
Linux Guide/merge/Linux For Newbies/Command Line

Why Should I Learn The Command Line, Anyway?
Simply put, the command line is powerful; an army of tools exist that can take what would be a tedious job in a graphical program and turn it into a task that takes just a few seconds. Removing the last four lines in every row of a large file would be a lengthy process in a graphical application, but can become trivial and automated on the command line.

Flexibility aside, it's also important to note that some Linux systems lack a graphical interface at all and that some systems may become damaged in such a way as to make it impossible to bring up anything other than the command prompt. In these cases it's important to be able to navigate on the command line with enough proficiency to perform whatever tasks need to be done from backing up some files to disabling a dying piece of hardware.

The commands used at the command line may seem a little cryptic due to their tendency to be very short. This is because the roots of the Linux command line are from systems where a single letter entry could take a significant amount of time to travel from a terminal, to a central server and back to the terminal where it was printed onto a roll of paper. In those old systems, the shorter the input was, the better, as it meant less time waiting to issue your command and receive output. The best thing you can do to remember what commands stand for is to find out what word the command is an abbreviation for. This can go a long way to remembering the command later.

Shell Prompt
For every Linux distribution the command line prompt will look a little different. For example, on one system you might see your username, the '@' symbol, the machine name, your current directory and some kind of symbol to indicate the end of the prompt (here, a dollar sign).

user@linux ~/$

This is a very common prompt. You may also see your username, a space, the fully qualified domain name of the computer, the full path to your present working directory followed by a symbol to indicate the end of the prompt (a dollar sign).

user linux.box.com /home/user#

The prompt varies from system to system based on a number of things. For example, it may be the default configuration set by the creators of your particular Linux distribution. It could also have been configured by the person who administers the computer. Maybe you, yourself, configured how you wanted your prompt to look. The way you configure the look of your command prompt depends on which shell you use.

The shell is the piece that most people commonly refer to as, "the command line" when, in reality, it is simply a piece of software that provides an interface to the services of a kernel. The distinction between a 'shell' and the 'command line' is simply that that a shell refers to a specific piece of software (e.g. BASH, Tch, ksh, etc.) that provides a command line interface. Most modern Linux systems use BASH (Bourne Again SHell) as the default shell.

Summary of Common Commands

 * ls - This command 'lists' the contents of your present working directory.
 * pwd - Shows you what your present working directory is.
 * cd - Lets you change directories.
 * rm - Remove one or more files.
 * rmdir - Remove an empty directory.
 * mkdir - Make a directory.
 * ps - Provides a list of currently running processes.
 * cp - Copy a file.
 * <tt>mv</tt> - Move a file (this is also used to rename a file, "moving" it from one file name to another.)
 * <tt>grep</tt> - The global regular expression print program lets you search through a file or output of another program.
 * <tt>find</tt> - Find a file on the filesystem (100% accurate, but not fast).
 * <tt>locate</tt> - Find a file on the filesystem from a cached list of files (Fast, but not 100% accurate).
 * <tt>man</tt> - Displays the manual for most commands (including 'man').
 * <tt>clear</tt> - clear the screen
 * <tt>less</tt> - view the contents of a file
 * <tt>nano</tt> - a simple text editor
 * <tt>sudo</tt> - execute a command as another user (default as root)
 * <tt>su</tt> - switch user (default to root)
 * <tt>view</tt> - Start in read-only mode. You will be protected from writing the files. Can also be done with the "-R" argument.

Command Arguments
Most ( tar cvf tarFile *     )  (   gzip   )    (    gzip -d & tar xvf      )commands  (   cp    ) mv [filename} [location]     )will need some extra information in order to do something useful. For example, the copy command will need to know what file you want to copy. The extra information is given in the form of arguments. ( while read names __ do __ ### __ done < filename    )Arguments are written as extra words after the command name and separated by spaces. If you want to invoke the command <tt>ps</tt> with the argument <tt>-A</tt>, you would write:

user@linux$ ps -A

 * NOTE: The words argument, parameter and flag are synonyms, while a "switch" is actually a type of argument that indicates an on or off status. Arguments often need additional information (such as a filename) while a switch will never require additional information except maybe "on/off", "true/false", "yes/no".

Most Linux commands use the GNU fashion of arguments: each option is either a letter preceded by a hyphen, like <tt>-o</tt>, <tt>-W</tt> or <tt>-L</tt>, or a word or phrase preceded by two hyphens, like <tt>--symbolic</tt>, <tt>--no-target-directory</tt> etc. Some commands also take file names. Each file has to be supplied as a single argument, so if your filename contains spaces, you have to either enclose it in double or single quotes, or precede the spaces with backslashes. These three commands open the same file with :

user@linux$ less "important notice.txt" user@linux$ less 'important notice.txt' user@linux$ less important\ notice.txt

Some characters are recognized by the shell and used for special tasks. If your file name contains the characters: <tt><>&[]$\"';</tt> and you experience problems, you should put backslashes before these characters. Note that in Linux, filenames can contain any characters except /, which is used as the directory separator, and the null character, which can't be entered from the keyboard anyway.

Using ls - List
user@linux ~/$ ls Afilez Report.doc  aFilea  finances.xls  myPic.jpg  report1.doc  vacation pictures

You may notice from the example, default output of 'ls' that the files are not in strict alphabetical order. This is because the output is sorted on the numeric ASCII value of each letter. Because upper case letters have a lower ASCII value than lowercase letters, the returned result will always be files starting with upper case letters first. For example, if we add the file AZTRIP to the directory we will get 'AZTRIP' as the file listed first followed by 'Afilez' because the ASCII value of 'Z' is numerically lower than the ASCII value of 'f'.

If the ASCII values of letters has you confused, the important thing to remember here is that uppercase letters trump lowercase letters and will appear first in listings. The result is that files are first sorted by case and sorted alphabetically second.

The default output of ls isn't as useful as it could be. For example, given the output in the example, we don't know what are files and what are directories. We can likely guess that "Afilez", "aFilea" and "vacation pictures" are all directories as they don't have an extension after the file name. To confirm this, we can pass the 'l' parameter to 'ls' to get "long listing format" output.

user@linux ~/$ ls -l -rw-r--r-- 1 adrong mkgroup-l-d 163328 Jul 24 11:42 AZTRIP -rw-r--r-- 1 adrong mkgroup-l-d 11264 Jul 24 11:42 Afilez -rw-r--r-- 1 adrong mkgroup-l-d 22528 Jul 24 11:43 Report.doc -rw-r--r-- 1 adrong mkgroup-l-d 24576 Jul 24 11:42 aFilea -rw-r--r-- 1 adrong mkgroup-l-d 300032 Jul 24 11:43 finances.xls -rw-r--r-- 1 adrong mkgroup-l-d 47104 Jul 24 11:41 myPic.jpg -rw-r--r-- 1 adrong mkgroup-l-d 17920 Jul 24 11:43 report1.doc drwxr-xr-x 1 adrong mkgroup-l-d     0 Jul 24 11:24 vacation pictures

The first character in the output above indicates the file type; where a dash indicates a file and the letter 'd' indicates a directory. From this output we see that the only directory is "vacation pictures"

 * NOTE: Most systems have an alias on the ls command to include the '--color' flag so that the command highlights different file types with different colors. Directories are commonly shown in blue. If the output of your 'ls' command has everything as the same color, try "ls --color".

 * TIP: Another common parameter to the ls command is 'a' which shows all files including any hidden files and folders that start with a period. Arguments may also be combined together in a single block of letters. For example, "ls -l -a" can also be expressed as "ls -la".

The command ls -l outputs information in the following order. The first column of data lists the permissions that apply to that file or directory. The next column of information lists the number of 'hard links' to that file. If you're not sure what that means, then don't worry about it. For more information about hard links, read the manual page for ln by running man ln. The next column lists the name of the user that owns the file or directory, followed by the name of the group that owns the file or directory. The next column lists the size of the file or directory. In the case of directories, it does not list the size of everything within that directory. In the example above, it lists the size of both directories as 4096 bytes. That is because that's how much space having a directory takes up, it does not mean that there are 4096 bytes of stuff within that directory. The next column lists the date that the file or directory was last modified. Finally, the name of the file or directory is listed. To find out more about the command ls, run the command man ls and you will be presented with ls's manual page.

Using cd - Change Directory

 * Also see the entry for cd in the Guide to Unix/Commands wikibook.

The cd command lets you navigate from directory to directory on your system. The first thing you may need to know when using the cd command is that, unlike windows, Linux does not use the concept of drive letters. Instead, everything is somewhere within the root directory, '/', including other disk drives.

There's a couple ways to use cd to navigate to the directory you want. These are known as "full path" and "relative path".

Full path always begins with the root directory '/'. For example, if we're in our home directory '/home/user' and we want to navigate to the 'vacation pictures' directory, we would issue the following command.

user@linux ~/$ cd /home/user/vacation\ pictures user@linux vacation pictures/$

You may note that our prompt changed a little to indicate the directory we're currently in. This will be the case on most systems, but as previously discussed, this depends on how your shell is configured. You may also note the backslash between "vacation" and " pictures". This backslash is known as the "escape character" and tells the cd command that the space is part of the directory name. If we omitted the backslash, the cd command would error and tell us that it could not find the directory "vacation". If you don't like typing backslash or have a directory name with many spaces in it, you can use quotation marks around the path.

Relative path can start a number of ways, but always describes how to get to a specific directory from the directory you're currently in. To do this, we need to know how to move to directories that immediately surround the directory we're currently in. These directories are parent directories and sub-directories

A sub-directory is any directory that is contained within the directory we're currently. Given the output below of "ls -l", we see that chicago, florida and "new york" are all sub-directories to the "vacation pictures" directory.

user@linux vacation pictures/$ ls -l drwxr-xr-x 1 adrong mkgroup-l-d 0 Jul 24 12:44 chicago drwxr-xr-x 1 adrong mkgroup-l-d 0 Jul 24 12:44 florida drwxr-xr-x 1 adrong mkgroup-l-d 0 Jul 24 12:44 new york

A parent directory is the directory that contains the folder that we are in. This makes the "vacation pictures" folder the parent of the "chicago", "florida" and "new york" directories.

To cd to a sub-directory, you can start the path name with "./" which indicates the directory we're already in, or you can immediately start with the name of the sub-directory. For example, both of the following commands will change you to the "florida" directory.

user@linux vacation pictures/$ cd ./florida user@linux florida/$

user@linux vacation pictures/$ cd florida user@linux florida/$

To cd to a parent directory, you always specify "../". The following command will return us to the "vacation pictures" directory.

user@linux florida/$ cd ../ user@linux vacation pictures/$

If we are already in the "chicago" directory and want to cd to "new york", we must first tell the system we want to go up one level to the parent directory and then to the "new york" directory. We can do this by saying "cd ../" and then "cd new\ york" or we can do it as one step using the command below.

user@linux chicago/$ cd "../new york" user@linux new york/$

 * NOTE: Notice how we used quotation marks around the path to cd to the "new york" directory. We could have, instead used the backslash before the space and omitted the quotes to get the same result.

Similar to "./" and "../", there's also "~/" which indicates the home directory of the user we're logged in as. If we wanted to cd to the "vacation pictures" folder while in the "/usr/lib" directory, we could do this with any of the following commands.

user@linux lib/$ cd ~/vacation\ pictures user@linux lib/$ cd "/home/user/vacation pictures" user@linux lib/$ cd ../../home/user/vacation\ pictures

 * TIP: Using the cd command without specifying a directory will return you to your home directory.

echo -n "Please Enter your name" read name useradd $name

Using pwd - Print Working Directory

 * Also see the entry for pwd in the Guide to Unix/Commands wikibook.

To display the full path that you are in at any time, simply run the command <tt>pwd</tt> (print working directory), and it will print the path out for you. For example: user@linux test$ pwd /home/user/test user@linux test$ cd .. user@linux ~/$ pwd /home/user

Using mkdir - Make a Directory
The <tt>mkdir</tt> command allows you to create new directories.

user@linux ~/$ ls Afilez Report.doc  aFilea  finances.xls  myPic.jpg  report1.doc  vacation pictures user@linux ~/$ mkdir playground user@linux ~/$ mkdir ./playground/test1 user@linux ~/$ mkdir /home/user/playground/test2 user@linux ~/$ ls Afilez Report.doc  aFilea  finances.xls  myPic.jpg  playground  report1.doc  vacation pictures user@linux ~/$

 * NOTE: Like we've previously seen with the <tt>cd</tt> command, we can create new directories by specifying either relative and absolute paths. You'll find you can do this with all command line programs what work with files and folders.
 * TIP: You can pass the <tt>-p</tt> parameter to <tt>mkdir</tt> to make it create all directories to make that path valid. For example, in place of the first and second <tt>mkdir</tt> commands, we could instead run <tt>mkdir -p playground/test1</tt> to create both the <tt>playground</tt> and <tt>test1</tt> directories in a single step.

Using rmdir - Remove a Directory
The <tt>rmdir</tt> command allows you to delete empty directories.

user@linux ~/$ ls playground/ test1 test2 user@linux ~/$ rmdir playground/test1 user@linux ~/$ ls playground/ test2 user@linux ~/$

Like Windows, Linux has the concept of hidden files. This is important to note because there may be times that you try to delete a seemingly empty directory only to be presented with an error.

user@linux ~/$ cd playground/ user@linux playground/$ rmdir test2 rmdir: failed to remove `test2': Directory not empty user@linux playground/$ ls test2/ user@linux playground/$

To see hidden files and folders, pass the <tt>-a</tt> (all files and folders) parameter to the <tt>ls</tt> command.

user@linux playground/$ ls -a test2/ . ..  .hiddenfile user@linux playground/$

All hidden files in Linux start with a period. The '.' and '..' files we see listed are the system folders that allow us to specify relative paths.

 * TIP: If you're tired of seeing the '.' and '..' folders every time you <tt>ls -a</tt>, you can instead run <tt>ls -A</tt> for "almost all" files. This gives you all the files and hidden files excluding '.' and '..'

Using rm - Remove Files
The <tt>rm</tt> command will delete a specific or group of files. Be a little cautious when using this command as there's no 'recycle-bin' for the command line!

To delete the file <tt>.hiddenfile</tt> in the previous example we simply specify the file after the <tt>rm</tt> command.

user@linux playground/$ rm test2/.hiddenfile user@linux playground/$ ls -a test2/ . .. user@linux playground/$ rmdir test2 user@linux playground/$

 * TIP: In addition to having several parameters, the <tt>rm</tt> command also supports the use of asterisk (*) to represent any set of characters. This can be useful when you want to delete all of specific type of file. For example, <tt> rm *.jpg</tt> will remove all the files ending in '.jpg' residing in your current directory.
 * TIP: Until you feel comfortable with the <tt>rm</tt> command (especially when used in conjunction with an asterisk), you might want to specify the <tt>-i</tt> parameter to have <tt>rm</tt> confirm the deletion before it happens.

Using locate - find a file
The <tt>locate</tt> utility is very useful even when working in a graphical environment. On systems where it is installed, it periodically indexes the whole filesystem and stores the names of files in an internal database. This makes finding files by name very fast (a search for a particular name takes under a second). Here is an example: tweenk@tc1100:~$ locate stock_3dsound /usr/share/icons/gnome/16x16/stock/media/stock_3dsound.png /usr/share/icons/gnome/24x24/stock/media/stock_3dsound.png tweenk@tc1100:~$ This example searches the hard drives for all files which have "stock_3dsound" anywhere in their path. You can also use wildcards * and ? in the pattern.

Since the filenames are kept in a database, <tt>locate</tt> will not be able to find recently created files, or might find files which have been deleted. While the database is periodically updated by a script, you might want to force an update. To do this, use the command <tt>locate -u</tt>, run as root (in Ubuntu, <tt>sudo locate -u</tt>; in other distributions, first <tt>su</tt>, then <tt>locate -u</tt>).

Using su/sudo - run commands with Super User privileges
The super user, more commonly known as "root", has complete access to everything on the system. The root user can do silly things like treat input from the mouse as audio to things catastrophic to the system like delete every file on the filesystem. It's largely because of this last reason that the command line has a reputation as being something to be feared.

 * WARNING: If you've been instructed to run the <tt>rm</tt> command in conjunction with asterisk (*), question it seriously before running it. There are many pranksters trolling Linux support forums hoping to trick you into deleting every file on your filesystem. Other variations have you <tt>mv</tt> your files to <tt>/dev/null</tt> which has the same effect. Other variations also involve <tt>rm -r -f </tt> as root which deletes every file on your filesystem.

su
The function of the `su` (super user) command allows you to switch to a different user on the system. Typically it is used to switch to the 'root' user on the system. To become root on most systems, give the <tt>su</tt> command with no parameters. You will then be prompted for the root password.

user@linux ~/$ su Password: root@linux user/#

Note the changes to the prompt. These are the typical changes you can expect to see. The username changed from 'user' to 'root' to reflect the change in which user we're operating as. The directory changed because the home directory for 'user' (e.g. /home/user) is not the same as the home directory for root (typically /root). The last change is character at the end of the prompt. The pound sign (#) is the typical symbol used to indicate you are now running commands as root.

To switch to a different user, use the <tt>su</tt> command followed by the username you want to switch to.

user@linux ~/$ su fred Password: fred@linux.box.com /home/user/$

Here we've successfully switched to the user 'fred'. Fred is not the root user, so the end symbol remains a dollar sign. However, Fred has made custom changes to how his prompt looks. It provides the fully qualified domain of the machine followed by the full path the user is currently in.

 * NOTE: The password needed in this example is Fred's user password. The root password will not work.

Once you <tt>su</tt> to the root user, you can <tt>su</tt> to any other user without needing their password. To <tt>su</tt> to 'fred' without needing his password, we first <tt>su</tt> to root as an intermediary step.

user@linux ~/$ su Password: root@linux user/# su fred fred@linux.box.com /home/user$

sudo
The <tt>sudo</tt> command is similar to <tt>su</tt> in that it lets you run commands with super user privileges. However, the philosophy on how super user privileges are give are quite a bit different.

To become the user <tt>fred</tt> using the <tt>sudo</tt> command looks a bit redundant.

user@linux ~/$ sudo su fred Password: fred@linux.box.com /home/user$

 * NOTE: The password needed in this example is your own user password.
 * NOTE: You can still use the command <tt>su fred</tt> to become the <tt>fred</tt> user, but again, you'll need Fred's password to do this.

Think of the <tt>sudo</tt> command as meaning something like, "Become root and run the following command." This makes the above command the <tt>sudo</tt> equivalent to the <tt>su</tt> example when we became root as an intermediary step before running <tt>su</tt> to become the user <tt>fred</tt>.

There are time when you may need to run more than one command as the root user. This can make using the <tt>sudo</tt> tedious and redundant, having to retype 'sudo' each time as illustrated in the following example.

user@linux ~/$ sudo ls /home/fred Travel.doc building budget.doc  dev user@linux ~/$ sudo ls /home/lisa Work funny.jpg  g1tmp.odf user@linux ~/$ sudo ls /home/joe Backup Desktop  java.jar user@linux ~/$

We can cut down on the amount of redundant typing by using <tt>sudo</tt> on <tt>bash</tt> to become root, first.

user@linux ~/$ sudo bash Password: root@linux user/# sudo ls /home/fred Travel.doc building budget.doc  dev root@linux user/# sudo ls /home/lisa Work funny.jpg  g1tmp.odf root@linux user/# sudo ls /home/joe Backup Desktop  java.jar root@linux user/# exit user@linux ~/$

 * NOTE: <tt>sudo</tt> and <tt>bash</tt> weren't made with the expectation they'd be used this way. This is why it's important to <tt>exit</tt> back to our own user account when we're done.

 * TIP: To become root, you can also use the command <tt>sudo -s</tt>.

Getting Help on Commands - Man Pages
Many shell commands will accept various options. To get some information about a command and a list of the available options, use the man (short for 'manual') command, giving the name of the command you want to find more about as its argument. After entering the command man who, the following output is displayed:

WHO(1)                                   User Commands                                   WHO(1) NAME who - show who is logged on SYNOPSIS who [OPTION]... [ FILE | ARG1 ARG2 ] DESCRIPTION -a, --all same as -b -d --login -p -r -t -T -u -b, --boot time of last system boot -d, --dead print dead processes -H, --heading print line of column headings -i, --idle add idle time as HOURS:MINUTES,. or old (deprecated, use -u) -l, --login print system login processes --lookup attempt to canonicalize hostnames via DNS -m    only hostname and user associated with stdin Manual page who(1) line 1

Most manuals are several screens long. Use the arrows or Page Up / Page Down keys to navigate in the text. Space shows the next line of text. Pressing q quits the manual and returns to the shell.

We can see from the man page that we can use the -a option to display more information about the currently active users sessions:

fred@3[fred]$ who -a Nov 14 13:47               10 id=si    term=0 exit=0 system boot Nov 14 13:47 run-level 5 Nov 14 13:47                   last=S Nov 14 13:47              835 id=l5    term=0 exit=0 LOGIN     tty1         Nov 14 13:47               958 id=1 root    - tty2         Nov 14 19:15 00:19         959 fred    - tty3         Nov 14 19:28 00:06         960 LOGIN     tty4         Nov 14 13:47               961 id=4 LOGIN     tty5         Nov 14 13:47               962 id=5 LOGIN     tty6         Nov 14 13:47               963 id=6 fred    ? :0          Nov 14 13:47   ? 965           pts/3        Nov 14 16:29              1746 id=/3    term=0 exit=0 fred@3[fred]$

Besides reading help files for programs, <tt>man</tt> can also be used to get information on shells, functions, and libraries.

TODO: Add sections about these commands (except clear)

View a File

 * Also see the chapter on file viewing in the Guide to Unix/Commands wikibook.

There are many ways to view and edit files on Linux. This section will only cover viewing files (not editing). In order to simply print out the contents of a text file, the program <tt>cat</tt> is normally used. (The name <tt>cat</tt> is an abbreviation for 'concatenate'). For example: [user@localhost test]$ cat file1 this is the contents of the file named file1 This works well for short files, but if the file is longer than your terminal the beginning of the file will be past the top of your terminal and you won't be able to read it. Luckily, there is a program called <tt>less</tt> that will help us here. Running the program <tt>less</tt> with the command <tt>less file1</tt> will allow you to scroll up and down through the contents of the file by using the up and down arrow keys. In order to quit <tt>less</tt> hit the 'Q' key. If you want to use <tt>less</tt> to search for a word in the file, type the '/' key, enter the word you want to search for and hit the <ENTER> key. You can then hit the 'N' key to jump to each occurrence of the word you searched for. For more information about <tt>less</tt> or <tt>cat</tt>, run the commands <tt>man less</tt> and <tt>man cat</tt> respectively to read each program's manual page.

Directory and File Completion
Some files have very long names and typing them is not fun. Because of this, the standard Linux shell has an auto-completion feature. Try typing in the first few letters of the name of a file that is in your current directory and then pressing Tab. The name will be automatically completed. If there is more than one file beginning with those letters, the shell will complete the name only partially, and hitting Tab twice will give you a listing of all matching files. If the list is very long, the shell will ask for confirmation. Here is an example:

$ cd /usr/share $ cd gnome <-- Here, I hit Tab twice gnome/                      gnome-mount/ gnome-2.0/                  gnome-netstatus/ gnome-about/                gnome-nettool/ gnome-app-install/          gnome-panel/ gnome-applets/              gnome-photo-printer/ gnome-art/                  gnome-pilot/ gnome-background-properties/ gnome-power-manager/ gnome-btdownload/           gnome-screensaver/ gnome-common/               gnome-screenshot/ gnome-compiz-manager/       gnome-sound-recorder/ gnome-control-center/       gnome-spell-1.0.7/ gnome-dictionary/           gnome-splashscreen-manager/ gnome-doc-utils/            gnome-sudoku/ gnome-games/                gnome-system-log/ gnome-games-common/         gnome-system-tools/ gnome-keyring-manager/      gnome-terminal/ gnome-mag/                  gnome-utils/ gnome-media/                gnome-volume-manager/ gnome-menus/                gnome-vpn-properties/ $ cd gnome  <-- My partially-typed command is not erased

The shell knows about <tt>cd</tt> and will not list files when auto-completing the argument to this command.


text:
Template:Java Programming/LanguageFundamentals/Topic

 * Statements
 * Conditional blocks
 * Loop blocks
 * Boolean expressions
 * Variables
 * Primitive Types
 * Arithmetic expressions
 * Literals
 * Methods
 * String
 * Objects
 * Packages
 * Arrays
 * Mathematical functions
 * Large numbers
 * Random numbers
 * Unicode
 * Comments
 * Keywords
 * Coding conventions
 * Lambda expressions

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


text:
Template:Java Programming/ClassesAndObjects/Topic

 * Defining classes
 * Inheritance
 * Interfaces
 * Overloading methods and constructors
 * Object Lifecycle
 * Scope
 * Nested classes
 * Generics


text:
User talk:TOK~enwikibooks

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally. -- Herby talk thyme 20:24, 31 October 2007 (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 TOK. To make sure that both of you can use all Wikimedia projects in future, we have reserved the name TOK~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:49, 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:34, 19 April 2015 (UTC)

title: User talk:TOK~enwikibooks


text:
Template:Java Programming/Aggregate/Topic

 * Collection
 * ArrayList
 * Map
 * Comparing Objects


text:
User:Teaandcrumpets~enwikibooks

Commons: Teaandcrumpets

Wikipedia: Tea and crumpets

title: User:Teaandcrumpets~enwikibooks


text:
Template:Java Programming/Exceptions/Topic

 * Throwing and catching exceptions
 * Checked exceptions
 * Unchecked exceptions
 * Preventing
 * Stack trace
 * Nesting exceptions (chained exceptions)


text:
Operating System Design/Case Studies/Windows 9x

Windows 9x references to the Windows family, Windows 95, 98 and Me operating systems. They were set apart from the earlier Windows versions: 1.0, 20, and 3.0 by their device drivers, virtual memory management and MSDOS.SYS and MS-DOS kernel. The reign of Windows 9x ended in 2001 when the Windows NT based Windows XP was released for both home and office use.

Architecture
The Windows 9x architecture was a step up in many ways from its predecessors. The GUI was redesigned, the kernel supported virtual memory and had a VFAT{virtual file allocation table} filesystem unlike its FAT16 and FAT12 filesystems before. Windows 95b was the 3rd version of 95 released and included support for FAT32. All versions of 9x supported FAT16 drive compression through Drivespace, a program originally from MS-DOS 6.22

The Kernel
The kernel was just a different version of the MS-DOS kernel, with added virtual memory and memory protection that was lacking in Windows 1.0+. It was of monolithic architecture, different from its successors NT 3.1+.

The Registry
The registry acted as a temporary and convenient holding place for program and system data. The directories are conventionally named as follows: HKEY_CLASSES_ROOT, HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CURRENT_CONFIG, and HKEY_PERFORMANCE_DATA. Each one of these stored specific types of data like, hardware configuration data, application data, performance data, and user data. The system can access this anytime and the current user is allowed to access and edit it also.

File Names
File names in Windows 9x were allowed to have up to 255 characters, a special feature in the VFAT filesystem. Previous versions of Windows were limited to MS-DOS style 8.3 letter filenames.

Graphical User Interface
The GUI was one significantly changed in the Windows 9x series. With the start button, the toolbar and taskbar both by default on the bottom of the screen, allowing running program to be selected. There was also a new widget set (that is, a different standard look and feel to the applications) and many new fonts are available.


text:
Operating System Design/Processes/Semaphores

Semaphores
A semaphore, in its most basic form, is a protected integer variable that can facilitate and restrict access to shared resources in a multi-processing environment. The two most common kinds of semaphores are counting semaphores and binary semaphores. Counting semaphores represent multiple resources, while binary semaphores, as the name implies, represents two possible states (generally 0 or 1; locked or unlocked). Semaphores were invented by the late Edsger Dijkstra.

Semaphores can be looked at as a representation of a limited number of resources, like seating capacity at a restaurant. If a restaurant has a capacity of 50 people and nobody is there, the semaphore would be initialized to 50. As each person arrives at the restaurant, they cause the seating capacity to decrease, so the semaphore in turn is decremented. When the maximum capacity is reached, the semaphore will be at zero, and nobody else will be able to enter the restaurant. Instead the hopeful restaurant goers must wait until someone is done with the resource, or in this analogy, done eating. When a patron leaves, the semaphore is incremented and the resource becomes available again.

A semaphore can only be accessed using the following operations: wait and signal. wait is called when a process wants access to a resource. This would be equivalent to the arriving customer trying to get an open table. If there is an open table, or the semaphore is greater than zero, then he can take that resource and sit at the table. If there is no open table and the semaphore is zero, that process must wait until it becomes available. signal is called when a process is done using a resource, or when the patron is finished with his meal. The following is an implementation of this counting semaphore (where the value can be greater than 1):

Historically, wait was called P (for Dutch “Proberen” meaning to try) and signal was called V (for Dutch “Verhogen” meaning to increment). The standard Java library instead uses the name "acquire" for P and "release" for V.

No other process can access the semaphore when P or V are executing. This is implemented with atomic hardware and code. An atomic operation is indivisible, that is, it can be considered to execute as a unit.

If there is only one count of a resource, a binary semaphore is used which can only have the values of 0 or 1. They are often used as mutex locks. Here is an implementation of mutual-exclusion using binary semaphores:

In this implementation, a process wanting to enter its critical section it has to acquire the binary semaphore which will then give it mutual exclusion until it signals that it is done.

For example, we have semaphore s, and two processes, P1 and P2 that want to enter their critical sections at the same time. P1 first calls wait(s). The value of s is decremented to 0 and P1 enters its critical section. While P1 is in its critical section, P2 calls wait(s), but because the value of s is zero, it must wait until P1 finishes its critical section and executes signal(s). When P1 calls signal, the value of s is incremented to 1, and P2 can then proceed to execute in its critical section (after decrementing the semaphore again). Mutual exclusion is achieved because only one process can be in its critical section at any time.

Disadvantage
As shown in the examples above, processes waiting on a semaphore must constantly check to see if the semaphore is not zero. This continual looping is clearly a problem in a real multiprogramming system (where often a single CPU is shared among multiple processes). This is called busy waiting and it wastes CPU cycles. When a semaphore does this, it is called a spinlock.

To avoid busy waiting, a semaphore may use an associated queue of processes that are waiting on the semaphore, allowing the semaphore to block the process and then wake it when the semaphore is incremented. The operating system may provide the block system call, which suspends the process that calls it, and the wakeup(P ) system call which resumes the execution of blocked process P. If a process calls wait on a semaphore with a value of zero, the process is added to the semaphore’s queue and then blocked. The state of the process is switched to the waiting state, and control is transferred to the CPU scheduler, which selects another process to execute. When another process increments the semaphore by calling signal and there are tasks on the queue, one is taken off of it and resumed.

In a slightly modified implementation, it would be possible for a semaphore's value to be less than zero. When a process executes wait, the semaphore count is automatically decremented. The magnitude of the negative value would determine how many processes were waiting on the semaphore:


text:
Operating System Design/Concurrency/Deadlock

In computer science, deadlock refers to a specific condition when two or more processes are each waiting for another to release a resource, or more than two processes are waiting for resources in a circular chain (see Necessary conditions). Deadlock is a common problem in multiprocessing where many processes share a specific type of mutually exclusive resource known as a software, or soft, lock. Computers intended for the time-sharing and/or real-time markets are often equipped with a hardware lock (or hard lock) which guarantees exclusive access to processes, forcing serialization. Deadlocks are particularly troubling because there is no general solution to avoid (soft) deadlocks.

This situation may be understood by an analogy with two people who are drawing diagrams, with only one pencil and one ruler between them. If one person takes the pencil and the other takes the ruler, a deadlock occurs when the person with the pencil needs the ruler and the person with the ruler needs the pencil, before he can give up the ruler. Both requests can't be satisfied, so a deadlock occurs.

The telecommunications description of deadlock is a little stronger: deadlock occurs when none of the processes meet the condition to move to another state (as described in the process's finite state machine) and all the communication channels are empty. The second condition is often left out on other systems but is important in the telecommunication context and its systems.

Necessary conditions
There are four necessary conditions for a deadlock to occur, known as the Coffman conditions from their first description in a 1971 article by E. G. Coffman.

 * 1) Mutual exclusion condition: a resource cannot be used by more than one process at a time
 * 2) Hold and wait condition: processes already holding resources may request new resources
 * 3) No preemption condition: only a process holding a resource may release it
 * 4) Circular wait condition: two or more processes form a circular chain where each process waits for a resource that the next process in the chain holds

Deadlock can only occur in systems where all 4 conditions hold true.

Circular wait prevention
Circular wait prevention consists of allowing processes to wait for resources, but ensure that the waiting cannot be circular. One approach might be to assign a precedence to each resource and force processes to request resources in order of increasing precedence. That is to say that if a process holds some resources, and the highest precedence of these resources is m, then this process cannot request any resource with precedence smaller than m. This forces resource allocation to follow a particular and non-circular ordering, so circular wait cannot occur. Another approach is to allow holding only one resource per process; if a process requests another resource, it must first free the one it's currently holding (or hold-and-wait).

Examples
An example of a deadlock which may occur in database products is the following. Client applications using the database may require exclusive access to a table, and in order to gain exclusive access they ask for a lock. If one client application holds a lock on a table and attempts to obtain the lock on a second table that is already held by a second client application, this may lead to deadlock if the second application then attempts to obtain the lock that is held by the first application. (But this particular type of deadlock is easily prevented, e.g., by using an all-or-none resource allocation algorithm.)

Another example might be a text formatting program that accepts text sent to it to be processed and then returns the results, but does so only after receiving "enough" text to work on (e.g. 1KB). A text editor program is written that sends the formatter with some text and then waits for the results. In this case a deadlock may occur on the last block of text. Since the formatter may not have sufficient text for processing, it will suspend itself while waiting for the additional text, which will never arrive since the text editor has sent it all of the text it has. Meanwhile, the text editor is itself suspended waiting for the last output from the formatter. This type of deadlock is sometimes referred to as a deadly embrace (properly used only when only two applications are involved) or starvation. However, this situation, too, is easily prevented by having the text editor send a forcing message (eg. EOF) with its last (partial) block of text, which will force the formatter to return the last (partial) block after formatting, and not wait for additional text.

Nevertheless, since there is no general solution for deadlock prevention, each type of deadlock must be anticipated and specially prevented. But general algorithms can be implemented within the operating system so that if one or more applications becomes blocked, it will usually be terminated after (and, in the meantime, is allowed no other resources and may need to surrender those it already has, rolled back to a state prior to being obtained by the application).

Avoidance
Deadlock can be avoided if certain information about processes is available in advance of resource allocation. For every resource request, the system sees if granting the request will mean that the system will enter an unsafe state, meaning a state that could result in deadlock. The system then only grants requests that will lead to safe states. In order for the system to be able to figure out whether the next state will be safe or unsafe, it must know in advance at any time the number and type of all resources in existence, available, and requested. One known algorithm that is used for deadlock avoidance is the Banker's algorithm, which requires resource usage limit to be known in advance. However, for many systems it is impossible to know in advance what every process will request. This means that deadlock avoidance is often impossible.

Two other algorithms are Wait/Die and Wound/Wait, each of which uses a symmetry-breaking technique. In both these algorithms there exists an older process (O) and a younger process (Y). Process age can be determined by a time stamp at process creation time. Smaller time stamps are older processes, while larger timestamps represent younger processes.

It is important to note that a process may be in unsafe state but would not result in a deadlock. The notion of safe/unsafe state only refers to the ability of the system to enter a deadlock state or not. For example, if a process requests A which would result in an unsafe state, but releases B which would prevent circular wait, then the state is unsafe but the system is not in deadlock.

Prevention
Deadlocks can be prevented by ensuring that at least one of the following four conditions occur:
 * Removing the mutual exclusion condition means that no process may have exclusive access to a resource. This proves impossible for resources that cannot be spooled, and even with spooled resources deadlock could still occur. Algorithms that avoid mutual exclusion are called non-blocking synchronization algorithms.
 * The "hold and wait" conditions may be removed by requiring processes to request all the resources they will need before starting up (or before embarking upon a particular set of operations); this advance knowledge is frequently difficult to satisfy and, in any case, is an inefficient use of resources. Another way is to require processes to release all their resources before requesting all the resources they will need. This too is often impractical. (Such algorithms, such as serializing tokens, are known as the all-or-none algorithms.)
 * A "no preemption" (lockout) condition may also be difficult or impossible to avoid as a process has to be able to have a resource for a certain amount of time, or the processing outcome may be inconsistent or thrashing may occur. However, inability to enforce preemption may interfere with a priority algorithm. (Note: Preemption of a "locked out" resource generally implies a rollback, and is to be avoided, since it is very costly in overhead.) Algorithms that allow preemption include lock-free and wait-free algorithms and optimistic concurrency control.
 * The circular wait condition: Algorithms that avoid circular waits include "disable interrupts during critical sections", and "use a hierarchy to determine a partial ordering of resources" (where no obvious hierarchy exists, even the memory address of resources has been used to determine ordering) and Dijkstra's solution.

Detection
Often neither deadlock avoidance nor deadlock prevention may be used. Instead deadlock detection and process restart are used by employing an algorithm that tracks resource allocation and process states, and rolls back and restarts one or more of the processes in order to remove the deadlock. Detecting a deadlock that has already occurred is easily possible since the resources that each process has locked and/or currently requested are known to the resource scheduler or OS.

Detecting the possibility of a deadlock before it occurs is much more difficult and is, in fact, generally undecidable, because the halting problem can be rephrased as a deadlock scenario. However, in specific environments, using specific means of locking resources, deadlock detection may be decidable. In the general case, it is not possible to distinguish between algorithms that are merely waiting for a very unlikely set of circumstances to occur and algorithms that will never finish because of deadlock.

Distributed deadlock
Distributed deadlocks can occur in distributed systems when distributed transactions or concurrency control is being used. Distributed deadlocks can be detected either by constructing a global wait-for graph, from local wait-for graphs at a deadlock detector or by a distributed algorithm like edge chasing.

Phantom deadlocks are deadlocks that are detected in a distributed system.


text:
Operating System Design/Virtual

Virtual memory is a memory management technique that offers two main benefits: Virtual memory is very useful and is implemented in most operating systems by using the memory management unit (MMU) in the CPU.
 * Each process "thinks" it has all the system's memory to itself
 * It becomes possible to access more memory than the actual physical amount

The second is accomplished by the MMU setting up a small, contiguous portion of the hard drive and treating it like physical RAM. That is, the operating system will place memory segments or pages into the file as if it were loading it into actual RAM. Thus, it has a place to hold "unused" pages of memory until they are needed and have a place to "Swap Out" memory segments that are no longer needed in memory. This technology is commonly used in paging, our next topic.

title: Operating System Design/Virtual


text:
MCSE Server 2003 Certification Core Exams

Exam 70-290: Managing and Maintaining a Windows Server 2003 Environment
Basic Test Objectives from Microsoft (10/31/07):

I. Managing and Maintaining Physical and Logical Devices
1. Manage basic disks and dynamic disks.

2. Monitor server hardware. Tools might include Device Manager, the Hardware Troubleshooting Wizard, and appropriate Control Panel items. 3. Optimize server disk performance.

4. Troubleshoot server hardware devices.
 * Implement a RAID solution.
 * Defragment volumes and partitions.

5. Install and configure server hardware devices.
 * Diagnose and resolve issues related to hardware settings.
 * Diagnose and resolve issues related to server hardware and hardware driver upgrades.

 * Configure driver signing options.
 * Configure resource settings for a device.
 * Configure device properties and settings.

II. Managing Users, Computers, and Groups
1. Manage local, roaming, and mandatory user profiles. 2. Create and manage computer accounts in an Active Directory environment.

3. Create and manage groups.

4. Create and manage user accounts.
 * Identify and modify the scope of a group.
 * Find domain groups in which a user is a member.
 * Manage group membership.
 * Create and modify groups by using the Active Directory Users and Computers Microsoft Management Console (MMC) snap-in.
 * Create and modify groups by using automation.

5. Troubleshoot computer accounts.
 * Create and modify user accounts by using the Active Directory Users and Computers MMC snap-in.
 * Create and modify user accounts by using automation.
 * Import user accounts.

6. Troubleshoot user accounts.
 * Diagnose and resolve issues related to computer accounts by using the Active Directory Users and Computers MMC snap-in.
 * Reset computer accounts.

7. Troubleshoot user authentication issues.
 * Diagnose and resolve account lockouts.
 * Diagnose and resolve issues related to user account properties.

III. Managing and Maintaining Access to Resources
1. Configure access to shared folders.

2. Troubleshoot Terminal Services.
 * Manage shared folder permissions.

3. Configure file system permissions.
 * Diagnose and resolve issues related to Terminal Services security.
 * Diagnose and resolve issues related to client access to Terminal Services.

4. Troubleshoot access to files and shared folders.
 * Verify effective permissions when granting permissions.
 * Change ownership of files and folders.

IV. Managing and Maintaining a Server Environment
1. Monitor and analyze events. Tools might include Event Viewer and System Monitor.

2. Manage software update infrastructure.

3. Manage software site licensing.

4. Manage servers remotely.

 * Manage a server by using Remote Assistance.
 * Manage a server by using Terminal Services remote administration mode.
 * Manage a server by using available support tools.

5. Troubleshoot print queues.

6. Monitor system performance. 7. Monitor file and print servers. Tools might include Task Manager, Event Viewer, and System Monitor.

8. Monitor and optimize a server environment for application performance.
 * Monitor disk quotas.
 * Monitor print queues.
 * Monitor server hardware for bottlenecks.

9. Manage a Web server.
 * Monitor memory performance objects.
 * Monitor network performance objects.
 * Monitor process performance objects.
 * Monitor disk performance objects.

 * Manage Internet Information Services (IIS).
 * Manage security for IIS.

V. Managing and Implementing Disaster Recovery
1. Perform system recovery for a server.

 * Implement Automated System Recovery (ASR).
 * Restore data from shadow copy volumes.
 * Back up files and System State data to media.
 * Configure security for backup operations.

2. Manage backup procedures.

3. Recover from server hardware failure. 4. Restore backup data
 * Verify the successful completion of backup jobs.
 * Manage backup storage media.

Exam 70-291

Exam 70-293

Exam 70-294


text: User talk:Ufodigest

title: User talk:Ufodigest


text:
Principles of Economics/Money

Definitions of Money
Economists use multiple definitions of money. By far the most important are:

 * Monetary base (MB)
 * "high-powered money"
 * stricter definition of money
 * consists of all currency (C) and reserves (R)
 * note that this is the actual extant money
 * Money type 1 (M1)
 * "money in the economy"
 * consists of all currency (C) and deposits (D)
 * standard definition of money
 * note that this is the amount of money that influences the well-being of the economy

These definitions of money are very confusing.

When customers deposit money in banks, the banks keep a certain small portion as reserves (R) and hold onto it for when customers withdraw. The remaining deposited money is then lent out to others, who, upon having that money, deposit into banks, who lend a fraction of that, and so on. Eventually, this cycle involves infinitesimally small amounts of money, so the cycle actually does come to an end, based on the basic geometric series rule:

 * $$ (r)^1 + (r)^2 + (r)^3 + ... = \frac{ 1 }{ 1 - r } $$

where
 * r is the portion of money that banks lend out

The result is that the economy is working with more money than really exists, because firms and individuals can still work with abstract money such as loaned money. This is the principal way in which banks "make money".

Equations
Monetary Base = Non Borrowed Monetary Base + Discount Loans

Monetary Base (MB) * Money base money multiplier (m) = M1

Monetary Base = "High-powered money" = Currency (C) + Reserves (R) = Currency (C) + (Deposits (D) * Required Reserve Ratio (r))

(Contrast with M1, which is Currency + Deposits)

title: Principles of Economics/Money


text:
Principles of Economics/Supply and Demand

The Model
We can apply supply and demand to a graph in the form of curves. Note that in some cases, these curves may be shown as lines instead; this is okay, but not quite as accurate. In such a model, the x axis is the quantity produced and the y axis is the price.

The demand model is concave up because changes in price are more significant when the initial price is less, ie. when the percentage change in price is greater, and hence more able to stimulate a response from buyers. This is often shown with a constant positive slope when linear.

The supply model is concave up because additional units of production rapidly come to cost more. Initially, it drops, because of the fixed-cost-division effect (hence the reason for mass production in modern times). This is also the reason why luxury goods cost so much even though they are clearly not overproduced. The low-quantity-produced section of the supply curve is frequently omitted for simplicity. This curve is often shown with a constant negative slope when linear.

The equilibrium is found at where the supply and demand curves intersect. At this point, allocative efficiency has been reached because everyone who is willing to buy the good at the going price is able to do so, and none who are not willing are able to do so. The equilibrium is the one stable point.

Supply and demand

If you have been following this text chapter by chapter you will have seen where the green supply and blue demand curves came from. Their intersection is the position where the market will produce and trade goods: at the price P* and quantity Q*. Remember that the firm has two minimum production points: one for short run and one for long run. The green point to the right is the long run minimum and hence the most important. Should the demand curve fall so that the intersection lies below that point, the firm will experience losses and shut down if the demand curve does not return to the blue curve shown here.

Total revenue

A firm's total revenue - the accounting profit's income side - is the price of the goods it produces times the quantity sold. In perfect competition all goods produced are assumed to be traded. This is the green shaded area.

Firm's output surplus and loss

So far you have already been introduced to the firm's labor surplus and loss. The firm's output surplus and loss follows a similar line of reasoning. The green supply curve indicates the firm's marginal cost of production, while the horizontal gray line is the price level, so the area between them where the supply curve is lower is the firm's surplus because at that range it can sell units of its good for more than what it costs to produce them. This area is filled green. The area between them where the supply curve is higher is the firm's loss because at that range it can sell units of its good for more than what it costs to produce them. This area is filled red.

If this analysis is done using the long run supply (as it is here), the green and red areas should equal each other, indicating (as is often the case) a firm that has zero economic profit. If this analysis is done using the short run supply, the red area will be exactly fixed costs' area greater than the green area.

Most textbooks refer to a general producer surplus that is the green area minus the red area. In that case it is simply not considering expenses. This is often the case in simplified micro-econ textbooks in which the supply curve is a straight line (which is not the case in real life).

Consumer surplus

The consumer surplus, by comparison, is the area between the demand curve and the price level, as explained in an earlier chapter on demand. There is no consumer loss, because consumers would not buy at that point. Beyond the equilibrium point, there is no consumer surplus, producer surplus, or producer loss because those points are not reached in practice; however, in theory they could be reached, in which case one merely has to extrapolate.

Surplus and Shortage
If at any time a product's price is not what it should be at equilibrium, there will be a pressure to restore it.

If the price is too high, suppliers will be willing to produce more than what would be allocatively efficient, while demanders will buy less than they would at the (cheaper) equilibrium price, causing a surplus. The increased stocks in the warehouses cause suppliers to drive price down.

If the price is too low, suppliers will be willing to produce fewer than is optimal because their marginal costs are higher than their marginal profits beyond that point. Meanwhile, demanders will want to buy more than would be efficient because the price is too low to adequately reflect the value (utility) of the good. Many demanders will be unable to obtain the good, causing a shortage. Producers see this and produce more at higher prices, expecting to be able to rise the price due to the excess demand and so still manage to break even.


text:
Talk:Visual Basic .NET/Branch statements

Does the binary operators section belong in Logical Operators? It doesn't seem to fit with the rest of the page. Xraytux 23:39, 31 October 2007 (UTC) - where is goto?

goto is bad programming practice.. consider it deprecated


text:
Wikijunior talk:World War II/Battle of Britain

Comments
Please feel free to change or add new stuff. :) Wallie 00:33, 1 November 2007 (UTC)


text:
Wikijunior talk:World War II/D-Day

Comments
Please feel free to change or add new stuff. :) Wallie 00:34, 1 November 2007 (UTC)

title: Wikijunior talk:World War II/D-Day


text:
Wikijunior talk:World War II/Blitzkrieg

Comments
Please feel free to change or add new stuff. :) Wallie 00:34, 1 November 2007 (UTC)

title: Wikijunior talk:World War II/Blitzkrieg


text: Template:Java Programming/JavadocAndAnnotationsTopic/Nav


text:
Template:Java Programming/JavadocAndAnnotations/Topic

 * Javadoc
 * Introduction to Annotation
 * Creating custom annotations
 * Meta-annotations
 * Helping the compiler


text:
Cookbook:Cuisine of The Dominican Republic

Mondongo is a very hearty tripe stew in a spicy red base, served with lime wedges and chopped onions. Usually available Saturday mornings in Dominican restaurants, it is especially recommended for a hangover. Menudo is related to the Mexican tripe stew in recipe, name, Saturday availability, presentation (beside limes and onions, Menudo comes with the addition of corn tortillas), and reputed therapeutic value. Verify this.

Locrio is another popular dish.

 * See also :Category:Dominican recipes


text:
Talk:XQuery/XQuery from SQL

Use of "Rank " in My sql?

Take this example as the basis for a comparison with SPARQL -

- one script to turn the tables into rdf - is this a generic function (with map of column to predicates and id identification -)

- Sparql equivalents where possible to the SQL queries

---

What does the following passage refer to: Note that in this release of eXist, the order of the operands in the equality is significant - to be fixed in a later release. XQuery: //Emp[//Dept[Dname='Accounting' = DeptNo]/DeptNo]/Ename

The XQuery (should be XPath) is wrong.

---

All links on this page are dead
As the title says - all links are dead, making this page less than useful...

title: Talk:XQuery/XQuery from SQL


text:
Java Programming/Byte Code

Java Byte Code is the language to which Java source is compiled and the Java Virtual Machine understands. Unlike compiled languages that have to be specifically compiled for each different type of computers, a Java program only needs to be converted to byte code once, after which it can run on any platform for which a Java Virtual Machine exists.

Bytecode is the compiled format for Java programs. Once a Java program has been converted to bytecode, it can be transferred across a network and executed by Java Virtual Machine (JVM). Bytecode files generally have a .class extension. It is not normally necessary for a Java programmer to know byte code, but it can be useful.

Other Languages
There are a number of exciting new languages being created that also compile to Java byte code, such as Groovy.

 * GNAT : The GNU Ada-Compiler, is capable of compiling Ada into Java-style bytecode.
 * ftp://cs.nyu.edu/pub/gnat

 * JPython : Compiles Python to Java-style bytecode.
 * http://www.jpython.org/

 * Kawa : Compiles Scheme to Java-style bytecode.
 * http://www.gnu.org/software/kawa/

Example
Consider the following Java code.

A Java compiler might translate the Java code above into byte code as follows, assuming the above was put in a method:

Example 2
As an example we can write a simple Foo.java source:

Compile it and then move Foo.java to another directory or delete it if you wish. What can we do with javap and Foo.class ?

$javap Foo

produces this result:

Compiled from "Foo.java" public class Foo extends java.lang.Object { public Foo; public static void main(java.lang.String[]); public static void a; public static void b; }

As you can see the javac compiler doesn't strip any (public) variable name from the .class file. As a result the names of the functions, their parameters and types of return are exposed. (This is necessary in order for other classes to access them.)

Let's do a bit more, try:

$javap -c Foo

Compiled from "Foo.java" public class Foo extends java.lang.Object{ public Foo; Code: 0:  aload_0 1:  invokespecial   #1; //Method java/lang/Object." ":V 4:  return

public static void main(java.lang.String[]); Code: 0:  getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream; 3:  ldc             #3; //String This is a simple example of decompilation using javap 5:  invokevirtual   #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 8:  invokestatic    #5; //Method a:V 11: invokestatic    #6; //Method b:V 14: return

public static void a; Code: 0:  getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream; 3:  ldc             #7; //String Now we are calling a function... 5:  invokevirtual   #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 8:  return

public static void b; Code: 0:  getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream; 3:  ldc             #8; //String ...and now we are calling b   5:   invokevirtual   #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 8:  return

}

The Java bytecodes
See Oracle's Java Virtual Machine Specification for more detailed descriptions

The manipulation of the operand stack is notated as [before]→[after], where [before] is the stack before the instruction is executed and [after] is the stack after the instruction is executed. A stack with the element 'b' on the top and element 'a' just after the top element is denoted 'a,b'.

title: Java Programming/Byte Code


text:
Linux Guide/Software equivalents

This table lists commonly used proprietary software and their open source equivalents. The open source programs are usually also available for Windows and Mac OS.

Useful Links

 * Linux Alternative Project
 * Linux Software Equivalents
 * Ubuntu Software Equivalents
 * +500 GNU/Linux Equivalents (Wikibooks in Spanish)

title: Linux Guide/Software equivalents


text:
Template:Reading level

See Reading Levels for more details about the use of this template.

title: Template:Reading level


text:
Wikibooks:Reading Levels

Reading Levels
Books have a preferred writing style that makes comprehension easy for readers who have mastered a certain level of fluency in reading a language. This page lists various reading fluency levels that may be required to read certain books here on Wikibooks. A book can show what the preferred reading fluency level is by using. Not to be confused with subject difficulty which is addressed by.

Common Reading Levels

 * Pre-reader: Pre-reader books are for young children and adults that have not yet learned to read the language the book is written in, or have just started to learn to pronounce simple words and read short sentences. A pre-reader typically needs a lot of pictures to help learn the language, and lot of assistance or someone to read out loud. These books are often part of Wikijunior. Use to add a book to this category.

 * Beginner: Books at the beginner skill level are intended for readers that may have some difficulties with pronunciation and comprehension when new vocabulary is encountered. Uncommon and difficult words should be properly introduced or defined when used. New concepts may rely heavily on pictures or illustrations to assist comprehension. These books should be accessible to readers with no education in the subject area, and should keep new vocabulary and long sentences to a minimum. Use to add a book to this category.

 * Intermediate: Books at the intermediate skill level are intended for readers that may comprehend new vocabulary from the context and usage. Sentence structures may be more diverse, and more difficult vocabulary is often not explained. These books should be accessible to readers without any particular expertise in the subject area, and subject-specific jargon should always be explained. Use to add a book to this category.

 * Advanced: Books at the advanced skill level depend on more background knowledge and understanding of more specialized vocabulary than is common for intermediate readers. Some subject-specific jargon is likely to be used without explanation, but a heavy reliance on subject-specific jargon should be avoided to increase readability and comprehension. Use to add a book to this category.

 * Professional: Books at the professional skill level tend to be highly subject-specific and require extensive background knowledge among readers. Jargon tends to be used extensively, and readability is often sacrificed for precision. These books may be dry, academic, and not welcoming to most readers. Use to add a book to this category.

title: Wikibooks:Reading Levels


text:
Semiconductor Electronics/Diode/Diode Maths

Experimentation method

Above shown is a apparatus to measure the characteristics of a diode. This apparatus has got a regulated voltage supply Vs. A potentiometer POT is used to get a variable voltage supply from 0V to Vs. A Voltmeter is connected parallel to the diode to measure voltage drop across the diode, an Ammeter is connected in series with the diode to measure the current flowing via the diode.

The voltage must be varied from 0V to Vs and the corresponding Voltmeter and Ammeter readings must be noted in a tabular format

Diode I-V Characteristic Curve

 * [[Image:Rectifier vi curve.GIF|frame|200px|Figure : I–V characteristics of a P-N junction diode (not to scale).]]

 * $$I=I_\mathrm{S} \left( e^{V_\mathrm{D}/(n V_\mathrm{T})}-1 \right),\,$$

where
 * I is the diode current,
 * IS is a scale factor called the saturation current,
 * VD is the voltage across the diode,
 * VT is the thermal voltage,
 * and n is the emission coefficient, also known as the ideality factor.

The saturation current IS is typically very small, so the diode current is often approximated as

 * $$I=I_\mathrm{S} e^{V_\mathrm{D}/(n V_\mathrm{T})}$$

The emission coefficient n varies from about 1 to 2 depending on the fabrication process and semiconductor material and in many cases is assumed to be approximately equal to 1 (thus omitted). The thermal voltage VT is approximately 25.7 mV at room temperature (25 °C or 298 K) and is a known constant. It is defined by:

 * $$V_\mathrm{T} = \frac{k T}{q},$$

where
 * q is the electrical charge of the electron (the elementary charge), often called e
 * k is Boltzmann's constant,
 * T is the absolute temperature of the p-n junction.


text:
Template:Corequisite

Use this template to point out books that should be read at the same time, or that are mutually supportive.

Related templates:
 * prerequisite

title: Template:Corequisite


text:
The Scientific Method/Resources

For more science topics, visit the Natural sciences bookshelf.

title: The Scientific Method/Resources


text: The Grand Inquisitor/Resources

title: The Grand Inquisitor/Resources


text:
MIPS Assembly/Resources

Wikimedia Resources

 * assembler
 * Programming:C
 * C++
 * Operating System Design
 * Embedded Systems
 * Reverse Engineering
 * Microprocessor Design
 * PSP Programming -- the PSP runs MIPS assembly language.

External Resources

 * Reverse Engineering for Beginners
 * A programmed Introduction to MIPS Assembly
 * OVPsim Virtual Platform Simulator
 * A Software MIPS Simulator
 * SPIM: MIPS Simulator
 * Patterson and Hennessy, Computer Organization and Design: The Hardware/Software Interface, 3rd Edition. Elsevier, 2005. ISBN 1558606941
 * Paul, Richard P. SPARC Architecture, Assembly Language Programming, and C, 2nd Edition, Prentice Hall, 2000. ISBN 0130255963
 * http://www.cs.tau.ac.il/~afek/MipsInstructionSetReference.pdf (the MIPS32 instruction set)

title: MIPS Assembly/Resources


text:
MIPS Assembly/Licensing

The text of this book is released under the following license:

title: MIPS Assembly/Licensing


text:
The Seven Wonders of the World/Resources

The initial text of this book has been adapted from articles at Wikipedia.


text: Sexual Health/Resources

title: Sexual Health/Resources


text:
SPARC Assembly/Resources

Wikimedia Resources

 * assembler
 * Programming:C
 * C++
 * Operating System Design
 * Embedded Systems
 * Reverse Engineering

External Resources

 * SPARC Architecture Manual, Version 9: http://developers.sun.com/solaris/articles/sparcv9.pdf
 * Patterson and Hennessy, "Computer Organization and Design: Third Edition". Elsevier, 2005. ISBN 1558606941
 * Paul, Richard P. "SPARC Architecture, Assembly Language Programming, and C: Second Edition". Prentice Hall, 2000. ISBN 0130255963

title: SPARC Assembly/Resources


text:
SPARC Assembly/Licensing

The text of this book is released under the following license:

title: SPARC Assembly/Licensing


text:
Subject:Subjects

< Books by subject

This is a list of all current subjects. Books should either be categorized with one of these subject tags, or a new subject should be created to accommodate your book.

title: Subject:Subjects


text:
Java Programming/3D Programming

Although Java comes with the Java 3D library other libraries have been developed over time with similar functionality. Thus, unlike many other areas of Java development explored in this book, a Java programmer has a choice to make as to which 3D library to use.

3D graphics Java libraries

 * Java 3D
 * JOGL
 * JPCT
 * Light Weight Java Game Library

title: Java Programming/3D Programming


text:
Talk:Control Systems/System Modeling

 * In External Description, 2nd formula, what happened to x(r)?
 * I think the only change from previous formula is just the limits

 * You're right, it was missing. I've fixed it now to be a proper convolution integral. Sorry for the misunderstanding. --Whiteknight (Page) (Talk) 21:12, 1 November 2007 (UTC)

PSD
no expansion of acronym, not in glossary--Billymac00 (talk) 15:36, 30 December 2008 (UTC)

title: Talk:Control Systems/System Modeling


text: User talk:69.210.96.83

title: User talk:69.210.96.83


text: User talk:81.109.197.2

title: User talk:81.109.197.2


text:
Talk:Japanese/Mini-tutorial lesson

USING TABLES
For study purposes, personally I think it works a lot better to put the words and sentences in tables. Then it's easy to cover the left or the right part and then try to think of the correct translation yourself. This is the way I have mastered German and French as well. Very effective!

Is there anybody who has other ideas? If not, I will soon continu putting the other words and sentences in tables (or let someone else do it, if somebody feels like it). Shinjitsu 19:50, 1 November 2007 (UTC)

 * Thank you so much! Please go ahead and put them into table form.

 * But not in the upcoming days. I am going to Tokyo for a couple of days now... Maybe after I am back. Also, I would like to know from any of the moderators if this way is the prefered way on WikiBooks. Maybe someone also has a better or faster way to do it... There's still LOTS of work to be done!
 * Btw, I see by your ip-address that you have done a few changes here and there. Not considering creating an account? Regards, Shinjitsu 23:51, 1 November 2007 (UTC)

Conversations in bulleted listings, "jumped" listings, or tables?
Who can tell me what is better?

This (bulleted listing):

Example 1: Mr. Smith walks into a shop. this (jump in with double point ":"):
 * スミス: おはよう ございます. を せます か.
 * すみません.  を せません.
 * スミス: わたし は が すこし しか せません.
 * です. わかります.

Example 2: Mr. Smith walks into a shop.
 * スミス: おはよう ございます. を せます か.
 * すみません.  を せません.
 * スミス: わたし は が すこし しか せません.
 * です. わかります.

or this (table):

I can't make a choice. Although I have a light preference towards the 2nd listing (the "jumped listing"), since it's much easier to make (write) and the left part and right part are nicely horizontally aligned. Can't do that in a table, because of the furigana (the smaller hiragana-characters above the kanji). But the table does give some extra space between the lines, which makes it a little nicer to read...

I'd like to have some opinions here please! As soon as I have enough opinions, I'll continu with the conversations. Thanks in advance! 真実 - Shinjitsu To my Talk page! 02:30, 12 November 2007 (UTC)
 * Absolutely not number 1, the bullets do not make it look like a conversation. Until I read your description I could not tell the difference between 2 and 3, but the extra line spacing of 3 does make it easier to read. So I like 3.--Balloonguy 22:20, 12 November 2007 (UTC)

Phrasebook or course/tutorial?
Right now this looks like a phrasebook, not like a course or "tutorial" as the name would imply. A phrasebook is something that people use for reference when traveling in a foreign country, so they could print out this Wikibook and carry it with them for reference (and due to coloring and length most commercial phrasebooks would be much more convenient to use for that purpose), but they can't actually learn from it. If you want to create a resource that people can learn from, you will need the following:
 * 1) vocabulary list or word-by-word translation of sentences, because right now people can't guess which word means what
 * 2) grammar section explaining how the words fit together, especially also the meaning of particles
 * 3) exercises, exercises, exercises so that people can see if they understood the grammar and learned the vocabulary
 * 4) ordering of taught phrases primarily not by topic (like "At the hotel") but by difficulty (complexity, tenses) and previously-taught grammar/vocabulary. The idea is that the lessons should first introduce the bare basics in terms of grammar and then build on each other (i. e. re-using knowledge that has been taught in previous lessons), introducing more and more complex phrases or grammar parts. Read the Wikibook on how to create a good language-teaching Wikibook!

If you'd like to create a mix between a phrasebook and a course, which allows for rapid language learning for tourists, I can recommend the method used in the "... tout de suite" series or even Michael Thomas' courses: introduce vital phrase parts like "I want", "I have", "I must", "I will" one by one along with useful words to go with them and teach phrase-building as you go, e. g. allowing the student to himself create phrases like "I want this book" or "I want to go to the pagoda today".

Alternatively, you could create word-by-word translations of your phrases along with the actual translation, like the Assimil method books do, and just provide a few footnotes on grammar and a few exercises. Then you'll just need a lot of phrases that people can use to "assimilate" the language and it's still recommended to make sure not to teach too complex grammar at the beginning. Recordings of the phrases are very important, too, because they mean much better retention.

I have provided a more detailed explanation of both methods in the Esperanto Wikibooks at, and there you can also find lessons plans you could adopt. If you want and if people here are actively looking to create a good Wikibook, I will help you further with the *planning* of this course, just send me a message on my User Talk page. My Japanese is not very good, so I can't actually contribute phrases and the like, but I'm a professional language course writer and I'd be ready to assist you by helping with the planning of lessons, showing you how you can write things so that people can learn from them and I'd play guinea pig.

Best wishes,

Junesun 10:18, 14 November 2007 (UTC)

 * Totally agree. Maybe the title should be changed. Into something like "Mini Phrase Book"... 真実 - Shinjitsu To my Talk page! 14:43, 14 November 2007 (UTC)

title: Talk:Japanese/Mini-tutorial lesson


text:
Talk:Rhetoric and Composition/What is Rhetoric

A few problems I see with this chapter: I'm also wondering to what extent this stuff should be moved to the chapter on writing argumentative papers. --Mattbarton.exe 20:05, 1 November 2007 (UTC)
 * The chapter jumps straight into a definition of rhetoric. I'd step back a bit and try to write a little about rhetorical situations, then address rhetoric as the formal study of how to address these situations. Why should people care about something if they have no idea what it is?
 * Second, the pathos/ethos/logos are from Aristotle's rhetoric, primarily. They are widely used, but there are other models (Toulmin schemes, for instance). There's also the "rhetorical triangle" or various forms of it. Do we want to go exclusively with Aristotle here?
 * Finally, I'm not sure what the logic stuff is doing here. Some might argue that these concerns are logic or dialectic rather than rhetoric. It's not a fallacy to use an ad hominem attack in a political speech, for instance, particularly if it works!


text:
Talk:Irish/Unit 2/Lesson 1

Untitled
You need a pronunciation guide, especially for Irish!

title: Talk:Irish/Unit 2/Lesson 1


text:
Chess Opening Theory/1. d4/1...Nf6/2. Nf3/2...b5

= Polish Defence Deferred =

2...b5
With this move, Black prevents White from playing c4 and prepares his queen's bishop to be fianchettoed.

Theory table
.

'''1.d4 Nf6 2. Nf3 b5'''


text:
SwisTrack/Examples/OutputProcessing

SwisTrack/Interfacing SwisTrack gives you an overview about how to communicate with SwisTrack. The OutputProcessing folder in the SwisTrack examples folder contains a few sample scripts and programs that help you to implement this.

Interfacing SwisTrack with Scripts
The NMEA format is extremely easy to process with regular expressions, as each message is on a separate line and starts with a $-sign. Hence - for all simple tasks - a Perl, Python, Ruby or Shell script is the easiest way to go. And often - if you reduce it to what you really need - your task IS simple.

The swistrack-filter.* files contain simple examples how SwisTrack messages can be processed. The swistrack-interface.pl script furthermore shows how you can send messages to remotely control SwisTrack. How to use these filter scripts in a terminal (shell) is explained in SwisTrack/Interfacing SwisTrack.

Interfacing SwisTrack with a C/C++ Program
To ease interfacing SwisTrack with your C/C++ program, we provide you code for parsing NMEA messages. The necessary files along with a sample program and some implementation hints are available in the folders NMEAParserC and NMEAParserC++ respectively. Both merely consist of a state machine scanning a data stream for NMEA messages, and are suited for both blocking and non-blocking IO.

Interfacing SwisTrack with a Microcontroller
The C implementation of the NMEA parser (NMEAParserC) can also be used on microcontrollers (if a C compiler for your microcontroller is available). In addition, you may need to write a script which forwards data between a TCP connection to SwisTrack and a serial connection to your microcontroller. One-way forwarding can even be achieved on the shell): cat < /dev/tcp/HOSTNAME/3000 > /dev/ttyS0    # assuming your serial port is /dev/ttyS0

The overhead for parsing NMEA is very small, and the overhead in terms of message size is reasonable as well. It is therefore rarely necessary to convert the data to another format when sending it over a slow serial link to a microcontroller.

Interfacing SwisTrack with SWIG
We have written swig/python bindings that allow you to instantiate a swistrack pipeline and get the output as an IplImage. This makes it possible to view all parts of the pipeline in a SWIG-compatible language. (We've only tested python so far, but Swig supports lots of languages.)

Checksum
The NMEA message checksum is optional and only makes sense if you are sending the data over an unreliable channel. SwisTrack always adds a checksum on outgoing messages, but does not require any checksum for incoming messages. However, if a checksum is provided, it has to be correct! (Messages with wrong checksums are discarded.)

As long as you are transmitting your messages over a TCP connection, you can safely assume that the channel is reliable (transmission errors are handled by lower network layer) and you don't need to implement checksum checking. USB and Bluetooth transmission are safe as well. If you transmit the messages over a serial cable (e.g. to a robot), however, handling the checksum may make sense - especially if you plug/unplug the cable while the system is running.

Plotting Results in Matlab
Matlab (or similar programs) doesn't read NMEA messages directly. The simplest way to plot data in Matlab is to write a filter script (adapt swistrack-filter.*) which extracts the relevant information among all incoming NMEA messages and prints it in matrix form. E.g. $PARTICLE,0,10,15,2.11 would be converted into 0 10  15  2.11 The resulting file can then be read with the Matlab load function.

Multiple Scripts/Programs
It is sometimes helpful to split a task into a few smaller (unrelated) tasks, and therefore create a few small, independent scripts/programs which all connect to SwisTrack. As SwisTrack accepts multiple TCP connections at the same time, this works just as fine as a single big script/program. All these scripts/programs may run on the same or on different computers, which gives you maximum flexibility.

If you need to exchange information between your scripts/programs, you can use the BROADCAST message. This allows you to send messages through SwisTrack to all clients, without the hassle to establish dedicated communication channels between them.

title: SwisTrack/Examples/OutputProcessing


text:
User talk:Deep kukreja

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally.– Mike.lifeguard  | talk 20:59, 1 November 2007 (UTC)

title: User talk:Deep kukreja


text:
Hebrew/Language/Answers

Hebrew to English Translations
What do the following words mean?
 * עִבְרִית
 * Hebrew
 * אֳנִי (review from Lesson 1)
 * I
 * כֵּן (review from Lesson 1)
 * yes
 * מְבִינָה
 * understand (feminine)

English to Hebrew Translations
How would you say the following in Hebrew?
 * Hebrew
 * ivreet
 * speak (singular, feminine)
 * midaberet
 * understand (singular, masculine)
 * no
 * word
 * he (review from Lesson 1)

Without Diacritic and Vowel Marks
Since Hebrew usually does not have the diacritic and vowel marks, practice reading the following without the marks. (The first time through the translation is given as a hint.) Try to read each word aloud. עברית (Hebrew) - Ivrit(Ivreet) את (you, feminine) - At לא (no) - Lo  מבין (understand, masculine) - Mevin מדברת (speak, feminine) - Midabet(Mid-a-beret) אני (I) - Ani(Anee) מדבר (speak, masculine) - Midaber(Mid-a-ber) אתה (you, masculine) - Atah אנגלית (English) - Anglit(Ang-leet) כן (yes) - Ken מבינה (understand, feminine) - Mevina

Now without the translation hints... how do you pronounce the word or phrase and what does it mean? מדברת את אני לא מדברת אנגלית לא מדבר אתה אנגלית מבין אני עברית כן מבינה

title: Hebrew/Language/Answers


text:
Writing a Research Paper

What's a research paper?
A paper involving hands-on or library-based research, or both. Expectations for research papers differ depending on discipline.

For specific guidance for history, see How to Write a Research Paper in History.

Selecting a Topic

 * Step One: Things to Consider
 * 1) What do you really care about (in school or out of school)?
 * 2) If you had all the time in the world, what would you spend your time doing? Studying?
 * 3) What do you want to learn more about?

Your answers may range from the very academic (e.g., plant science, Gettysburg Address) to non-academic subjects (e.g., car mechanics, basketball, etc.).

Once you have narrowed down a subject matter to study more thoroughly, you need to pose an analytical question about the subject or topic. Using “why” or “how” often works much better than “what,” and promotes better critical thinking. Use open-ended questions, such as:
 * Step Two: Pose an Analytical Question
 * I have always wondered why _________________________________________.
 * I have always wondered how _________________________________________.
 * I wonder why/how ______________________ about _____________________.
 * What about __________________________would you like to learn more about?

Fill in the blanks for the subject, and then focus on the content to be learned. For example:
 * Step Three: Take it a Step Further

 * I wonder how ___________________________________________ about the Civil War.

Student Response: I wonder how soldiers on one side of the battle were able to gain information about the other side during the Civil War when computers, radar and military intelligence were not available as they are today.

Now we are getting somewhere.

Whatever the subject, there is probably a conversation occurring about it (or a conversation has occurred sometime in the past). Whether the topic is highly academic or only slightly in the academic circle, there is most likely something people have already said about the issue. Find it! Research!
 * Step Four: Finding the Current “Academic Conversation”

As you read your research, you are drawing conclusions and making inferences; ultimately you are forming an opinion – a position! You will defend your position in a thesis statement.
 * Step Five: Drawing Conclusions/Making Inferences

Citing your sources
Citing your sources serves several purposes: it shows where you drew information from, it enables interested readers to find out more by providing them with the tools to locate those sources, and it gives credit to the authors whose work you used. It is also a crucial part of preventing plagiarism.

title: Writing a Research Paper


text:
User talk:24.58.10.14

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.

– Mike.lifeguard  | talk 23:04, 1 November 2007 (UTC)

title: User talk:24.58.10.14


text:
User talk:76.214.121.125

– Mike.lifeguard  | talk 00:17, 2 November 2007 (UTC)

title: User talk:76.214.121.125


text: User:Whiteknight/Count Ticker/2007/November