It was written in high level language rather than assembly language (which had been thought necessary for

systems implementation on early computers). Although this followed the lead of Multics and Burroughs, it
was Unix that popularized the idea.

Unix had a drastically simplified file model compared to many contemporary operating systems, treating
all kinds of files as simple byte arrays. The file system hierarchy contained machine services and devices
(such as printers, terminals, or disk drives), providing a uniform interface, but at the expense of
occasionally requiring additional mechanisms such as ioctl and mode flags to access features of the
hardware that did not fit the simple "stream of bytes" model. The Plan 9 operating system pushed this
model even further and eliminated the need for additional mechanisms.

Unix also popularized the hierarchical file system with arbitrarily nested subdirectories, originally
introduced by Multics. Other common operating systems of the era had ways to divide a storage device
into multiple directories or sections, but they had a fixed number of levels, often only one level. Several
major proprietary operating systems eventually added recursive subdirectory capabilities also patterned
after Multics. DEC's RSX-11M's "group, user" hierarchy evolved into VMS directories, CP/M's volumes
evolved into MS-DOS 2.0+ subdirectories, and HP's MPE group.account hierarchy and IBM's SSP and
OS/400 library systems were folded into broader POSIX file systems.

Making the command interpreter an ordinary user-level program, with additional commands provided as
separate programs, was another Multics innovation popularized by Unix. The Unix shell used the same
language for interactive commands as for scripting (shell scripts – there was no separate job control
language like IBM's JCL). Since the shell and OS commands were "just another program", the user could
choose (or even write) his own shell. New commands could be added without changing the shell itself.
Unix's innovative command-line syntax for creating modular chains of producer-consumer processes
(pipelines) made a powerful programming paradigm (coroutines) widely available. Many later command-
line interpreters have been inspired by the Unix shell.

A fundamental simplifying assumption of Unix was its focus on ASCII text for nearly all file formats.
There were no "binary" editors in the original version of Unix – the entire system was configured using
textual shell command scripts. The common denominator in the I/O system was the byte – unlike "record-
based" file systems. The focus on text for representing nearly everything made Unix pipes especially
useful, and encouraged the development of simple, general tools that could be easily combined to perform
more complicated ad hoc tasks. The focus on text and bytes made the system far more scalable and
portable than other systems. Over time, text-based applications have also proven popular in application
areas, such as printing languages (PostScript, ODF), and at the application layer of the Internet protocols,
e.g., FTP, SMTP, HTTP, SOAP and SIP.

Unix popularized a syntax for regular expressions that found widespread use. The Unix programming
interface became the basis for a widely implemented operating system interface standard (POSIX, see
above).

The C programming language soon spread beyond Unix, and is now ubiquitous in systems and
applications programming.

Early Unix developers were important in bringing the concepts of modularity and reusability into software
engineering practice, spawning a "software tools" movement.

Unix provided the TCP/IP networking protocol on relatively inexpensive computers, which contributed to
the Internet explosion of worldwide real-time connectivity, and which formed the basis for
implementations on many other platforms. This also exposed numerous security holes in the networking
implementations.

The Unix policy of extensive on-line documentation and (for many years) ready access to all system
source code raised programmer expectations, and contributed to the 1983 launch of the free software
movement.

Over time, the leading developers of Unix (and programs that ran on it) established a set of cultural norms
for developing software, norms which became as important and influential as the technology of Unix
itself; this has been termed the Unix philosophy.

VAX versions
A VAX computer was installed at Berkeley in 1978, but the port of Unix to the VAX architecture,
UNIX/32V, did not take advantage of the VAX's virtual memory capabilities. The kernel of 32V was
largely rewritten by Berkeley students to include a virtual memory implementation, and a complete
operating system including the new kernel, ports of the 2BSD utilities to the VAX, and the utilities from
32V was released as 3BSD at the end of 1979. 3BSD was also alternatively called Virtual VAX/UNIX or
VMUNIX (for Virtual Memory Unix), and BSD kernel images were normally called /vmunix until
4.4BSD.

The success of 3BSD was a major factor in the Defense Advanced Research Projects Agency's (DARPA)
decision to fund Berkeley's Computer Systems Research Group (CSRG), which would develop a standard
Unix platform for future DARPA research in the VLSI Project. CSRG released 4BSD, containing
numerous improvements to the 3BSD system, in October 1980.

4BSD (November 1980) offered a number of enhancements over 3BSD, notably job control in the
previously released csh, delivermail (the antecedent of sendmail), "reliable" signals, and the Curses
programming library.

4.1BSD (June 1981) was a response to criticisms of BSD's performance relative to the dominant VAX
operating system, VMS. The 4.1BSD kernel was systematically tuned up by Bill Joy until it could perform
as well as VMS on several benchmarks. (The release would have been called 5BSD, but after objections
from AT&T the name was changed; AT&T feared confusion with AT&T's UNIX System V.[4] One early,
never-released test version was in fact called 4.5BSD.[citation needed])

4.2BSD would take over two years to implement and contained several major overhauls. Before its official
release came three intermediate versions: 4.1a incorporated a modified version of BBN's preliminary
TCP/IP implementation; 4.1b included the new Berkeley Fast File System, implemented by Marshall Kirk
McKusick; and 4.1c was an interim release during the last few months of 4.2BSD's development.
To guide the design of 4.2BSD Duane Adams of DARPA formed a "steering committee" consisting of
Bob Fabry, Bill Joy and Sam Leffler from UCB, Alan Nemeth and Rob Gurwitz from BBN, Dennis
Ritchie from Bell Labs, Keith Lantz from Stanford, Rick Rashid from Carnegie-Mellon, Bert Halstead
from MIT, Dan Lynch from ISI, and Gerald J. Popek of UCLA. The committee met from April 1981 to
June 1983.

The official 4.2BSD release came in August 1983. It was notable as the first version released after the
1982 departure of Bill Joy to co-found Sun Microsystems; Mike Karels and Marshall Kirk McKusick took
on leadership roles within the project from that point forward. On a lighter note, it also marked the debut
of BSD's daemon mascot in a drawing by John Lasseter that appeared on the cover of the printed manuals
distributed by USENIX.

[edit] 4.3BSD

4.3BSD was released in June 1986. Its main changes were to improve the performance of many of the new
contributions of 4.2BSD that had not been as heavily tuned as the 4.1BSD code. Prior to the release,
BSD's implementation of TCP/IP had diverged considerably from BBN's official implementation. After
several months of testing, DARPA determined that the 4.2BSD version was superior and would remain in
4.3BSD. (See also History of the Internet.)

After 4.3BSD, it was determined that BSD would move away from the aging VAX platform. The Power
6/32 platform (codenamed "Tahoe") developed by Computer Consoles Inc. seemed promising at the time,
but was abandoned by its developers shortly thereafter. Nonetheless, the 4.3BSD-Tahoe port (June 1988)
proved valuable, as it led to a separation of machine-dependent and machine-independent code in BSD
which would improve the system's future portability.

Apart from portability, the CSRG worked on an implementation of the OSI network protocol stack,
improvements to the kernel virtual memory system and (with Van Jacobson of LBL) new TCP/IP
algorithms to accommodate the growth of the internet.[5]

Until then, all versions of BSD incorporated proprietary AT&T Unix code and were, therefore, subject to
an AT&T software license. Source code licenses had become very expensive and several outside parties
had expressed interest in a separate release of the networking code, which had been developed entirely
outside AT&T and would not be subject to the licensing requirement. This led to Networking Release 1
(Net/1), which was made available to non-licensees of AT&T code and was freely redistributable under
the terms of the BSD license. It was released in June 1989.

4.3BSD-Reno came in early 1990. It was an interim release during the early development of 4.4BSD, and
its use was considered a "gamble", hence the naming after the gambling center of Reno, Nevada. This
release was explicitly moving towards POSIX compliance,[5] and, according to some, away from the BSD
philosophy (as POSIX is very much based on System V, and Reno was quite bloated compared to
previous releases). Among the new features was an NFS implementation from the University of Guelph.

In August 2006, Information Week magazine rated 4.3BSD as the "Greatest Software Ever Written".[6]
They commented: "BSD 4.3 represents the single biggest theoretical undergirder of the Internet."

[edit] Net/2 and legal troubles

After Net/1, BSD developer Keith Bostic proposed that more non-AT&T sections of the BSD system be
released under the same license as Net/1. To this end, he started a project to reimplement most of the
standard Unix utilities without using the AT&T code. For example, vi, which had been based on the
original Unix version of ed, was rewritten as nvi (new vi). Within eighteen months, all the AT&T utilities
had been replaced, and it was determined that only a few AT&T files remained in the kernel. These files
were removed, and the result was the June 1991 release of Networking Release 2 (Net/2), a nearly
complete operating system that was freely distributable.

Net/2 was the basis for two separate ports of BSD to the Intel 80386 architecture: the free 386BSD by
William Jolitz and the proprietary BSD/386 (later renamed BSD/OS) by Berkeley Software Design
(BSDi). 386BSD itself was short-lived, but became the initial code base of the NetBSD and FreeBSD
projects that were started shortly thereafter.

BSDi soon found itself in legal trouble with AT&T's Unix System Laboratories (USL) subsidiary, then the
owners of the System V copyright and the Unix trademark. The USL v. BSDi lawsuit was filed in 1992
and led to an injunction on the distribution of Net/2 until the validity of USL's copyright claims on the
source could be determined.

The lawsuit slowed development of the free-software descendants of BSD for nearly two years while their
legal status was in question, and as a result systems based on the Linux kernel, which did not have such
legal ambiguity, gained greater support. Although not released until 1992, development of 386BSD
predated that of Linux. Linus Torvalds has said that if 386BSD had been available at the time, he probably
would not have created Linux.[7]

[edit] 4.4BSD and descendants

See also: Comparison of BSD operating systems

The lawsuit was settled in January 1994, largely in Berkeley's favor. Of the 18,000 files in the Berkeley
distribution, only three had to be removed and 70 modified to show USL copyright notices. A further
condition of the settlement was that USL would not file further lawsuits against users and distributors of
the Berkeley-owned code in the upcoming 4.4BSD release.

In June 1994, 4.4BSD was released in two forms: the freely distributable 4.4BSD-Lite contained no
AT&T source, whereas 4.4BSD-Encumbered was available, as earlier releases had been, only to AT&T
licensees.

The final release from Berkeley was 1995's 4.4BSD-Lite Release 2, after which the CSRG was dissolved
and development of BSD at Berkeley ceased. Since then, several variants based directly or indirectly on
4.4BSD-Lite (such as FreeBSD, NetBSD, OpenBSD and DragonFly BSD) have been maintained.

In addition, the permissive nature of the BSD license has allowed many other operating systems, both free
and proprietary, to incorporate BSD code. For example, Microsoft Windows has used BSD-derived code
in its implementation of TCP/IP and bundles recompiled versions of BSD's command-line networking
tools with Windows 2000.[8] Also Darwin, the system on which Apple's Mac OS X is built, is a derivative
of 4.4BSD-Lite2 and FreeBSD. Various commercial UNIX operating systems, such as Solaris, also
contain varying amounts of BSD code.
ADVANTAGES OF BSD:-This final consideration may often be the dominant one, as it was when the
Apache project decided upon its license:

“This type of license is ideal for promoting the use of a reference body of code that implements a protocol
for common service. This is another reason why we choose it for the Apache group - many of us wanted to
see HTTP survive and become a true multiparty standard, and would not have minded in the slightest if
Microsoft or Netscape choose to incorporate our HTTP engine or any other component of our code into
their products, if it helped further the goal of keeping HTTP common... All this means that, strategically
speaking, the project needs to maintain sufficient momentum, and that participants realize greater value by
contributing their code to the project, even code that would have had value if kept proprietary.”

Developers tend to find the BSD license attractive as it keeps legal issues out of the way and lets them do
whatever they want with the code. In contrast, those who expect primarily to use a system rather than
program it, or expect others to evolve the code, or who do not expect to make a living from their work
associated with the system (such as government employees), find the GPL attractive, because it forces
code developed by others to be given to them and keeps their employer from retaining copyright and thus
potentially "burying" or orphaning the software. If you want to force your competitors to help you, the
GPL is attractive.

A BSD license is not simply a gift. The question “why should we help our competitors or let them steal
our work?” comes up often in relation to a BSD license. Under a BSD license, if one company came to
dominate a product niche that others considered strategic, the other companies can, with minimal effort,
form a mini-consortium aimed at reestablishing parity by contributing to a competitive BSD variant that
increases market competition and fairness. This permits each company to believe that it will be able to
profit from some advantage it can provide, while also contributing to economic flexibility and efficiency.
The more rapidly and easily the cooperating members can do this, the more successful they will be. A
BSD license is essentially a minimally complicated license that enables such behavior.

A key effect of the GPL, making a complete and competitive Open Source system widely available at cost
of media, is a reasonable goal. A BSD style license, in conjunction with ad-hoc-consortiums of
individuals, can achieve this goal without destroying the economic assumptions built around the
deployment-end of the technology transfer pipeline.

-------------------------------------------------------------------------------------------------------------------------------

Mac OSX:-The most visible change was the Aqua theme. The use of soft edges, translucent colors, and
pinstripes – similar to the hardware design of the first iMacs – brought more texture and color to the user
interface when compared to what OS 9 and OS X Server 1.0's "Platinum" appearance had offered.
According to John Siracusa, an editor of Ars Technica, the introduction of Aqua and its departure from the
then conventional look "hit like a ton of bricks."[25] Bruce Tognazzini (who founded the original Apple
Human Interface Group) said that the Aqua interface in Mac OS X v10.0 represented a step backwards in
usability compared with the original Mac OS interface.[26][27] Third-party developers started producing
skins for customizable applications and other operating systems which mimicked the Aqua appearance. To
some extent, Apple has used the successful transition to this new design as leverage, at various times
threatening legal action against people who make or distribute software with an interface the company
claims is derived from its copyrighted design.[28]
Mac OS X architecture implements a layered design.[29] The layered frameworks aid rapid development of
applications by providing existing code for common tasks.

Mac OS X includes its own software development tools, most prominently an integrated development
environment called Xcode. Xcode provides interfaces to compilers that support several programming
languages including C, C++, Objective-C, and Java. For the Apple–Intel transition, it was modified so that
developers could build their applications as a universal binary, which provides compatibility with both the
Intel-based and PowerPC-based Macintosh lines.[30]

The Darwin sub-system in Mac OS X is in charge of managing the filesystem, which includes the Unix
permissions layer. In 2003 and 2005, two Macworld editors expressed criticism of the permission scheme;
Ted Landau called misconfigured permissions "the most common frustration" in Mac OS X,[31] while Rob
Griffiths suggested that some users may even have to reset permissions every day, a process which can
take up to 15 minutes.[32] More recently, another Macworld editor, Dan Frakes, called the procedure of
repairing permissions vastly overused.[33] He argues that Mac OS X typically handles permissions properly
without user interference, and resetting permissions should just be tried when problems emerge.[34]

As of September 2010, Mac OS X is the second most active general-purpose client operating system in
use on the World Wide Web, after Microsoft Windows, with an 8.3% usage share according to statistics
compiled by W3Counter.[35] It is the most successful Unix-like desktop operating system on the web,
estimated at over 5 times the usage of Linux (which has 1.5%).[35] See also Usage share of operating
systems. Eighteen languages are available as the "base" language (that which is used for sub-user
environments, such as the user login screen) at the first screen of the installation DVD. All of the eighteen
user languages for the system menus, messages, and other functions are installed by default and can be
chosen from the System Preferences. As of Mac OS X Snow Leopard, the languages are English,
Japanese, French, German, Spanish, Italian, Dutch, Swedish, Danish, Norwegian, Finnish, Traditional
Chinese, Simplified Chinese, Korean, Brazilian Portuguese, European Portuguese, Russian, and Polish.
Input methods for typing in dozens of scripts can be chosen independently of the system language.[36]

Windows NT is a family of operating systems produced by Microsoft, the first version of which was
released in July 1993. It was a powerful high-level-language-based, processor-independent,
multiprocessing, multiuser operating system with features comparable to Unix. It was intended to
complement consumer versions of Windows that were based on MS-DOS. NT was the first fully 32-bit
version of Windows, whereas its consumer-oriented counterparts, Windows 3.1x and Windows 9x, were
16-bit/32-bit hybrids. Windows 2000, Windows XP, Windows Server 2003, Windows Vista, Windows
Home Server, Windows Server 2008, and Windows 7 are effectively Windows NT, although they are not
branded using that name.
DISADVANTAGES

1.
o Windows CE is a embedded operating system from Microsoft that is used in handheld
computers, smart phones and industrial devices. Windows CE is made for devices that have
minimal memory. It is a real-time operating system, which is important in industrial
settings. Certain portions of Windows CE source code are offered so that the operating
system may be adapted to specialized purposes. Windows CE is not without its
disadvantages, however.

Source Code
o Microsoft offers developers part of the Windows CE source code, as well as development
tools for modifying the operating system to specific purposes. Windows CE is still
considered a completely closed system, however. This can be a large disadvantage if the
level of customization goes far beyond what is offered within the development package.
Linux is a popular choice for an alternative if this situation occurs.

Pricing
o Windows CE is expensive compared to other embedded system options. Its development
tools package is $995, and run-time licenses are $3 per core and $16 per professional.
Developing an in-house embedded operating system could be less expensive than Windows
CE, depending on production levels of the devices that the operating system will be used
on.

System Limitations
o The Windows CE platform offers significant restrictions when it comes to process limits
and memory. There is a 32 concurrent process limit. There is also a 32 MB virtual space
limit per application. This only applies to Windows CE 5.0 and earlier; Windows CE 6.0
no longer has these limitations.

Read more: The Disadvantages of Windows CE | eHow.com

http://www.ehow.com/list_6370560_disadvantages-windows-ce.html#ixzz1OBzgme2g
Components
See also: List of Unix programs

The Unix system is composed of several components that are normally packed together. By including – in
addition to the kernel of an operating system – the development environment, libraries, documents, and
the portable, modifiable source-code for all of these components, Unix was a self-contained software
system. This was one of the key reasons it emerged as an important teaching and learning tool and has had
such a broad influence.

The inclusion of these components did not make the system large – the original V7 UNIX distribution,
consisting of copies of all of the compiled binaries plus all of the source code and documentation occupied
less than 10MB, and arrived on a single 9-track magnetic tape. The printed documentation, typeset from
the on-line sources, was contained in two volumes.

The names and filesystem locations of the Unix components have changed substantially across the history
of the system. Nonetheless, the V7 implementation is considered by many to have the canonical early
structure:

• Kernel – source code in /usr/sys, composed of several sub-components:

o conf – configuration and machine-dependent parts, including boot code
o dev – device drivers for control of hardware (and some pseudo-hardware)
o sys – operating system "kernel", handling memory management, process scheduling,
system calls, etc.
o h – header files, defining key structures within the system and important system-specific
invariables
• Development Environment – Early versions of Unix contained a development environment
sufficient to recreate the entire system from source code:
o cc – C language compiler (first appeared in V3 Unix)
o as – machine-language assembler for the machine
o ld – linker, for combining object files
o lib – object-code libraries (installed in /lib or /usr/lib). libc, the system library with C run-
time support, was the primary library, but there have always been additional libraries for
such things as mathematical functions (libm) or database access. V7 Unix introduced the
first version of the modern "Standard I/O" library stdio as part of the system library. Later
implementations increased the number of libraries significantly.
o make – build manager (introduced in PWB/UNIX), for effectively automating the build
process
o include – header files for software development, defining standard interfaces and system
invariants
o Other languages – V7 Unix contained a Fortran-77 compiler, a programmable arbitrary-
precision calculator (bc, dc), and the awk scripting language, and later versions and
implementations contain many other language compilers and toolsets. Early BSD releases
included Pascal tools, and many modern Unix systems also include the GNU Compiler
Collection as well as or instead of a proprietary compiler system.
o Other tools – including an object-code archive manager (ar), symbol-table lister (nm),
compiler-development tools (e.g. lex & yacc), and debugging tools.
• Commands – Unix makes little distinction between commands (user-level programs) for system
operation and maintenance (e.g. cron), commands of general utility (e.g. grep), and more general-
 purpose applications such as the text formatting and typesetting package. Nonetheless, some major
categories are:
o sh – The "shell" programmable command line interpreter, the primary user interface on
Unix before window systems appeared, and even afterward (within a "command window").
o Utilities – the core tool kit of the Unix command set, including cp, ls, grep, find and many
others. Subcategories include:
 System utilities – administrative tools such as mkfs, fsck, and many others.
 User utilities – environment management tools such as passwd, kill, and others.
o Document formatting – Unix systems were used from the outset for document preparation
and typesetting systems, and included many related programs such as nroff, troff, tbl, eqn,
refer, and pic. Some modern Unix systems also include packages such as TeX and
Ghostscript.
o Graphics – The plot subsystem provided facilities for producing simple vector plots in a
device-independent format, with device-specific interpreters to display such files. Modern
Unix systems also generally include X11 as a standard windowing system and GUI, and
many support OpenGL.
o Communications – Early Unix systems contained no inter-system communication, but did
include the inter-user communication programs mail and write. V7 introduced the early
inter-system communication system UUCP, and systems beginning with BSD release 4.1c
included TCP/IP utilities.
• Documentation – Unix was the first operating system to include all of its documentation online in
machine-readable form. The documentation included:
o man – manual pages for each command, library component, system call, header file, etc.
o doc – longer documents detailing major subsystems, such as the C language and troff