LQWiki - User contributions [en]

Disk partitioning

2004-10-26T16:40:40Z

Chalupamaster92: Added detail, plus a 37-page anti-corporate manifesto.

==Partitioning==

Partitioning is the act of dividing a hard drive or other storage media into sections, each of which can hold its own file system. The BIOS of the computer is informed of the partitioning through a special area near the beginning of the hard drive called the partition table.

From an end user's point of view, partitioning is important because it can be used to create dual-boot systems and give older hardware access to more of the storage on newer hard drives. For example, a simple dual-boot partitioning scheme might have an NTFS partition containing Windows XP, a partition for a Linux root directory, a third partition for home directories, and a Linux swap partition.

On many systems, there is a maximum limit of four primary partitions. It is possible for each primary partition to be divided into numerous logical partitions, but this process can be tricky.

A list of partitioning tools and techniques can be found in [[Disk_and_tape_drive_commands]].

People

2004-04-19T02:25:07Z

Chalupamaster92: Added two names

[[Linux]] was originally created by Linus Torvalds with the assistance of developers around the world. This page is dedicated to those people. Here's a list of the most important contributors to the Linux community.

===Important People===
* [[Linus Torvalds]] - Founder of the [[Linux]] kernel.
* [[RMS|Richard M. Stallman]] - Founder of the [[Free Software]] movement.
* [[Miguel de Icaza]] - founder of [[Ximian]], the [[GNOME]] project and the [[Mono]] project. He has also been a kernel and [[Wine]] contributor.
* [[ESR|Eric S. Raymond]] - One of the primary advocates of the [[Open Source]] movement.
* [[Brian Behlendorf]] - President of the Apache Software Foundation and creator of the [[Apache|Apache Web Server]].
* [[Andrew Tridgell]] - Lead developer for [[Samba]].

Emacs keystrokes

2004-04-19T02:09:18Z

Chalupamaster92:

'''[[Emacs]]''' works its text-editing wonders through a combination of indirection and Lisp-jitsu. When you type a key--'k', for instance--Emacs doesn't simply paint the character on the screen, it takes the keystroke and sees what sort of commands are "bound" to it. In the case of 'k', the command it issues is a straightforward "insert me where the cursor is."

At this point, no advantage is apparent. But the commands bound to a keystroke can be arbitrarily complex. For example, when Emacs is running in [[C]] [[Emacs_modes|mode]], pressing the <TAB> key doesn't indent everything after the cursor by a single tabspace. Instead, it analyzes the code that you are writing, and indents the entire line to whatever depth appears to make the most sense.

There are many more examples, but the upshot is that if you're willing to learn the Emacs way, there are many tips and tricks to pick up that can make it a very productive environment. Just be warned that, before it's over, you're going to be bending and contorting your fingers in ways you never imagined.

==Basic Keystrokes==

The keystroke <CTRL>+X is generally represented as C-x, while <META>-v would be displayed with the shorthand M-v. The meta key varies from system to system, but is usually the <ALT> key. The <ESC> key can be pressed before any key to simulate the <META> version of that key.

If two commands are separated by a comma (C-p, C-n for example) then they are separate commands. Otherwise they are part of the same command. For example, C-x C-s means you type <CTRL>-x, then <CTRL>-s to execute the command.

===Navigation===

* C-p, C-n, C-f, C-b : Functionally equivalent to the arrow buttons. C-p moves the cursor up to the '''p'''revious line, C-n moves it down to the '''n'''ext line, C-f moves one space '''f'''orward, and C-b moves one space '''b'''ackwards. It may seem silly to have these commands when the arrow keys are right there. But once you're used to them [and they do take some getting used to] you may decide that 'right there' just isn't close enough, and it's nice to be able to navigate without moving your hands away from normal typing position.

* C-a, C-e : C-a moves to the beginning of a line ('''a''' is the beginning of the alphabet), while C-e moves to the '''e'''nd of the line.

''Note: These keystrokes aren't specific to Emacs. For example, all six work on the command line, and they also work inside forms on the web browser I'm using to type this. You may find it advantageous to try and make them second nature.''

* C-l : Centers your view of the buffer so that the cursor is in the middle of the screen.

* C-v, M-v : Move the cursor up and down by half a page of text at a time.

* M-<, M-> : Moves the cursor to the beginning and end of the entire document.

===Files and Buffers===

* C-x C-s : Saves the current buffer. If there is no file associated with the buffer, Emacs prompts for a filename.

* C-x C-w : Saves the current buffer, requesting a name.

* C-x C-f : Open a file.

* C-x d : Open a directory.

* C-x b, C-x C-b: The first takes you to another buffer. the second takes you to a list of all available buffers.

* C-x 1, C-x 2, C-x 3 : C-x 2 and 3 split the current window. 2 splits horizontally, while 3 splits vertically. C-x 1 gets rid of the various splits, leaving you with a single window.

* C-g : Cancel the current command or key sequence, even if you are in a minibuffer. A minibuffer is a one-line buffer at the bottom of the screen, where you type in things like filenames and search expressions. Sometimes you may have to hit C-g more than once.

===Cutting and Pasting===

* C-k : Removes the portion of the line following the cursor and places it on the clipboard. Repeat to remove more text and append it to the clipboard.

* C-[space] : Sets a "mark" (beginning of the current selection).

* C-w : Removes everything between the cursor and the "mark" and places it on the clipboard.

* C-y : Inserts the contents of the clipboard into the buffer.

* M-y : After pressing C-y, use this to gain access to previous items in the clipboard.

===Help===

* C-h t : This takes you to a tutorial which tries to teach you all this, and a bunch of other stuff besides. It's very helpful for the aspiring Emacs enthusiast.

* C-h k : Runs the command "describe-key." It prompts you for a key that you would like described, then you perform whatever key sequence you want to know about.

* C-h b : Opens a list of all the commands currently bound to keys.

* M-x doctor : Sometimes you just have to talk out your problems with a sympathetic program.

===Miscellaneous===

* M-/ : Autocompletion. Emacs looks through the buffer for possible completions of whatever you're typing at the moment. For example, if you've typed "rotweiler" at some point previous, and wish to reuse the word, you could type rot'''M-/''' and it will fill in the "weiler". Of course, it may also come up with "rotation" if it sees that word as well. Can be very handy.

''see also''
* [[Emacs modes]]
* [[Emacs customization]]

Binary

2004-03-14T18:58:24Z

Chalupamaster92: Floating point section lacks detail.

'''Binary''' (also known as base 2) is the representation of numbers with a base--or ''radix''--of two. Binary numbers are therefore represented with two symbols, usually written as a string of 1's and 0's e.g. 0001010011101.

In the more familiar world of decimal counting, there are ten values that a single symbol can represent (0-9, giving it a radix of 10). To express higher numbers, a "positional notation" is used. For example, the 1 in 21936 represents a quantity of 1 * 10^3, or 1000.

Binary works in much the same way, with the position of a bit representing its magnitude. A number like 10110 represents:
<tt>
1 * 2^4 (16)
+ 0 * 2^3 (8)
+ 1 * 2^2 (4)
+ 1 * 2^1 (2)
+ 0 * 2^0 (1)

16 + 4 + 2 = 20
</tt>

In case this is unclear, here is the same process for a decimal number 87,103:
<tt>
8 * 10^4 (10,000)
+ 7 * 10^3 (1000)
+ 1 * 10^2 (100)
+ 0 * 10^1 (10)
+ 3 * 10^0 (1)

80,000 + 7000 + 100 + 3 = 87,103.
</tt>

One limitation of the system as it is currently described: There is no way to represent negative numbers. To overcome this limitation, it is standard practice to use the highest visible bit to represent the sign of the number. There are four different ways to represent negative numbers: sign-and-magnitude, one's complement, two's complement, and biased notation. Two's complement dominates the field of computing today, because it makes it easy to perform arithmetic operations. However, biased notation has some very useful properties, and makes an appearance in the discussion of floating point numbers.

===sign and magnitude===
While sign-and-magnitude is a lousy way to implement a computer, it's the easiest notation to understand. After all, it's the way we represent decimal numbers in daily life. The highest bit (going from left to right) tells you which way to travel from zero. The rest of the number is read as one would read an unsigned binary number. For example, 0101 would translate to 5, and 1101 would be -5.

Notice that 0000 and 1000 both represent zero, much as if I wrote +0 and -0 in decimal. One's complement also has two representations of zero.

===one's complement===

The ''complement'' of a number is the number of the same magnitude but opposite sign (the number times -1). In one's complement, the complement is found by simply swapping all the zeros with ones, and vice versa. So the complement of 01101 (13) is 10010 (-13).

===two's complement===
In two's complement notation, getting the complement of a number requires putting ones where the zeros are and zeros where the ones are, and then adding 1 to the result. The complement of 01001 (9) would be 10110 + 1, or 10111 (-9). While that may seem like a bit of needless complexity when compared to the one's complement, from a computer's-eye view it amounts to a great simplification.

Under this notation, the highest visible bit of a number implicitly defines all the higher bits. 01001 is simply a shorthand way of saying ...00000000000001001. For negative numbers, 10111 means ...11111111111110111. This should be slightly confusing because, as I mentioned earlier, binary numbers are represented in positional notation. The question is, what can an infinite string of 1's represent?

For a negative number, the positional notation works as follows: The highest bit represents -1 * 2^(position). Each subsequent bit represents 1 * 2^(position). Here's the breakdown for 111 (-1), and for 111111 (-1).

<tt>
-1 * 2^2 (-4)
+ 1 * 2^1 (2)
+ 1 * 2^1 (1)

-4 + 2 + 1 = -1

-1 * 2^5 (-32)
+ 1 * 2^4 (16)
+ 1 * 2^3 (8)
+ 1 * 2^2 (4)
+ 1 * 2^1 (2)
+ 1 * 2^1 (1)

