The modern computer industry depends on standards. It's how a disk from one computer runs in another (there's a single standard for how they're formatted), or how two computers on the internet can talk to each other even when they're different machines running different software (a single communication protocol). Standards dictate how certain things are to be done. This sounds limiting, but in fact, this gives us more options by ensuring that things will work together. For example, HTML (hypertext mark-up language) is the standard language to format web pages. If everyone sticks to the official HTML standard, then any web browser will work with any web site. And any web-authoring tool that generates standard HTML code can be used to develop any web site. But if (for example) Microsoft added proprietary extensions to the HTML code their web-authoring tools created, extensions which were only supported by Microsoft's web browser, people would need to use Microsoft's browser to properly view those pages. (Which they have done, which is why you see all those "best viewed with Internet Explorer" pages.)
(When referring to "source code", programmers will often say just "source" or "code", because they tend not to be very talkative. It's the same thing.) Behind every program there's source code. The mainstream media may talk about "source codes" for software as if they were talking about secret codes like those for launching nuclear missiles or encrypting spy messages. But source code isn't necessarily about secrets, but about the guts of how a program works. It's a set of type-written instructions explaining step by meticulous step what the program is supposed to do, and how to do it... usually in a standard language like C++ (which is not at all secret, just a bit difficult to read at first). These instructions are translated into machine code (the infamous "ones and zeros" that computers operate on), which is usually how the program is then distributed. The source code is only secret if the developers treat it that way (proprietary), but not if they share it freely (open source).
If something is "proprietary", that simply means that someone owns it, which is usually the case with software. But it usually implies that the owner won't tell anyone else how it works, and tries to prevent other developers from creating software that does the same thing. This becomes a problem when something proprietary becomes a de facto (unofficial) standard. For example, Microsoft Word is so common that people are now passing around Word-format DOC files and expecting other people to be able to open them. But the DOC format is proprietary (and keeps changing), so the developers of other word processors have difficulty enabling their products to do something as simple as opening DOC files. Microsoft is also fond of adopting official standards, but then adding proprietary extensions, which then trap people into using Microsoft's software rather than being able to use any software that supports the true standard. This renders the standard useless. Their slogan for this tactic is "embrace, extend, extinguish". (compare to: open source, public domain, shareware)
OPEN SOURCE and FREE SOFTWARE
Anyone who has the source code to a program can compile it and run it on their computer, or even develop improved versions of it. Companies like Microsoft keep their source code confidential and proprietary to prevent that. But if a program is "open source", that means the source code is available to anyone, usually free of charge. Additionally, "open" usually means that anyone who sees a problem with the program, or wants to add new features to it, is welcome to contribute new code to it. So not only is the software available free of charge, it also benefits from the combined creativity, programming expertise, and testing of many volunteer programmers. The Linux, GNU, and BSD Unix operating systems are built entirely out of open-source components. Application programs such as the Apache web server, MySQL database, Mozilla web browser, and OpenOffice.org suite are other examples. The term "free software" (coined many years ago by the Free Software Foundation) refers to the same kind of software. "Free software" is much more poetic and to-the-point, but because it's so easily confused (at least in English) with freeware, I refer to all software of this kind as "open source" instead. (There are some philosophical and legal differences between "open source" and "free software", but the common principle is that freedom and openness make better software. Which is demonstrably true.) (also compare to: shareware, public domain)
Shareware is a method of distributing and selling software, invented simultaneously by Jim "Button" Knopf and Andrew Flugelman in the early 1980's, when the microcomputer industry was emerging from its infancy. Rather than paying up front to package and distribute their software, and then asking you to pay up front for software that might not suit your needs, shareware developers let you try the software first, and encourage you to pass the software on to anyone else who's interested... both problems solved. If you like it, you're expected to pay for it (usually not very much), otherwise just delete it and forget about it. Some shareware requires payment and registration to enable some of the advanced features, or to keep the program running after a set trial period. Other shareware developers do it purely on the honour system. A few don't even ask for payment (but unlike open-source software, they don't give you the source code to modify); another term for that kind of shareware is freeware.
Freeware is shareware for which the developer doesn't ask any money. It's different from public domain software because the developer still puts restrictions on what can be done with it (usually that you can't modify it, sell it for profit, or claim it as your own). It's different from open-source software (also referred to as "free software") because the source code is kept proprietary. In other words, it's "free" only in the sense of "free beer" (i.e. you don't have to pay for it), rather than the grander sense of "free speech" (i.e. no restrictions on it). While free(beer) software is nice, free(speech) software is much nicer. Other languages provide distinct words for these two concepts. For example, in French, free(speech) is called "libre" and free(beer) is "gratis".
Almost all software is covered by copyright: whoever wrote it has the legal (and moral) right to control when/where/how the software is copied. A very small amount of software is instead in the public domain. This means that the person who wrote it has completely renounced his copyright, and put absolutely no restrictions whatsoever on the program. You might even be able to sell it as if it were your own work. Sometimes either freeware or open-source software is mistakenly referred to as "public domain", but the developer of a freeware program still owns the copyright: he can restrict people from claiming the program as their own, from selling the program for profit, from modifying the program and redistributing it, etc. Some people assume that old software that's no longer being developed falls into the public domain, but this is also incorrect. That's because copyright automatically lasts for several decades, regardless of whether anybody is actively trying to protect it. Maybe no one will actually object if you give out copies of VisiCalc (the first spreadsheet program), but somebody owns the copyright, and they could legally stop you from doing it. (update: I recently discovered that this example was more real than I imagined. Lotus Corp. bought up VisiCalc after their 1-2-3 surpassed it in the marketplace, but they've authorised VisiCalc co-creator Dan Bricklin to give away copies of the original program for DOS as an historical curiosity.)
Cross-platform programs (sometimes called "portable") are available in versions that can run on two or more different operating systems. This takes a combination of advance planning and additional resources from the developer (not as much as it used to, though), but it lets them sell their product to more people. And it's better for the consumer because it means they can use the same program on (for example) their Mac at home, and their PC with Windows at the office. Or develop a web site with cross-platform tools without having to worry about whether the server it ends up on runs Linux, Windows, BSD, etc. Because Microsoft produces both an operating system and application programs, they have a bias against cross-platform development (preferring to steer everyone to Windows), and do only as much of it as they need to maintain good relations with the public, important companies, and the government.
Unix is a family of operating systems. It can be adapted to run on almost any sort of computer hardware (unlike Windows, which is limited to the Intel x86 CPU architecture). It was originally developed as a side project at AT&T's Bell Labs in 1969, and became popular at educational institutions, where it was widely used, studied, and enhanced. UC-Berkeley developed a variety known as the "BSD" version, which is the basis of the open-source FreeBSD, OpenBSD, and NetBSD Unixes, and Apple's OS X. After the AT&T break-up put Unix on the commercial market, a variety of competing - and not quite compatible - versions developed, generally for big, proprietary, expensive hardware. (For trademark reasons, most of them used to have names other than "Unix", such as "Ultrix" and "Xenix"). Today most of them adhere to the standards of the X/Open group (which now owns the "Unix®" trademark) so that programs written for one of them will run on another without too much difficulty. These include Sun Solaris, Hewlett Packard HP-UX, IBM AIX, SGI IRIX, and Caldera OpenUnix. (If I ran the world, Windows would be handled the same way, with competing - but compatible - versions from a variety of sources.)
Not all of the operating systems people think of as "Unix" necessarily are Unix. And on the flip side, some systems people don't think of as "Unix" are in fact very similar. For example, the various BSD systems and Mac OS X are based on the original Unix code from Bell Labs, so by that standard they're often considered "Unix systems". But they aren't part of the X/Open group that now sets the standards for Unix, so they aren't officially "UNIX® systems". Some other operating systems (e.g. GNU, Linux, Minix, QNX) were written independently to be replacements or copies of Unix. They're based on the design of Unix and generally behave like Unix, but they don't use any of the original Unix source code, and aren't part of X/Open. Because programs written for "real" Unix systems can usually be adapted to run on these clones (and vice versa), they are often referred to collectively as "unixes", or (using a traditional pattern-matching expression for their various names) as "*n*x". I refer to them here as "Unix-like systems".
PRONUNCIATION OF LINUX
Not everybody pronounces "Linux" the same way. The confusion comes because the name is derived from two different linguistic backgrounds and is used by speakers of dozens of additional languages. Furthermore, most people's first exposures to it are in print rather than spoken aloud. The name is an amalgam of "Unix" and the first name of Linus Torvalds, who created the Linux kernel. Torvalds - who was raised in Finland, but speaks Swedish natively - pronounces his name "LEEnus", and the operating system (roughly) "LEEnux". In English-speaking countries, "Linus" is usually pronounced "LIEnus" (with a long "i"), and thus some people assume the operating system is called "LIEnux". However, the most widely-accepted pronunciation among Linux users is "LIHnux" (short "i"), which approximates Torvalds' own but with an American accent.
The kernel is the core of an operating system. It is the software that controls access to the system's memory and storage, and manages the various processes that are running at any given time. It's usually possible to load additional device drivers to access devices not supported by the kernel. The user interface (e.g. windows, command line, etc.) is considered part of the operating system, but is not part of the kernel. (Windows users may have seen "KERNEL32.DLL" referred to in error messages; that's the Windows kernel flaking out.)
The operating system of a computer ("OS" for short) is the software that makes it possible for all the other software (like word processors and e-mail programs) to run on that computer. It provides an interface for the user of the computer to tell the computer what programs to run and what to do with those programs. (That's usually done with a mouse and a keyboard.) The operating system also provides services to these programs. For example, it gives a web browser access to communication devices so it can read web pages, and it gives a word processor access to storage devices so it can save documents (the first operating systems to offer access to disks were referred to as a Disk OS: a "DOS" for short). Although a well-designed cross-platform program can be adapted to work on differing operating systems, there are always changes that have to be made for each OS, so a program packaged for one can't run on another. Likewise, operating systems have to be designed to work with a certain set of hardware as well, which is why you can't load the Mac OS on a PC. But the hardware available tends to fall into a handful of common platforms, so OS developers can sometimes produce versions for two or more platforms, especially if the OS was designed with that in mind (like Unix was).
HACKER vs. CRACKER
I am a hacker. Contrary to the way the news media misuse the term, a "hacker" isn't necessarily a bad person. What they're referring to are really "crackers", which are something quite different. Most hackers are generally pretty ethical, though they may not have a lot of respect for arbitrary rules and restrictions for their own sake. As the term was originally used, a hacker is a creative expert, someone who knows his subject matter inside and out and can use that knowledge very effectively, usually just for the sheer enjoyment of the process, and certainly not maliciously. Someone who knows enough about Intel x86 CPUs to "hack out" a complete machine code program to perform long division using Roman numerals is a hacker. Someone who can turn a pile of old computer parts and free software into a e-mail/web server is a hacker. And someone who knows enough about protocols and vulnerabilities to devise a way to break into a computer is also a hacker. When a hacker uses his skills like that to break things or break into something for nefarious purposes, he becomes a "cracker". Those are the people you should spit at, not hackers in general. (And to make matters worse, these days you don't even need to be a hacker to be a cracker. There are "script kiddies" who just download other people's system-cracking programs and use them without even understanding - or caring - how they work, like a toddler pulling the trigger on a gun he found. While I might have a grudging respect for the skills of an ingenious hacker-cracker, these point-and-shoot crackers are just a bunch of lusers.)
The first public release of a new piece of software is traditionally labeled "version 1.0". Updates that fix bugs in the software (fixing things that were supposed to work, but didn't) increment the "hundredths" place (e.g. version 1.01). When minor features are added, the "tenths" place after the decimal gets incremented (e.g. version 1.1). The "ones" digit gets incremented only when there's a major upgrade of the program. Not all developers follow this model, but most do. They are often overruled by Marketing, who may replace version numbers with something else (e.g. MS Office 2000 and MS Office XP, which are really MS Office 9.0 and 10.0, respectively) or even arbitrarily change the version number (e.g. Access 3.0 was renumbered to 7.0 so it would match Word 7.0 and Excel 7.0)
The quality of commercial "1.0" releases has always been a bit... variable. Before releasing a product, developers start with "alpha testing" (in which they give the software to their co-workers and ask them to report the various problems they find), then moving on to "beta testing" (which usually involves a select group of customers who agree to run the software through its paces with the understanding that they're working with a not-quite-finished product). But 1.0 releases are sometimes disparagingly referred to as "gamma test" software (which means the developers are letting all of their customers do the work of identifying the remaining bugs), and cautious customers (often wisely) avoid them like the plague. The term "delta testing" is occasionally used in reference to software like Microsoft Windows, which seems to be in a perpetual test-and-fix phase.
Open-source software is released under a somewhat different model. The whole development process is open to the public, so anyone who's interested and willing can be involved in testing, even earlier in the process than traditional alpha testing. You can help write the code, if you want. Version numbers less than 1.0 are often used for this phase; the farther the number is from 1.0, the more work it needs before its developers consider it "1.0-ready". But by the time the software is ready for beta-level testing (version numbers around 0.9 or above), a large population of testers may already be in place and these "open betas" fix a lot more bugs than the traditional "closed betas" of commercial software. So when an open-source project reaches version 1.0, that really does mean that it's ready for public release. There will still be bugs, and a flurry of 1.01, 1.02, 1.03... will usually follow in pretty short order as more people start using it, but the conventional wariness about "1.0" isn't nearly as necessary with open-source software as it is with proprietary wares.
Object-oriented programming (sometimes abbreviated as OOP) is an approach that ties both data and procedures together in bundles. For example, an object might contain a list of names as well as instructions for how to print that list, how to add another name to the list, etc. This can make it easier to reuse that list in another program, because you don't need to rewrite the code for performing these functions; just drop the object into your new program and use it. This approach was pioneered with the language SmallTalk, and has become popular in recent years. As a result, object-oriented features have been added to many existing languages (e.g. C++, Delphi, O'Caml), and several newer languages have been created with object capabilities, either as one method they support (e.g. Java), or the only one (e.g. Pike, Ruby).
Describing a language as "funcational" isn't a reference to the fact that "it works". It means... (compare to: logical, procedural)
(compare to: logical, procedural)
Most programming languages are procedural. They consist of a list of instructions for the computer to execute in order, switching to different parts of the list depending on certain conditions. This is fundamentally the way computers operate, so it's a natural approach to take in programming them, and keeps it fairly easy to translate the written instrucitons into machine instructions. (compare to: logical, functional)
(compare to: procedural, functional)
(compare to: procedural, functional)
COMPILED vs. INTERPRETTED
Programs written in many languages have to be fully compiled from their original form into machine code before they can be started. This has two major advantages: 1) the program can be checked for fundamental errors (e.g. mistyping a command, failing to put and "end" statement on a procedure) before trying to run it, and 2) it allows the program to run much faster. The major disadvantages are that 1) the programmer has to go through that whole (often time-consuming) compilation process to test even a small change, and 2) a compiled program can only run on the kind of machine it was compiled for, one that uses that particular machine code. So the alternative is for a language to be interpretted, with the written instructions being translated into machine code as they are executed. Most languages for large application development are compiled (e.g. C++, Delphi, Fortran, COBOL), and most languages intended for smaller scripting projects are interpretted (e.g. Perl, Python, TCL), though there are exceptions. Some languages can be used either way, using an interpretter for development and testing, but compiling the final version. A few do partial compilation, translating the written instructions into a more machine-like "metacode" to gain some speed, but interpretting the metacode to facilitate portability between machine types. (e.g. Java)
This verb doesn't have a specific meaning related to computing, though it does seem to apply to a lot of computer jargon. It means "to deliberately make something unclear or difficult to understand, by making use of unfamiliar terminology". The thing I love about this term is that it's self-referential: the term itself is obfuscatory.
All logos and product names are trademarks of their respective developers or distributors.
This site is in no way affiliated with Microsoft Corporation. ach-ptui!
© 1999-2008, Rzero.