-32 + 16 + 8 + 4 + 2 + 1 = -1
</tt>

Adding and subtracting is fairly straightforward in two's complement. For addition, simply use the grade school algorithm of adding the bits in a position, and carrying the overflow to the next higher position:
<tt>

1 11 <-- carry
01001001 (73)
+ 00101011 (43)
----------
01110100 (116)
</tt>

Subtraction simply requires taking the first number and adding it to the twos complement of the second. <tt>0101 - 0110 (5 - 6)</tt> would be the same as <tt>5 + (-6)</tt>:

<tt>
Two's complement of 0110:

1 <--carry
1001
+ 1
------
1010

0101 (5)
+ 1010 (-6)
------
1111 (-1)
</tt>

This is very similar to the method by which modern processors perform the same operations.

===biased notation===
In biased notation, a string of zeros represents the smallest possible number the system can express, while 1111 represents the largest.

One of the consequences you may have noticed is that the same string of bits can represent several different numbers, depending on whether the number is interpreted as an unsigned, ones complement, or twos-complement number. There is yet another interpretation of a given series: as a floating point number.

===floating point===
Floating point math on computers has a long and painful history of conflicting representations and implementations. Today sanity reigns, after the industry converged on a single standard called [http://en.wikipedia.org/wiki/IEEE_754 IEEE754].

----

Colloquially, a '''binary''' is a compiled computer program. They are referred to as such, because they are represented in a form that a computer (which speaks binary [[machine code]]) understands, rather than [[source]], which a human does.

See also [[unary]], [[octal]] (base 8), [[decimal]](base 10), and [[hexadecimal]](base 16)

Binary

2004-03-14T17:48:14Z

Chalupamaster92: Saving. Still much to be done.

'''Binary''' (also known as base 2) is the representation of numbers with a base--or ''radix''--of two. Binary numbers then, are represented with two symbols, usually written as a string of 1's and 0's e.g. 0001010011101.

In the more familiar world of decimal counting, there are ten values that a single symbol can represent (0-9, giving it a radix of 10). To express higher numbers, a "positional notation" is used. For example, the 1 in 21936 represents a quantity of 1 * 10^3, or 1000.

Binary works in much the same way, with the position of a bit representing its magnitude. A number like 10110 represents:
<tt>
1 * 2^4 (16)
+ 0 * 2^3 (8)
+ 1 * 2^2 (4)
+ 1 * 2^1 (2)
+ 0 * 2^0 (1)

16 + 4 + 2 = 20
</tt>

In case this is unclear, here is the same process for a decimal number 87,103:
<tt>
8 * 10^4 (10,000)
+ 7 * 10^3 (1000)
+ 1 * 10^2 (100)
+ 0 * 10^1 (10)
+ 3 * 10^0 (1)

80,000 + 7000 + 100 + 3 = 87,103.
</tt>

One limitation of the system as it is currently described: There is no way to represent negative numbers. To overcome this limitation, it is standard practice to use the highest visible bit to represent the sign of the number. There are four different ways to represent negative numbers: sign-and-magnitude, one's complement, two's complement, and biased notation. Two's complement dominates the field of computing today, because it makes it easy to perform arithmetic operations. However, biased notation has some very useful properties, and makes an appearance in the discussion of floating point numbers.

===sign and magnitude===
While sign-and-magnitude is a lousy way to implement a computer, it's the easiest notation to understand. After all, it's the way we represent decimal numbers in daily life. The highest bit (going from left to right) tells you which way to travel from zero. The rest of the number is read as one would read an unsigned binary number. For example, 0101 would translate to 5, and 1101 would be -5.

Notice that 0000 and 1000 both represent zero, much as if I wrote +0 and -0 in decimal. One's complement also has two representations of zero.

===one's complement===

The ''complement'' of a number is the number of the same magnitude but opposite sign (the number times -1). In one's complement, the complement is found by simply swapping all the zeros with ones, and vice versa. So the complement of 01101 (13) is 10010 (-13).

===two's complement===
In two's complement notation, getting the complement of a number requires putting ones where the zeros are and zeros where the ones are, and then adding 1 to the result. The complement of 01001 (9) would be 10110 + 1, or 10111 (-9). While that may seem like a bit of needless complexity when compared to the one's complement, from a computer's-eye view it amounts to a great simplification.

Under this notation, the highest visible bit of a number implicitly defines all the higher bits. 01001 is simply a shorthand way of saying ...00000000000001001. For negative numbers, 10111 means ...11111111111110111. This should be slightly confusing because, as I mentioned earlier, binary numbers are represented in positional notation. The question is, what can an infinite string of 1's represent?

For a negative number, the positional notation works as follows: The highest bit represents -1 * 2^(position). Each subsequent bit represents 1 * 2^(position). Here's the breakdown for 111 (-1), and for 111111 (-1).

<tt>

===biased notation===

One of the consequences you may have noticed is that the same string of bits can represent several different numbers, depending on whether the number is interpreted as an unsigned, ones complement, or twos-complement number. There is yet another interpretation of a given series: as a floating point number.

===floating point===
Floating point math on computers has a long and painful history of conflicting representations and implementations. Today sanity reigns, after the industry converged on a single standard called [http://cch.loria.fr/documentation/IEEE754/ IEEE754].

----

Colloquially, a '''binary''' is a compiled computer program. They are referred to as such, because they are represented in a form that a computer (which speaks binary [[machine code]]) understands, rather than [[source]], which a human does.

See also [[unary]], [[octal]] (base 8), [[decimal]](base 10), and [[hexadecimal]](base 16)

Talk:C plus plus tutorial

2004-03-14T16:07:12Z

Chalupamaster92: Some questions about style.

I'm trying to get this page together, but I have a couple of questions.

Question the first: Is there a GPL/Creative Commons tutorial that I could modify to speed this process along?

Question the second: What is the traditional format for breaking up a page like this into multiple, related pages. Would they be labelled C_plus_plus_tutorial_[1|2|3]? Or C_plus_plus_tutorial_[intro|simple|vars]?

Question the third: Is there a better place to ask these questions?

[[User:Chalupamaster92|Chalupamaster92]] 11:07, Mar 14, 2004 (EST)
----

Machine code

2004-03-14T15:43:04Z

Chalupamaster92: Link-making and other tweaks.

'''Machine Code''', sometimes called ''binary code'', is simply a set of instructions and data that directly control the actions of a [[CPU]]. A collection of machine code used to accomplish some useful task (or play ''Counterstrike'') is called a ''program''.

Not every CPU can read every program. Whether a [[processor|microprocessor]] can read a given program depends on its ''instruction set architecture'' (ISA), which defines the form that individual instructions to a given chip have to take. For example, Intel has its x86 instruction set, while others (such as SGI's R-series microprocessors) are based on the [[MIPS]] instruction set.

There exist entire families of chips with the same instruction set, so a program compiled for the x86 architecture will run happily on a [[Pentium]] IV, a Cyrix x86, or an AMD Athlon. Even within a single manufacturer's product line, there can be wide variations in clock speed, cache size, or pipeline size, without harming compatability.

An instruction set represents all the discrete operations that can be performed by a processor, including fundamental operations like adding and subtracting integer and floating point numbers, loading data from and storing it back to [[memory]], multiplying and dividing, testing conditions (for example, does [[variable]] x = 5?) and branching the program based on the results. Some chips also include more specialized operations (for example, early Pentiums contained "MMX instructions" which were intended to speed up multimedia).

===The Life of a Program===

Most programs start their lives as a collection of [[source code]]; human-readable files that define how a program should operate. There are literally hundreds of [[programming languages]] to choose from.

Before a program is compiled into machine code, it may first be translated into [[object code]], which is basically machine code with certain symbols (calls to [[Library-related Commands and Files|libraries]] for example) left undefined. It is up to a separate program called the [[linker]] to resolve the unknown symbols so that the program can use them.

Once a program has been compiled and linked, it can be stored in an executable format (common Unix formats include [[a.out]] and [[ELF]]) on the [[hard drive]]. Now the program can be loaded into memory and run.

Note: Some programming languages (notably [[Java]] and Microsoft's .NET) compile into bytecode rather than machine code. Instead of targeting a specific type of hardware, the compiler will translate programs into instructions that can be read by a software-based [[virtual machine]].

Machine code

2004-03-14T15:18:58Z

Chalupamaster92: COFF isn't a Unix executable format, and I isn't too bright.

'''Machine Code''', sometimes called ''binary code'', is simply a set of instructions and data that directly control the actions of a [[CPU]]. A collection of machine code used to accomplish some task (or play ''Counterstrike'') is called a ''program''.

Not every CPU can read every program. Whether a microprocessor can read a given program depends on its ''instruction set architecture'' (ISA), which defines the form that individual instructions to a given chip have to take. For example, Intel has its x86 instruction set, while others (such as SGI's R-series microprocessors) are based on the MIPS instruction set.

There exist entire families of chips with the same instruction set, so a program compiled for the x86 architecture will run happily on a Pentium IV, a Cyrix x86, or an AMD Athlon. Even within a single manufacturer's product line, there can be wide variations in clock speed, cache size, or pipeline size, without harming compatability.

An instruction set represents all the discrete operations that can be performed by a processor, including fundamental operations like adding and subtracting integer and floating point numbers, loading data from memory and storing it back, multiplying and dividing, testing conditions (for example, does variable x = 5?) and branching the program based on the results. Some chips also include more specialized operations (for example, early Pentiums contained "MMX instructions" which were intended to speed up multimedia).

===The Life of a Program===

Most programs start their lives as a collection of [[source code]]; human-readable files that define how a program should operate. There are literally hundreds of [[programming languages]] to choose from.

Before a program is compiled into machine code, it may first be translated into [[object code]], which is basically machine code with certain symbols (calls to [[library|libraries]] for example) left undefined. It is up to a separate program called the [[linker]] to resolve the unknown symbols so that the program can use them.

Once a program has been compiled and linked, it can be stored in an executable format (common Unix formats include a.out and ELF) on the hard drive. Now the program can be loaded into memory and run.

Note: Some programming languages (notably Java and Microsoft's .NET) compile into bytecode rather than machine code. Instead of targeting a specific type of hardware, the compiler will translate programs into instructions that can be read by a software-based [[virtual machine]].

Talk:Machine code

2004-03-14T15:13:14Z

Chalupamaster92:

I'm glossing over a whole lot of detail in this article, especially when it comes to the compiling process. Feel free to dig in.

[[User:Chalupamaster92|Chalupamaster92]] 10:13, Mar 14, 2004 (EST)
----

Machine code

2004-03-14T15:11:14Z

Chalupamaster92: Destubbification, rough draft

'''Machine Code''', sometimes called ''binary code'', is simply a set of instructions and data that directly control the actions of a [[CPU]]. A collection of machine code used to accomplish some task (or play ''Counterstrike'') is called a ''program''.

Not every CPU can read every program. Whether a microprocessor can read a given program depends on its ''instruction set architecture'' (ISA), which defines the form that individual instructions to a given chip have to take. For example, Intel has its x86 instruction set, while others (such as SGI's R-series microprocessors) are based on the MIPS instruction set.

There exist entire families of chips with the same instruction set, so a program compiled for the x86 architecture will run happily on a Pentium IV, a Cyrix x86, or an AMD Athlon. Even within a single manufacturer's product line, there can be wide variations in clock speed, cache size, or pipeline size, without harming compatability.

An instruction set represents all the discrete operations that can be performed by a processor, including fundamental operations like adding and subtracting integer and floating point numbers, loading data from memory and storing it back, multiplying and dividing, testing conditions (for example, does variable x = 5?) and branching the program based on the results. Some chips also include more specialized operations (for example, early Pentiums contained "MMX instructions" which were intended to speed up multimedia).

===The Life of a Program===

Most programs start their lives as a collection of [[source code]]; human-readable files that define how a program should operate. There are literally hundreds of [[programming languages]] to choose from.

Before a program is compiled into machine code, it may first be translated into [[object code]], which is basically machine code with certain symbols (calls to [[library|libraries]] for example) left undefined. It is up to a separate program called the [[linker]] to resolve the unknown symbols so that the program can use them.

Once a program has been compiled and linked, it can be stored in an executable format (common Unix formats include COFF and ELF) on the hard drive. Now the program can be loaded into memory and run.

Note: Some programming languages (notably Java and Microsoft's .NET) compile into bytecode rather than machine code. Instead of targeting a specific type of hardware, the compiler will translate programs into instructions that can be read by a software-based [[virtual machine]].

Unicode

2004-03-11T14:26:00Z

Chalupamaster92: The entire article was about the Unicode Consortium. :)

===What is unicode?===
'''Unicode''' is a system for representing characters and symbols in binary[1]. To that extent, it is similar to other encoding schemes like [[ASCII]]. However, the goal of Unicode is to be able to uniquely represent every character in every language. Use of Unicode promotes easy internationalization of files and applications.

Unicode encoding schemes include UTF-8, UTF-16, UTF-32. These use 8, 16, and 32 bits to represent a character, respectively.

==What is the Unicode Consortium?==
''From the unicode website:'' The Unicode Consortium is a non-profit organization founded to develop, extend and promote use of the Unicode Standard, which specifies the representation of text in modern software products and standards. The membership of the consortium represents a broad spectrum of corporations and organizations in the computer and information processing industry. The consortium is supported financially solely through membership dues. Membership in the Unicode Consortium is open to organizations and individuals anywhere in the world who support the Unicode Standard and wish to assist in its extension and implementation.

==External Link==
* [http://www.unicode.org/ Unicode.org]

[1] Just to be absolutely clear, Unicode is not a set of fonts, nor is it a software package. It's simply a way of representing a given character as a string of 1's and 0's.

Mkisofs

2004-03-11T13:49:30Z

Chalupamaster92:

'''mkisofs''' - A utility for creating hybrid ISO9660/Joliet/HFS filesystems, including optional Rock Ridge extensions.

*ISO9660: A format for storing data about the files on a volume (file system). It's a "lowest common denominator" that most operating systems will understand. This is the format used by CD image files, sometimes called ISO's.

*Joliet: an extension to the ISO9660 format which allows for long filenames and filenames in [[unicode]].

*Rock Ridge: an extension to the ISO9660 format, which allows the CD to store long filenames, UNIX permissions, and symbolic links].

*HFS (Heirarchal File System): a third extension, which supports file information useful to [[Macintosh]] computers.

mkisofs is useful for CD and DVD writing, but it cannot perform the write itself. Instead, it takes a directory structure and converts it into a binary file which corresponds to the information which would be on the CD. This file can be used by CD mastering software such as [[cdrecord]].

mkisofs can be used to create bootable CDs.

Internet Relay Chat

2004-03-11T07:17:41Z

Chalupamaster92:

'''IRC''': ''Internet Relay Chat'' - one of the older widespread messaging protocols; similar to the popular IM networks, but ordinarily used for chat rooms rather than [[instant messaging]]. Servers are distributed and can be run by anyone, so IRC is a very free place. It houses help channels for almost all major [[Linux]] distributions, as well as rooms devoted to just about every topic imaginable. Channels have "operators" who can kick or mute anyone in the room. It also features the ability to send files. Like any large community, it does have its seedier regions, so be wary when venturing forth. (i.e. SexNet is probably not a good starting place for the easily offended.)

Some regions of IRC are even battlegrounds, as people try to take over channels from each other. The battles are fought by disabling the systems of the people who currently control a channel.

See also:

*[[IRC Tutorial|Using IRC]]
*[[Getting help from IRC]]

Getting help from IRC

2004-03-11T07:16:45Z

Chalupamaster92:

Most major distributions will have a user-supported channel on the IRC network FreeNode (Formerly OpenProjects). in order to connect to an IRC network you will need an [[IRC Client]].
----
Here are some of the channels for some of the more major distributions (in alphabetical order):

* '''[[Debian]]''' - #Debian
* '''[[Fedora]]''' - #fedora
* '''[[Gentoo]]''' - #Gentoo
* '''[[Mandrake]]''' - #Mandrake
* '''[[Slackware]]''' - #slackware
----

For help getting started with IRC, go to the [[IRC tutorial]].

Free

2004-03-11T06:52:28Z

Chalupamaster92: Random pontification with much linking

The concept of "freedom", as it applies to software, is complicated because of the multiple uses of "free" in the English language. Some have proposed the term "libre software" to eradicate potential confusion; as of this writing, this term has not caught on widely.

The [[FSF]] (or Free Software Foundation) clearly explains their position here: [http://www.fsf.org/philosophy/free-sw.html]

Note that, politically, ''free software'' and ''open-source software'' are two separate movements, with separate but frequently overlapping goals. "Free Software" focuses on the political and ethical ramifications of keeping software free. "Open Source" tends to focus on more the more pragmatic advantages that come with open source, such as code quality and lower development costs. Individual software packages are often referred to using either term, and the distinctiveness of the two approaches is further blurred by the increasing use of the term '''FOSS''', or 'Free, Open-Source Software'.

There are two different meanings of "free" when referring to software: available at no cost, or freely modifiable under a non-restrictive license. The analogy commonly used to illustrate the distinction is by comparing "free beer" to "free speech."

The [[Open Source Initiative]] maintains a list of dozens licenses which are considered compatible with the goals of the Open Source movement, including the [[GPL]] and [[LGPL]], [[BSD license|BSD]], [[Apache]], [[Mozilla MPL|Mozilla]], and [[SISSL]] licenses.

Integrated development environment

2004-03-11T06:36:17Z

Chalupamaster92:

What are good Linux IDE's? What features do they have? How easy are they to use? Is the Documentation any good? Are there any Dreamweaver alternatives?

Integrated Development Environment:
* [[DevCpp|Dev-C++]]
* [[Glimmer]]
* [[KDevelop]]

Web Design Environment:
* [[Bluefish]]
* [[Nvu]] / [[Mozilla Composer]]
* [[Quanta]]

Nice

2004-03-11T06:34:36Z

Chalupamaster92: Let the niceness begin

'''nice''' is a utility that reports or sets the priority of a command, giving the user control over how much processor time is allotted for running a given task. The "niceness" of a program is a number between -20 and 19. The higher the number, the more willing a task is to step aside and let other tasks monopolize the processor. That's why it's called "niceness" instead of "greediness."

nice is used when a command is first run. For example, <tt>nice -n 19 setiathome</tt> would run setiathome with the lowest possible priority. Privileges are required to run a command with negative priority. To change the priority of a currently running process, use [[renice]].

Ln

2004-03-11T06:02:24Z

Chalupamaster92:

<tt>ln</tt> - creates a link from one file to another.

Links are divided into two classes, hard and symbolic. Symbolic links (symlinks) are often preferred due to their flexibility and the ability to work across different partitions.

Given a file, it is non-trivial to locate other files linked to it. Symbolic links can be found by searching the entire filesystem for symbolic links pointing to that file, while hard links can only be found by searching every inode at a low level for inodes that share the same data pointers as that file.

==Hard==

Hard links are more "robust" than symbolic links in that the links are actually connected, and renaming or deleting one of the files does not break the link between them. However, as the files are actually connected at the inode level in Linux, hard links cannot cross partitions. In addition, directories cannot be hard linked, except for the special links <tt>.</tt> and <tt>..</tt> which refer to itself and the parent directory respectively. Also unlike symbolic links, hard links can never be dangling, and each hard link can have different access permissions and ownership.

With hard links, a link counter is maintained on each file. When the link counter drops to zero, the file is deleted. This way, once you hard link a file, you can delete either "copy" of the file, and the other will still be valid. Normally, files only have a single link. Directories have as many links as they have subdirectories (including <tt>.</tt> and <tt>..</tt>).

===Creating===
Hard links are created with
<tt>ln source link</tt>
Where <tt>source</tt> is an existing file, and <tt>link</tt> is the file to create. <tt>link</tt> is optional. If it is not given, the filename given in <tt>source</tt> is used. If <tt>link</tt> is an existing directory, it will create the new link there.

===Finding===
Locating a hard link is a bit harder than a symbolic link. In <tt>[[ls]] -l</tt>, the number following the permissions but before the owner is the number of links to that file. For normal files, if that number is greater than 1, then that file is hardlinked somewhere else as well as where you are looking now:
<tt>lrwxrwxrwx 2 username groupname # 2004-03-08 15:55 foo</tt>

You can also find hardlinked files with <tt>[[find]] -type f -links 2</tt>. You will have to repeat the search for 3, 4, etc. number of links.

----
==Symbolic==

Symbolic links are implemented in Linux as an inode containing the "real" location of the file. Symbolic links use a path that can be either absolute (beginning with /) or relative to the location of the link.

Because of their design, a symbolic link can point to any directory or file, or even not point at an existing location (in which case it is called "dangling" or "broken"). A program called <tt>symlinks</tt> was written to make the process of locating and cleaning up broken [[symlink]]s. Unlike a hard link, deleting the original file will cause the file to be erased and the symlinks pointing to it to become dangling.

Symbolic links have no permissions or status of their own. Instead, they use the permissions of the file they point to. The size of a symlink is reported as the length of the path they contain (plus the [[null]] character at the end)

===Creating===
Symbolic Links are created with the <tt>-s</tt> flag to <tt>ln</tt>:
<tt>ln -s content link</tt>
Where <tt>content</tt> is the "text" of the symlink, and <tt>link</tt> is the actual file which will be created. <tt>content</tt> can be any string, even one that does not point to a file (in which case, the symlink will dangle), and it will be used exactly as given. This means that <tt>ln -s sbin/executable bin/executable</tt> will not create a link from bin/executable to sbin/executable, instead, bin/executable will point to bin/sbin/executable.

The <tt>link</tt> is optional. If you do not give a name here, it will assume you want the link to be named the same as the file in <tt>content</tt>. If you provide an existing directory name with no filename, it will create the link in that directory.

===Finding===
Using <tt>[[ls]] -l</tt> to locate symbolic links is easy. They are shown as
<tt>lrwxrwxrwx 1 username groupname # 2004-03-08 15:55 foo -> bar</tt>
This indicates that anytime I access <tt>foo</tt>, I am really accessing the file named <tt>bar</tt>.

Symbolic links can also be located using <tt>[[find]] -type l</tt>.

Symbolic link

2004-03-11T05:55:47Z

Chalupamaster92: I admire the recursiveness of what I'm doing.

#redirect [[symlink]]

Symlinks

2004-03-11T05:52:10Z

Chalupamaster92: May as well save the reader a click

#redirect [[symlink]]

C/C plus plus tips

2004-03-08T03:00:28Z

Chalupamaster92: Fixed link

==Overview==

==Comments: Early and often==

==Debugging==
===Let the Compiler Nitpick===
When compiling with GCC or G++, always use the "-Wall" command-line argument to tell GCC/G++ to print extra warnings and errors. This can often help you locate potential problems in your code. But it's not enough to let the compiler spit the nitpicks at you; you have to take them seriously. Warnings are often a sign that your code is doing something it shouldn't. [Examples?]

===Remote Debugging with DDD and gdb===

1. Make sure gdbsever and libthread_db.so.1 on the remote machine.

2. run gdbserver on target:
gdbserver host:2345 /path/application

The "host" is ignored, so this can be anything. 2345 is an arbitrary TCP
port not in use. 2345 ususally works, just make sure it does not conflict with other IP ports in use.

The target application on the remote machine does not require symbols (debugging information).

3. On the host (your local PC):
a. ddd program (must have symbols)
b. At the (gdb) prompt
target remote xxx.xxx.xxx.xxx:2345

Where the IP address is that of the remote machine.

That's it, remote debugging is up and running.

==Optimization==

Optimizing a program is often more an art than a science. But even in art, there are some rules that should be carefully followed (especially for new practitioners who aren't quite sure why the rules are important).

===Optimization Rule #1 : DON'T!===
You're coding along, minding your own business, when you notice a simple, quick optimization just begging to be done. Maybe it's as simple as replacing <tt>d = c * 2;</tt> with <tt>d = c << 1;</tt>. Why do an expensive multiply when you could do a cheap right-shift and come up with precisely the same result?

Why indeed? This optimization should do the right thing, but at the expense of a tiny bit of program clarity. Program clarity is a precious commodity, which isn't something that can be said for your computer's processor time. It may be that you'll end up making precisely this optimization later on. But right now, the important thing is to get the program working correctly.

===Optimization Rule #2 : DON'T!===
So now the program runs. It runs like a fifteen year old weiner dog. Sometimes it sits down on its haunches, staring off into space as though it's waiting for a doggie treat. So it's time to go in and replace that multiply with the bitshift, right?

Patience, grasshopper.

Before you decide if it's worth investing even one second in optimizing the program, decide how valuable your effort is going to be. The value derived from the effort is directly linked to the purpose of the program. Is it a tiny app you wrote for your own personal use, that you'll only use once a week? Is it part of a critical, high-performance application or library that will be used by millions, or a scientific number-cruncher which will take years to solve a problem? Most likely, it will be somewhere between these two extrema. To some extent, "fast enough" is a subjective judgment.

===Optimization Rule #3 : DON'T!===
Okay, I see you're getting impatient. You want to go in and make that aged dachshund run like a young rotweiler chasing a mailman smothered in barbecue sauce. But the bad news is, it's still not time to replace that line of code. If you go back in and start "optimizing" right now, you may end up with hundreds of little tweaks, whose overall effect is to make the code difficult to understand and impossible to maintain. Even worse, it may not speed your program up noticeably.

Before you make a single change, take advantage of a profiler ([[gprof]] ([http://www.cs.utah.edu/dept/old/texinfo/as/gprof.html tutorial]), for example). A profiler will tell you exactly where your code is spending all its time. The rationale for this is referred to as [http://en.wikipedia.org/wiki/Amdahls_law Amdahl's law] : The amount of time saved by optimizing a section of code cannot be greater than the time the program spent running that code. For example, if a single for loop comprises 7% of a program's running time, then no optimization you could perform on that loop will cause more than a 7% performance increase.

Most programs spend most of their time executing a few very small areas of code. Find out which areas, and you'll likely get huge boosts from small changes.

===Optimization Rule #4 : Never Assume an Optimization Works===
It is important that you know exactly how the unoptimized version of your program was performing, because many optimizations don't do anything. Some "optimizations" will even slow your program.

Part of this is due to the fact that, without being told, the compiler will try to do whatever optimizations it considers "safe", and a programmer's attempts to optimize the code may interfere with the optimizations the compiler is trying to perform. The best thing is to perform one optimization, compare the new performance to the old performance, decide whether to keep it, and then move on to the next potential improvement.

===Optimization Rule #5 : Three Words: Algorithms===
Very frequently, the best way to speed up a program is to change the way you solve the problem. No amount of pointer arithmetic or loop unwinding is going to give you a thousand-fold improvement in runtime, but changing the algorithm frequently does just that. [Need details, specifics]

[That's really 90% of optimization (sans details), but there are also things to cover like pre-caching, just-in-time calculation, optimizing for space vs. optimizing for time, etc.]

===Save Compiler Optimizations for the End===
Also, don't use any -O flags when debugging, it can compound current errors and make things really weird. They can possibly add new bugs too, due to the way the compiler does low-level optimization. The higher the optimization level, the riskier the optimizations that the compiler will attempt.

Once you know the program works in an unoptimized state, then it may be time to crank the -O flag up a couple of notches. Compare both performance and stability between the unoptimized and optimized versions.

==Memory management==
===Valgrind===
Many new programmers have difficulties with pointers and sudden segmentation faults due to careless usage. [http://valgrind.kde.org/ Valgrind] is an excellent program to get more information about what is causing the problems.

===new and malloc: Arch-nemises===
Don't mix malloc and new; they might work togeather temporarily, but they're bound to cause errors. Pick which one from the start and stay with it. Valgrind will also point out this kind of error.

''Note: The same can be said for <iostream> and <iostream.h>. Don't play mix and match.''

==Use Macros With Care==
Macros are simply precompiler directives that instruct the compiler to replace certain strings of text with others before it attempts to compile. If used carelessly, they can make a program terribly confusing.

For example, if you wanted to be intentionally misleading, you could write:

<tt> #define CLOSE_BLOCK {
#define OPEN_BLOCK }
#define CIN cout
#define COUT cin</tt>

and then write the rest of the program as follows:

<tt> for( int i = 0; i < 100; ++i )
CLOSE_BLOCK
for( int j = 0; j < 100; ++j )
CLOSE_BLOCK
CIN << data[ i ][ j ];
OPEN_BLOCK
OPEN_BLOCK</tt>

But intentional obfuscation isn't the real danger. The real problem comes from accidental obfuscation, as in the following example.

===Example: Proving the Meaning of Life===

The meaning of life is elusive. Here is a prime example of why parentheses are needed around macro definitions.

life.c:
----
<tt> #include <stdio.h>

#define SIX 1+5 /* Should be (1+5) */
#define SEVEN 6+1 /* Should be (6+1) */

int main()
{
printf("The meaning of life: %d x %d = %d\n", SIX, SEVEN, SIX * SEVEN);
return 0;
}</tt>
----
Rather than evaluating (1+5) * (6+1) as we would hope, the compiler will now read the statement as 1+(5*6)+1. Result: 32 rather than 42, and thousands of years of time wasted by the galaxy's biggest supercomputer.

C/C plus plus tips

2004-03-08T02:47:38Z

Chalupamaster92: Made some progress with the section on optimization.

==Overview==

==Comments: Early and often==

==Debugging==
===Let the Compiler Nitpick===
When compiling with GCC or G++, always use the "-Wall" command-line argument to tell GCC/G++ to print extra warnings and errors. This can often help you locate potential problems in your code. But it's not enough to let the compiler spit the nitpicks at you; you have to take them seriously. Warnings are often a sign that your code is doing something it shouldn't. [Examples?]

===Remote Debugging with DDD and gdb===

1. Make sure gdbsever and libthread_db.so.1 on the remote machine.

2. run gdbserver on target:
gdbserver host:2345 /path/application

The "host" is ignored, so this can be anything. 2345 is an arbitrary TCP
port not in use. 2345 ususally works, just make sure it does not conflict with other IP ports in use.

The target application on the remote machine does not require symbols (debugging information).

3. On the host (your local PC):
a. ddd program (must have symbols)
b. At the (gdb) prompt
target remote xxx.xxx.xxx.xxx:2345

Where the IP address is that of the remote machine.

That's it, remote debugging is up and running.

==Optimization==

Optimizing a program is often more an art than a science. But even in art, there are some rules that should be carefully followed (especially for new practitioners who aren't quite sure why the rules are important).

===Optimization Rule #1 : DON'T!===
You're coding along, minding your own business, when you notice a simple, quick optimization just begging to be done. Maybe it's as simple as replacing <tt>d = c * 2;</tt> with <tt>d = c << 1;</tt>. Why do an expensive multiply when you could do a cheap right-shift and come up with precisely the same result?

Why indeed? This optimization should do the right thing, but at the expense of a tiny bit of program clarity. Program clarity is a precious commodity, which isn't something that can be said for your computer's processor time. It may be that you'll end up making precisely this optimization later on. But right now, the important thing is to get the program working correctly.

===Optimization Rule #2 : DON'T!===
So now the program runs. It runs like a fifteen year old weiner dog. Sometimes it sits down on its haunches, staring off into space as though it's waiting for a doggie treat. So it's time to go in and replace that multiply with the bitshift, right?

Patience, grasshopper.

Before you decide if it's worth investing even one second in optimizing the program, decide how valuable your effort is going to be. The value derived from the effort is directly linked to the purpose of the program. Is it a tiny app you wrote for your own personal use, that you'll only use once a week? Is it part of a critical, high-performance application or library that will be used by millions, or a scientific number-cruncher which will take years to solve a problem? Most likely, it will be somewhere between these two extrema. To some extent, "fast enough" is a subjective judgment.

===Optimization Rule #3 : DON'T!===
Okay, I see you're getting impatient. You want to go in and make that aged dachshund run like a young rotweiler chasing a mailman smothered in barbecue sauce. But the bad news is, it's still not time to replace that line of code. If you go back in and start "optimizing" right now, you may end up with hundreds of little tweaks, whose overall effect is to make the code difficult to understand and impossible to maintain. Even worse, it may not speed your program up noticeably.

Before you make a single change, take advantage of a profiler ([[gprof]] ([http://www.cs.utah.edu/dept/old/texinfo/as/gprof.html tutorial]), for example). A profiler will tell you exactly where your code is spending all its time. The rationale for this is referred to as [http://en.wikipedia.org/wiki/Amdahl's_law Amdahl's law]: The amount of time saved by optimizing a section of code cannot be greater than the time the program spent running that code. For example, if a single for loop comprises 7% of a program's running time, then no optimization you could perform on that loop will cause more than a 7% performance increase.

Most programs spend most of their time executing a few very small areas of code. Find out which areas, and you'll likely get huge boosts from small changes.

===Optimization Rule #4 : Never Assume an Optimization Works===
It is important that you know exactly how the unoptimized version of your program was performing, because many optimizations don't do anything. Some "optimizations" will even slow your program.

Part of this is due to the fact that, without being told, the compiler will try to do whatever optimizations it considers "safe", and a programmer's attempts to optimize the code may interfere with the optimizations the compiler is trying to perform. The best thing is to perform one optimization, compare the new performance to the old performance, decide whether to keep it, and then move on to the next potential improvement.

===Optimization Rule #5 : Three Words: Algorithms===
Very frequently, the best way to speed up a program is to change the way you solve the problem. No amount of pointer arithmetic or loop unwinding is going to give you a thousand-fold improvement in runtime, but changing the algorithm frequently does just that. [Need details, specifics]

[That's really 90% of optimization (sans details), but there are also things to cover like pre-caching, just-in-time calculation, optimizing for space vs. optimizing for time, etc.]

===Save Compiler Optimizations for the End===
Also, don't use any -O flags when debugging, it can compound current errors and make things really weird. They can possibly add new bugs too, due to the way the compiler does low-level optimization. The higher the optimization level, the riskier the optimizations that the compiler will attempt.

Once you know the program works in an unoptimized state, then it may be time to crank the -O flag up a couple of notches. Compare both performance and stability between the unoptimized and optimized versions.

==Memory management==
===Valgrind===
Many new programmers have difficulties with pointers and sudden segmentation faults due to careless usage. [http://valgrind.kde.org/ Valgrind] is an excellent program to get more information about what is causing the problems.

===new and malloc: Arch-nemises===
Don't mix malloc and new; they might work togeather temporarily, but they're bound to cause errors. Pick which one from the start and stay with it. Valgrind will also point out this kind of error.

''Note: The same can be said for <iostream> and <iostream.h>. Don't play mix and match.''

==Use Macros With Care==
Macros are simply precompiler directives that instruct the compiler to replace certain strings of text with others before it attempts to compile. If used carelessly, they can make a program terribly confusing.

For example, if you wanted to be intentionally misleading, you could write:

<tt> #define CLOSE_BLOCK {
#define OPEN_BLOCK }
#define CIN cout
#define COUT cin</tt>

and then write the rest of the program as follows:

<tt> for( int i = 0; i < 100; ++i )
CLOSE_BLOCK
for( int j = 0; j < 100; ++j )
CLOSE_BLOCK
CIN << data[ i ][ j ];
OPEN_BLOCK
OPEN_BLOCK</tt>

But intentional obfuscation isn't the real danger. The real problem comes from accidental obfuscation, as in the following example.

===Example: Proving the Meaning of Life===

The meaning of life is elusive. Here is a prime example of why parentheses are needed around macro definitions.

life.c:
----
<tt> #include <stdio.h>

#define SIX 1+5 /* Should be (1+5) */
#define SEVEN 6+1 /* Should be (6+1) */

int main()
{
printf("The meaning of life: %d x %d = %d\n", SIX, SEVEN, SIX * SEVEN);
return 0;
}</tt>
----
Rather than evaluating (1+5) * (6+1) as we would hope, the compiler will now read the statement as 1+(5*6)+1. Result: 32 rather than 42, and thousands of years of time wasted by the galaxy's biggest supercomputer.

C/C plus plus tips

2004-03-08T01:54:58Z

Chalupamaster92: Still in progress.

==Overview==

==Comments: Early and often==

==Debugging==
===Let the Compiler Nitpick===
When compiling with GCC or G++, always use the "-Wall" command-line argument to tell GCC/G++ to print extra warnings and errors. This can often help you locate potential problems in your code. But it's not enough to let the compiler spit the nitpicks at you; you have to take them seriously. Warnings are often a sign that your code is doing something it shouldn't. [Examples?]

===Remote Debugging with DDD and gdb===

1. Make sure gdbsever and libthread_db.so.1 on the remote machine.

2. run gdbserver on target:
gdbserver host:2345 /path/application

The "host" is ignored, so this can be anything. 2345 is an arbitrary TCP
port not in use. 2345 ususally works, just make sure it does not conflict with other IP ports in use.

The target application on the remote machine does not require symbols (debugging information).

3. On the host (your local PC):
a. ddd program (must have symbols)
b. At the (gdb) prompt
target remote xxx.xxx.xxx.xxx:2345

Where the IP address is that of the remote machine.

That's it, remote debugging is up and running.

==Optimization==

Optimizing a program is often more an art than a science. But even in art, there are some rules that should be carefully followed (especially for new practitioners who aren't quite sure why the rules are important).

===Optimization Rule #1 : DON'T!===
You're coding along, minding your own business, when you notice a simple, quick optimization just begging to be done. Maybe it's as simple as replacing <tt>d = c * 2;</tt> with <tt>d = c << 1;</t>. Why do an expensive multiply when you could do a cheap right-shift and come up with precisely the same result?

Why indeed? This optimization should do the right thing, but at the expense of a tiny bit of program clarity. Program clarity is a precious commodity, which isn't something that can be said for your computer's processor time. It may be that you'll end up making precisely this optimization later on. But right now, the important thing is to get the program working correctly.

===Optimization Rule #2 : DON'T!===
So now the program runs. It runs like a fifteen year old weiner dog. Sometimes it sits down on its haunches, staring off into space as though it's waiting for a doggie treat. So it's time to go in and replace that multiply with the bitshift, right?

Patience, grasshopper.

Before you decide if it's worth investing even one second in optimizing the program, decide how valuable your effort is going to be. The value derived from the effort is directly linked to the purpose of the program. Is it a tiny app you wrote for your own personal use, that you'll only use once a week? Is it part of a critical, high-performance application or library that will be used by millions, or a scientific number-cruncher which will take years to solve a problem? Most likely, it will be somewhere between these two extrema. To some extent, "fast enough" is a subjective judgment.

===Optimization Rule #3 : DON'T!===
Okay, I see you're getting impatient. You want to go in and make that aged dachshund run like a young rotweiler chasing a mailman smothered in barbecue sauce. But the bad news is, it's still not time to replace that line of code. If you go back in and start "optimizing" right now, you may end up with hundreds of little tweaks, whose overall effect is to make the code difficult to understand and impossible to maintain. Even worse, it may not speed your program up noticeably.

===Save Compiler Optimizations for the End===
Also, don't use any -O flags when debugging, it can compound current errors and make things really weird. They can possibly add new bugs too, due to the way the compiler does low-level optimization. The higher the optimization level, the riskier the optimizations that the compiler will attempt.

Once you know the program works in an unoptimized state, then it may be time to crank the -O flag up a couple of notches. Compare both performance and stability between the unoptimized and optimized versions.

==Memory management==
===Valgrind===
Many new programmers have difficulties with pointers and sudden segmentation faults due to careless usage. [http://valgrind.kde.org/ Valgrind] is an excellent program to get more information about what is causing the problems.

===new and malloc: Arch-nemises===
Don't mix malloc and new; they might work togeather temporarily, but they're bound to cause errors. Pick which one from the start and stay with it. Valgrind will also point out this kind of error.

''Note: The same can be said for <iostream> and <iostream.h>. Don't play mix and match.''

==Use Macros With Care==
Macros are simply precompiler directives that instruct the compiler to replace certain strings of text with others before it attempts to compile. If used carelessly, they can make a program terribly confusing.

For example, if you wanted to be intentionally misleading, you could write:

<tt> #define CLOSE_BLOCK {
#define OPEN_BLOCK }
#define CIN cout
#define COUT cin</tt>

and then write the rest of the program as follows:

<tt> for( int i = 0; i < 100; ++i )
CLOSE_BLOCK
for( int j = 0; j < 100; ++j )
CLOSE_BLOCK
CIN << data[ i ][ j ];
OPEN_BLOCK
OPEN_BLOCK</tt>

But intentional obfuscation isn't the real danger. The real problem comes from accidental obfuscation, as in the following example.

===Example: Proving the Meaning of Life===

The meaning of life is elusive. Here is a prime example of why parentheses are needed around macro definitions.

life.c:
----
<tt> #include <stdio.h>

#define SIX 1+5 /* Should be (1+5) */
#define SEVEN 6+1 /* Should be (6+1) */

int main()
{
printf("The meaning of life: %d x %d = %d\n", SIX, SEVEN, SIX * SEVEN);
return 0;
}</tt>
----
Rather than evaluating (1+5) * (6+1) as we would hope, the compiler will now read the statement as 1+(5*6)+1. Result: 32 rather than 42, and thousands of years of time wasted by the galaxy's biggest supercomputer.

User:Chalupamaster92

2004-03-08T00:56:39Z

Chalupamaster92:

I suppose you wonder why I call myself the master of the chalupa. Frankly, so do I.

The name's Bryce. Comp sci major at the University of Utah. Been toying with Linux on and off since 1999, primarily due to the influence of Slashdot.

I think this is a cool and useful project, and I'd like to contribute.

----

Especially a master of the the chalupa of the 92nd degree. Wow. That's some chalupa-mastery. :)

Nah, the reason I post: I noticed you ask about making indents - check out [[LinuxQuestions.org_Wiki:Wiki_markup|markup help]], and welcome.

[[User:Digiot|Digiot]] 01:57, Mar 7, 2004 (EST)

----

I wish I mastered Chalupa like this guy. The C_plus_plus template looks good - could you add the same for [[C]] and [[Java]]?

[[User:MHouliston|MHouliston]] 18:26, Mar 7, 2004 (EST)
----

Talk:General programming tips

2004-03-08T00:40:42Z

Chalupamaster92:

Call it "General programming overview"?

Still, it's a useful idea.

[[User:Chalupamaster92|Chalupamaster92]] 19:40, Mar 7, 2004 (EST)
----

I created this page to give the seeking visitor something to start with: a language independent philosophy of programming and a feeling for which languages are common, without going into greater detail. Comments?

C/C plus plus tips

2004-03-08T00:22:58Z

Chalupamaster92: Added minor point about iostream

==Overview==

===Debugging===
====Let the Compiler Nitpick====
When compiling with GCC or G++, always use the "-Wall" command-line argument to tell GCC/G++ to print extra warnings and errors. This can often help you locate potential problems in your code.

====Listen to the Nitpicky Compiler====
Warnings are often a sign that your code is doing something it shouldn't.

Also, don't use any -O flags when debugging, it can compound current errors and make things really weird. They can possibly add new bugs too, due to the way the compiler does low-level optimization.

====Remote Debugging with DDD and gdb====

1. Make sure gdbsever and libthread_db.so.1 on the remote machine.

2. run gdbserver on target:
gdbserver host:2345 /path/application

The "host" is ignored, so this can be anything. 2345 is an arbitrary TCP
port not in use. 2345 ususally works, just make sure it does not conflict with other IP ports in use.

The target application on the remote machine does not require symbols (debugging information).

3. On the host (your local PC):
a. ddd program (must have symbols)
b. At the (gdb) prompt
target remote xxx.xxx.xxx.xxx:2345

Where the IP address is that of the remote machine.

That's it, remote debugging is up and running.

===Memory management===
====Valgrind====
Many new programmers have difficulties with pointers and sudden segmentation faults due to careless usage. [http://valgrind.kde.org/ Valgrind] is an excellent program to get more information about what is causing the problems.

====new and malloc: Arch-nemises====
Don't mix malloc and new; they might work togeather temporarily, but they're bound to cause errors. Pick which one from the start and stay with it. Valgrind will also point out this kind of error.

''Note: The same can be said for <iostream> and <iostream.h>. Don't play mix and match.''

===Use Macros With Care===
====Example: Proving the Meaning of Life====

The meaning of life is elusive. Here is a prime example of why parentheses are needed around macro definitions.

life.c:
----
#include <stdio.h>

#define SIX 1+5 /* Should be (1+5) */
#define SEVEN 6+1 /* Should be (6+1) */

int main()
{
printf("The meaning of life: %d x %d = %d\n", SIX, SEVEN, SIX * SEVEN);
return 0;
}
----
Rather than evaluating (1+5) * (6+1) as we would hope, the compiler will now read the statement as 1+(5*6)+1. Result: 32 rather than 42, and thousands of years of time wasted by the galaxy's biggest supercomputer.

C plus plus

2004-03-07T23:20:36Z

Chalupamaster92: Here's an idea for the outline.

'''C++'''

==Introduction==

(Feed me)

==History==

(Feed me)

==Language Features==

(Feed me)

==Further Reading==

===Wiki pages===
*[[C plus plus tutorial|Tutorial]]
*[[C/C plus plus tips|Tips and Tricks]]
*[[C plus plus practices|Good Programming Practices]]
*[[C plus plus tools|Linux C++ tools]]

===Books===
*''The C++ Programming Language'', Bjarne Stroustrup 
*''Effective C++: 50 Specific Ways to Improve Your Programs and Design'', [http://www.aristeia.com/ Scott Meyers] 
*''Code Complete'', Steve McConnell

===External links===

''This article is a [[LinuxQuestions.org_Wiki:stub_articles|stub]] and needs to be finished. [[LinuxQuestions.org_Wiki:plunging_forward|Plunge forward]] and [[LinuxQuestions.org_Wiki:How_to_edit_a_page|help it grow]] !''
 

See also: [[C]], [[C/C_plus_plus tips|C and C++ tips]]

C/C plus plus tips

2004-03-07T19:14:14Z

Chalupamaster92: There's a lot of room to build here.

==Overview==

===Debugging===
====Let the Compiler Nitpick===
When compiling with GCC or G++, always use the "-Wall" command-line argument to tell GCC/G++ to print extra warnings and errors. This can often help you locate potential problems in your code.

====Listen to the Nitpicky Compiler====
Warnings are often a sign that your code is doing something it shouldn't.

Also, don't use any -O flags when debugging, it can compound current errors and make things really weird. They can possibly add new bugs too, due to the way the compiler does low-level optimization.

====Remote Debugging with DDD and gdb====

1. Make sure gdbsever and libthread_db.so.1 on the remote machine.

2. run gdbserver on target:
gdbserver host:2345 /path/application

The "host" is ignored, so this can be anything. 2345 is an arbitrary TCP
port not in use. 2345 ususally works, just make sure it does not conflict with other IP ports in use.

The target application on the remote machine does not require symbols (debugging information).

3. On the host (your local PC):
a. ddd program (must have symbols)
b. At the (gdb) prompt
target remote xxx.xxx.xxx.xxx:2345

Where the IP address is that of the remote machine.

That's it, remote debugging is up and running.

===Memory management===
====Valgrind====
Many new programmers have difficulties with pointers and sudden segmentation faults due to careless usage. [http://valgrind.kde.org/ Valgrind] is an excellent program to get more information about what is causing the problems.

====new and malloc: Arch-nemises====
Don't mix malloc and new; they might work togeather temporarily, but they're bound to cause errors. Pick which one from the start and stay with it. Valgrind will also point out this kind of error.

===Use Macros With Care===
====Example: Proving the Meaning of Life====

The meaning of life is elusive. Here is a prime example of why parentheses are needed around macro definitions.

life.c:
----
#include <stdio.h>

#define SIX 1+5 /* Should be (1+5) */
#define SEVEN 6+1 /* Should be (6+1) */

int main()
{
printf("The meaning of life: %d x %d = %d\n", SIX, SEVEN, SIX * SEVEN);
return 0;
}
----
Rather than evaluating (1+5) * (6+1) as we would hope, the compiler will now read the statement as 1+(5*6)+1. Result: 32 rather than 42, and thousands of years of time wasted by the galaxy's biggest supercomputer.

Email

2004-03-07T18:55:51Z

Chalupamaster92:

#redirect [[e-mail]]

Talk:All commands

2004-03-07T17:21:25Z

Chalupamaster92:

Here's a suggestion for a new format:

[[a commands|A]]
*[[alias]], [[at]], [[anacron]], [[apropos]] ''[[a commands|More]]''

The goal is to make the "most important" commands--the ones that crop up in normal use--quickly accessible. Of course, there will be disagreement over which ones are the most important, but I don't see that being a major problem.

It would also get rid of the somewhat repetitive "Commands beginning with the letter [letter]"

Anyways, that's what I'm going to do. If anyone's really unhappy about it, go ahead and revert.

[[User:Chalupamaster92|Chalupamaster92]] 12:21, Mar 7, 2004 (EST)

----

This is a good collection and nice effort by you but how about also providing the link to the site where you got all this from.

Plus I will be adding links to these commands. Feel free to join in.

[[User:Linuxlala|Linuxlala]]

----

I have broken this page down as each time I wanted to edit, it said that the page is too big, break it down. I also kinda like the way it looks now. Easy accesibility.

Now it would be easy for people to contribute or edit the commands.

[[User:Linuxlala|Linuxlala]]

----

Talk:All commands

2004-03-07T17:10:29Z

Chalupamaster92: Suggestion

Here's a suggestion for a new format:

===[[a commands|A]]===
*[[alias]], [[at]], [[anacron]], [[apropos]] ''[[a commands|More]]''

The goal is to make the "most important" commands--the ones that crop up in normal use--quickly accessible. Of course, there will be disagreement over which ones are the most important, but I don't see that being a major problem.

It would also get rid of the somewhat repetitive "Commands beginning with the letter [letter]"

Anyways, that's what I'm going to do. If anyone's really unhappy about it, go ahead and revert.

[[User:Chalupamaster92|Chalupamaster92]]

----

This is a good collection and nice effort by you but how about also providing the link to the site where you got all this from.

Plus I will be adding links to these commands. Feel free to join in.

[[User:Linuxlala|Linuxlala]]

----

I have broken this page down as each time I wanted to edit, it said that the page is too big, break it down. I also kinda like the way it looks now. Easy accesibility.

Now it would be easy for people to contribute or edit the commands.

[[User:Linuxlala|Linuxlala]]

----

Run Levels

2004-03-07T14:25:00Z

Chalupamaster92:

==What are Run Levels?==

Each of the 6 Run Levels of [[Linux]] is a different "Operating Mode". This means that it has different settings, independent of any other run level, allowing it to run different tasks and applications as required. Each Run Level can be configured to perform different tasks using a [[Configuration File]] in the /etc directory (discussed later). If you are familiar with Microsoft's [[Windows]], it may be helpful to think of the run level system as being similar to the choice between "Safe Mode", "Safe Mode with Networking", "Command Prompt", etc, that you are presented with when the system has shutdown uncleanly - not that [[Linux]] needs to be shutdown uncleanly to change run level.

==What does each Run Level do?==

*Run level 1 provides [[Single User Mode]]
*Run level 2 provides [[Single User Mode]] with [[Networking]] support
*Run level 3 provides [[Multi-User Mode]] with a [[Command Line Interface]], rather than a graphical [[Window Manager]]. This is convenient if you wish to perform menial tasks without the overhead of pretty anti-aliased windows
*Run level 4 has not yet been defined
*Run level 5 provides [[Multi-User Mode]] with a graphical [[Window Manager]]. This is the default run level that is booted on many [[Distributions]] and the one that you are most likely to have for everyday use.
*Run level 6 shuts down the system, closing necessary [[Applications]] and [[Daemons]]. For obvious reasons, this run level should not be used if you want to do anything productive.

==Configuring each Run Level==

(Could someone more familiar with this add it please?)

==How to change Run Level==

To switch between run levels in the terminal you use this command:

<tt>init <Run Level Number></tt>

To switch between run levels using the keyboard (at least in RH9 with Gnome, correct this for any other distros/environments) you use:

<tt>Ctrl+Alt+F<Run Level Number></tt>
For example, to switch to run level 1, you use <tt>Ctrl+Alt+F1</tt>.

BitchX

2004-03-07T08:34:38Z

Chalupamaster92: Very stubby. Not much I can do to save it.

BitchX is a text based [[IRC]] client. Very useful to [[ssh]] into your computer from somewhere random, and get on your favorite irc server.

==External links==
*[http://www.bitchx.org BitchX home page]
*[http://bitchx.org/download.php Downloads]

OpenOffice

2004-03-07T08:16:27Z

Chalupamaster92: Added links to related pages, including pages for individual applications.

'''OpenOffice.org''' is both an open source product and a project. The product is a multi-platform office productivity suite. It combines the key desktop applications--such as a [[OpenOffice_swriter|word processor]], [[OpenOffice_scalc|spreadsheet]], [[OpenOffice_simpress|presentation manager]], [[OpenOffice_sdraw|drawing program]], and [[OpenOffice_sweb|web page design tool]]--with a user interface and feature set similar to other office suites. Sophisticated and flexible, OpenOffice.org also works transparently with a variety of file formats, including those of Microsoft Office.

Available in 25 languages with more being constantly added by the community, OpenOffice.org runs stably and natively on [[Solaris]], [[Common_Questions_and_Misconceptions#Q:_What_is_Linux?|Linux]] (including PPC Linux), and [[Windows]]. Additional ports, such as for [[FreeBSD]], [[IRIX]], and Mac [[OS X]], are in various stages of completion.

Written in C++ and with documented [[API|APIs]] licensed under the [[LGPL]] and [[SISSL]] Open Source licenses, OpenOffice.org allows any knowledgeable developer to benefit from the source. And because the file format for OpenOffice.org is [[XML]], interoperability is easy, making future development and adoption more certain.

[[SUN]] sells a commercial office suite based on OpenOffice.org, called [[StarOffice]]. Students can download it free from [http://wwws.sun.com/software/download/desktop_app.html sun.com].

==Links==
*[http://www.openoffice.org/ The OpenOffice.org homepage]
**[http://download.openoffice.org/index.html Download page]
**[http://support.openoffice.org/index.html Support]

Emacs

2004-03-07T07:54:28Z

Chalupamaster92:

'''Emacs''' is a powerful (some might say too powerful) [[Editor|Text Editor]] created and maintained by the [[GNU]] project. AT it's heart is a [[LISP]] interpretter, allowing it to perform highly complex tasks with a great degree of customization. It supports syntax highlighting, [[CVS]], [[diff]]/[[patch]] and just about anything you could wish to (or not for that matter) write using the built-in LISP extensibility.

*Advantages:
** Hardly anything it can't do ...
** It has many optional modules that serve specialised purposes

*Disadvantages:
** emacs is a huge and complex program
** steep learning curve

Latest stable release, 21.3 was released on March 24, 2003

[http://www.gnu.org/software/emacs/ Emacs' homepage]

Some more emacs links:

ELSE:

[http://www.zipworld.com.au/~peterm/ Emacs Language Sensitive Editor]

Else is very nifty, the base language files need some
customisation, though (mind you, the C ones are great,
C++ needs work, didn't look into the others in detail).

Wiki:

[http://www.emacswiki.org/cgi-bin/wiki/ Emacs-wiki]

Wiki for emacs - usage similar to this one, valuable source of information.

.emacs:

[http://www.dotfiles.com/index.php3?app_id=6 dot-files]

Heaps of nice customised .emacs files :}

==Detailed Pages==
* [[Emacs_keystrokes|Keystrokes]]
* [[Emacs_modes|Modes]]

Emacs keystrokes

2004-03-07T07:53:30Z

Chalupamaster92:

'''Emacs''' works its text-editing wonders through a combination of indirection and Lisp-jitsu. When you type a key--'k', for instance--Emacs doesn't simply paint the character on the screen like a lazier text editor would. Instead, it takes the keystroke and sees what sort of commands are "bound" to it. In the case of 'k', the command it issues is a straightforward "insert me where the cursor is."

At this point, no advantage is apparent. But the commands bound to a keystroke can be arbitrarily complex. For example, when Emacs is running in C [[Emacs_modes|mode]], pressing the <TAB> key doesn't indent everything after the cursor by a single tabspace. Instead, it analyzes the code that you are writing, and indents the entire line to whatever depth appears to make the most sense.

There are many more examples, but the upshot is that if you're willing to learn the Emacs way, there are many tips and tricks to pick up that can make it a very productive environment. Just be warned that, before it's over, you're going to be bending and contorting your fingers in ways you never imagined.

==Basic Keystrokes==

The keystroke <CTRL>+X is generally represented as C-x, while <META>-v would be displayed with the shorthand M-v. The meta key varies from system to system, but is usually the <ALT> key, or sometimes the <ESC> key.

If two commands are separated by a comma (C-p, C-n for example) then they are separate commands. Otherwise they are part of the same command. For example, C-x C-s means you type <CTRL>-x, then <CTRL>-s to execute the command.

===Navigation===

* C-p, C-n, C-f, C-b : Functionally equivalent to the arrow buttons. C-p moves the cursor up one line, C-n moves it down a line, C-f moves one space forward, and C-b moves one space backwards. It may seem silly to have these commands when the arrow keys are right there. But once you're used to them [and they do take some getting used to] you may decide that 'right there' just isn't close enough, and it's nice to be able to navigate without moving your hands away from normal typing position.

* C-a, C-e : C-a moves to the beginning of a line, while C-e moves to the end of the line.

''Note: These keystrokes aren't specific to Emacs. For example, all six work on the command line, and they also work inside forms on the web browser I'm using to type this. You may find it advantageous to try and make them second nature.''

* C-l : Centers your view of the buffer so that the cursor is in the middle of the screen.

* C-v, M-v : Move the cursor up and down by half a page of text at a time.

* M-<, M-> : Moves the cursor to the beginning and end of the entire document.

===Files and Buffers===

* C-x C-s : Saves the current buffer. If there is no file associated with the buffer, Emacs prompts for a filename.

* C-x C-w : Saves the current buffer, requesting a name.

* C-x f : Open a file.

* C-x d : Open a directory.

* C-x b, C-x C-b: The first takes you to another buffer. the second takes you to a list of all available buffers.

* C-x 1, C-x 2, C-x 3 : C-x 2 and 3 split the current window. 2 splits horizontally, while 3 splits vertically. C-x 1 gets rid of the various splits, leaving you with a single window.

* C-g : Gets you out of a minibuffer. A minibuffer is a one-line buffer at the bottom of the screen, where you type in things like filenames and search expressions.

===Cutting and Pasting===

* C-k : Removes the portion of the line following the cursor and places it on the clipboard.

* C-[space] : Sets a "mark".

* C-w : Removes everything between the cursor and the "mark" and places it on the clipboard.

* C-y : Inserts the contents of the clipboard into the buffer.

* M-y : After pressing C-y, use this to gain access to earlier items in the clipboard.

===Help===

* C-h t : This takes you to a tutorial which tries to teach you all this, and a bunch of other stuff besides. It's very helpful for the aspiring Emacs enthusiast.

* M-x doctor : Sometimes you just have to talk out your problems with a sympathetic program.

===Miscellaneous===

* M-/ : Autocompletion. Emacs looks through the buffer for possible completions of whatever you're typing at the moment. For example, if you've typed "rotweiler" at some point previous, and wish to reuse the word, you could type rot'''M-/''' and it will fill in the "weiler". Of course, it may also come up with "rotation" if it sees that word as well. Can be very handy.

Emacs keystrokes

2004-03-07T07:53:07Z

Chalupamaster92: More to be done.

'''Emacs''' tends to work its text-editing wonders through a combination of indirection and Lisp-jitsu. When you type a key--'k', for instance--Emacs doesn't simply paint the character on the screen like a lazier text editor would. Instead, it takes the keystroke and sees what sort of commands are "bound" to it. In the case of 'k', the command it issues is a straightforward "insert me where the cursor is."

At this point, no advantage is apparent. But the commands bound to a keystroke can be arbitrarily complex. For example, when Emacs is running in C [[Emacs_modes|mode]], pressing the <TAB> key doesn't indent everything after the cursor by a single tabspace. Instead, it analyzes the code that you are writing, and indents the entire line to whatever depth appears to make the most sense.

There are many more examples, but the upshot is that if you're willing to learn the Emacs way, there are many tips and tricks to pick up that can make it a very productive environment. Just be warned that, before it's over, you're going to be bending and contorting your fingers in ways you never imagined.

==Basic Keystrokes==

The keystroke <CTRL>+X is generally represented as C-x, while <META>-v would be displayed with the shorthand M-v. The meta key varies from system to system, but is usually the <ALT> key, or sometimes the <ESC> key.

If two commands are separated by a comma (C-p, C-n for example) then they are separate commands. Otherwise they are part of the same command. For example, C-x C-s means you type <CTRL>-x, then <CTRL>-s to execute the command.

===Navigation===

* C-p, C-n, C-f, C-b : Functionally equivalent to the arrow buttons. C-p moves the cursor up one line, C-n moves it down a line, C-f moves one space forward, and C-b moves one space backwards. It may seem silly to have these commands when the arrow keys are right there. But once you're used to them [and they do take some getting used to] you may decide that 'right there' just isn't close enough, and it's nice to be able to navigate without moving your hands away from normal typing position.

* C-a, C-e : C-a moves to the beginning of a line, while C-e moves to the end of the line.

''Note: These keystrokes aren't specific to Emacs. For example, all six work on the command line, and they also work inside forms on the web browser I'm using to type this. You may find it advantageous to try and make them second nature.''

* C-l : Centers your view of the buffer so that the cursor is in the middle of the screen.

* C-v, M-v : Move the cursor up and down by half a page of text at a time.

* M-<, M-> : Moves the cursor to the beginning and end of the entire document.

===Files and Buffers===

* C-x C-s : Saves the current buffer. If there is no file associated with the buffer, Emacs prompts for a filename.

* C-x C-w : Saves the current buffer, requesting a name.

* C-x f : Open a file.

* C-x d : Open a directory.

* C-x b, C-x C-b: The first takes you to another buffer. the second takes you to a list of all available buffers.

* C-x 1, C-x 2, C-x 3 : C-x 2 and 3 split the current window. 2 splits horizontally, while 3 splits vertically. C-x 1 gets rid of the various splits, leaving you with a single window.

* C-g : Gets you out of a minibuffer. A minibuffer is a one-line buffer at the bottom of the screen, where you type in things like filenames and search expressions.

===Cutting and Pasting===

* C-k : Removes the portion of the line following the cursor and places it on the clipboard.

* C-[space] : Sets a "mark".

* C-w : Removes everything between the cursor and the "mark" and places it on the clipboard.

* C-y : Inserts the contents of the clipboard into the buffer.

* M-y : After pressing C-y, use this to gain access to earlier items in the clipboard.

===Help===

* C-h t : This takes you to a tutorial which tries to teach you all this, and a bunch of other stuff besides. It's very helpful for the aspiring Emacs enthusiast.

* M-x doctor : Sometimes you just have to talk out your problems with a sympathetic program.

===Miscellaneous===

* M-/ : Autocompletion. Emacs looks through the buffer for possible completions of whatever you're typing at the moment. For example, if you've typed "rotweiler" at some point previous, and wish to reuse the word, you could type rot'''M-/''' and it will fill in the "weiler". Of course, it may also come up with "rotation" if it sees that word as well. Can be very handy.

Emacs keystrokes

2004-03-07T07:29:01Z

Chalupamaster92: Still a work in progress.

'''Emacs''' tends to work its text-editing wonders through a combination of indirection and Lisp-jitsu. When you type a key--'k', for instance--Emacs doesn't simply paint the character on the screen like a lazier text editor would. Instead, it takes the keystroke and sees what sort of commands are "bound" to it. In the case of 'k', the command it issues is a straightforward "insert me where the cursor is."

At this point, no advantage is apparent. But the commands bound to a keystroke can be arbitrarily complex. For example, when Emacs is running in C [[Emacs_modes|mode]], pressing the <TAB> key doesn't indent everything after the cursor by a single tabspace. Instead, it analyzes the code that you are writing, and indents the entire line to whatever depth appears to make the most sense.

There are many more examples, but the upshot is that if you're willing to learn the Emacs way, there are many tips and tricks to pick up that can make it a very productive environment. Just be warned that, before it's over, you're going to be bending and contorting your fingers in ways you never imagined.

==Basic Keystrokes==

The keystroke <CTRL>+X is generally represented as C-x, while <META>-v would be displayed with the shorthand M-v. The meta key varies from system to system, but is usually the <ALT> key, or sometimes the <ESC> key.

If two commands are separated by a comma (C-p, C-n for example) then they are separate commands. Otherwise they are part of the same command. For example, C-x C-s means you type <CTRL>-x, then <CTRL>-s to execute the command.

===Navigation===

* C-p, C-n, C-f, C-b : Functionally equivalent to the arrow buttons. C-p moves the cursor up one line, C-n moves it down a line, C-f moves one space forward, and C-b moves one space backwards. It may seem silly to have these commands when the arrow keys are right there. But once you're used to them [and they do take some getting used to] you may decide that 'right there' just isn't close enough, and it's nice to be able to navigate without moving your hands away from normal typing position.

* C-a, C-e : C-a moves to the beginning of a line, while C-e moves to the end of the line.

''Note: These keystrokes aren't specific to Emacs. For example, all six work on the command line, and they also work inside forms on the web browser I'm using to type this. You may find it advantageous to try and make them second nature.''

* C-l : Centers your view of the buffer so that the cursor is in the middle of the screen.

* C-v, M-v : Move the cursor up and down by half a page of text at a time.

* M-<, M-> : Moves the cursor to the beginning and end of the entire document.

===Files and Buffers===

* C-x C-s :

* C-x f :

* C-x 1, C-x 2, C-x 3 :

===Miscellaneous===

* M-/ : Autocompletion. Emacs looks through the buffer for possible completions of whatever you're typing at the moment. For example, if you've typed "rotweiler" at some point previous, and wish to reuse the word, you could type rot'''M-/''' and it will fill in the "weiler". Of course, it may also come up with "rotation" if it sees that word as well. Can be very handy.

User:Chalupamaster92

2004-03-07T06:39:28Z

Chalupamaster92:

I suppose you wonder why I call myself the master of the chalupa. Frankly, so do I.

Web browser

2004-03-07T06:32:43Z

Chalupamaster92: Added links to specific browsers. How does one indent?

''This article is a [[LinuxQuestions.org_Wiki:stub_articles|stub]] and needs to be finished. [[LinuxQuestions.org_Wiki:plunging_forward|Plunge forward]] and [[LinuxQuestions.org_Wiki:How_to_edit_a_page|help it grow]] !'' 

A '''web browser''' is essentially an engine that converts markup (primarily [[HTML]]) into a representation according to the rules of the markup. However, browsers must also handle an array of other demands from an increasingly complex web, which is often done with the help of [[plugins]] such as [[Flash Player(s)]].

For some hints on setting up web browsers, look at [[Browsing tasks]].

Links to specific browsers:

[[Galeon]] : a web browser for [[Gnome]]. Based on the [[Gecko]] renderer.

[[Konqueror]] : a web browser for [[KDE]].

[[Lynx]] : text-only web browser for command-line purists.

[[Netscape]] / [[Mozilla]] / [[Firefox]] : A very popular family of browsers.

[[Opera]] : A popular, ad-supported web browser. Adherents say it's the fastest browser around.

[[Emacs]] : No, really. It's true.