Search This Blog

Wednesday, July 10, 2013

LINUX

INTRODUCTION

Linux is a Unix-like computer operating system assembled under the model of free and open source software development and distribution. The defining component of Linux is the Linux kernel an operating system kernel first released on 5 October 1991, by Linus Torvalds. Since the C compiler that builds Linux and the main supporting user space system tools and libraries originated in the GNU Project, initiated in 1983 by Richard Stallman, the Free Software Foundation prefers the name GNU/Linux.



Linux was originally developed as a free operating system for Intel x86-based personal computers. It has since been ported to more computer hardware platforms than any other operating system. It is a leading operating system on servers and other big iron systems such as mainframe computers and supercomputers: more than 90% of today's 500 fastest supercomputers run some variant of Linux,[  including the 10 fastest.  Linux also runs on embedded systems (devices where the operating system is typically built into the firmware and highly tailored to the system) such as mobile phones, tablet computers, network routers, building automation controls, televisions and video game consoles; theAndroid system in wide use on mobile devices is built on the Linux kernel.

The development of Linux is one of the most prominent examples of free and open source software collaboration: the underlying source code may be used, modified, and distributed—commercially or non-commercially—by anyone under licenses such as the GNU General Public License. Typically Linux is packaged in a format known as a Linux distribution for desktop and server use. Some popular mainstream Linux distributions include Debian(and its derivatives such as Ubuntu and Linux Mint), Fedora, Red Hat Enterprise Linux, CentOS, Mandriva/Mageia, openSUSE (and its commercial derivative SUSE Linux Enterprise Server), and Arch Linux. Linux distributions include the Linux kernel, supporting utilities and libraries and usually a large amount of application software to fulfill the distribution's intended use.

A distribution oriented toward desktop use will typically include the X Window System and an accompanying desktop environment such as GNOMEor KDE Plasma. Some such distributions may include a less resource intensive desktop such as LXDE or Xfce for use on older or less powerful computers. A distribution intended to run as a server may omit all graphical environments from the standard install and instead include other software such as the Apache HTTP Server and an SSH server such as OpenSSH. Because Linux is freely redistributable, anyone may create a distribution for any intended use. Applications commonly used with desktop Linux systems include the Mozilla Firefox web browser, the LibreOffice office application suite, and the GIMP image editor.

Linus Torvalds, a young man studying computer science at the University of Helsinki, thought it would be a good idea to have some sort of freely available academic version of UNIX, and promptly started to code.

He started to ask questions, looking for answers and solutions that would help him get UNIX on his PC. Below is one of his first posts in comp.os.minix, dating from 1991:

From: torvalds@klaava.Helsinki.FI (Linus Benedict Torvalds)
Newsgroups: comp.os.minix
Subject: Gcc-1.40 and a posix-question
Message-ID: <1991Jul3.100050.9886@klaava.Helsinki.FI>
Date: 3 Jul 91 10:00:50 GMT
Hello netlanders,
Due to a project I'm working on (in minix), I'm interested in the posix
standard definition. Could somebody please point me to a (preferably)
machine-readable format of the latest posix rules? Ftp-sites would be
nice.

From the start, it was Linus' goal to have a free system that was completely compliant with the original UNIX. That is why he asked for POSIX standards, POSIX still being the standard for UNIX.

In those days plug-and-play wasn't invented yet, but so many people were interested in having a UNIX system of their own, that this was only a small obstacle. New drivers became available for all kinds of new hardware, at a continuously rising speed. Almost as soon as a new piece of hardware became available, someone bought it and submitted it to the Linux test, as the system was gradually being called, releasing more free code for an ever wider range of hardware. These coders didn't stop at their PC's; every piece of hardware they could find was useful for Linux.

Back then, those people were called "nerds" or "freaks", but it didn't matter to them, as long as the supported hardware list grew longer and longer. Thanks to these people, Linux is now not only ideal to run on new PC's, but is also the system of choice for old and exotic hardware that would be useless if Linux didn't exist.

Two years after Linus' post, there were 12000 Linux users. The project, popular with hobbyists, grew steadily, all the while staying within the bounds of the POSIX standard. All the features of UNIX were added over the next couple of years, resulting in the mature operating system Linux has become today. Linux is a full UNIX clone, fit for use on workstations as well as on middle-range and high-end servers. Today, all the important players on the hard- and software market each have their team of Linux developers; at your local dealer's you can even buy pre-installed Linux systems with official support.



History

In order to understand the popularity of Linux, we need to travel back in time, about 40 years ago...
Imagine computers as big as houses, even stadiums. While the sizes of those computers posed substantial problems, there was one thing that made this even worse: every computer had a different operating system. Software was always customized to serve a specific purpose, and software for one given system didn't run on another system. Being able to work with one system didn't automatically mean that you could work with another. It was difficult, both for the users and the system administrators.

Computers were extremely expensive then, and sacrifices had to be made even after the original purchase just to get the users to understand how they worked. The total cost of IT was enormous.
Technologically the world was not quite that advanced, so they had to live with the size for another decade. In 1969, a team of developers in the Bell Labs laboratories started working on a solution for the software problem, to address these compatibility issues. They developed a new operating system, which was

1. Simple and elegant.
2. Written in the C programming language instead of in assembly code.
3. Able to recycle code.

The Bell Labs developers named their project "UNIX.”


UNIX

The Unix operating system was conceived and implemented in 1969 at AT&T's Bell Laboratories in the United States by Ken Thompson,Dennis Ritchie, Douglas McIlroy, and Joe Ossanna. It was first released in 1971 and was initially entirely written in assembly language, a common practice at the time. Later, in a key pioneering approach in 1973, Unix was re-written in the programming language C by Dennis Ritchie (with exceptions to the kernel and I/O). The availability of an operating system written in a high-level language allowed easier portability to different computer platforms. With a legal glitch forcing AT&T to license the operating system's source code to anyone who asked,  Unix quickly grew and became widely adopted by academic institutions and businesses. In 1984, AT&T divested itself of Bell Labs. Free of the legal glitch requiring free licensing, Bell Labs began selling Unix as a proprietary product.

The code recycling features were very important. Until then, all commercially available computer systems were written in a code specifically developed for one system. UNIX on the other hand needed only a small piece of that special code, which is now commonly named the kernel. This kernel is the only piece of code that needs to be adapted for every specific system and forms the base of the UNIX system. The operating system and all other functions were built around this kernel and written in a higher programming language, C. This language was especially developed for creating the UNIX system. Using this new technique, it was much easier to develop an operating system that could run on many different types of hardware.

The software vendors were quick to adapt, since they could sell ten times more software almost effortlessly. Weird new situations came in existence: imagine for instance computers from different vendors communicating in the same network, or users working on different systems without the need for extra education to use another computer. UNIX did a great deal to help users become compatible with different systems.

Throughout the next couple of decades the development of UNIX continued. More things became possible to do and more hardware and software vendors added support for UNIX to their products.
UNIX was initially found only in very large environments with mainframes and minicomputers (note that a PC is a "micro" computer). You had to work at a university, for the government or for large financial corporations in order to get your hands on a UNIX system.
But smaller computers were being developed, and by the end of the 80's, many people had home computers. By that time, there were several versions of UNIX available for the PC architecture, but none of them were truly free.


GNU 

The GNU Project, started in 1983 by Richard Stallman, had the goal of creating a "complete Unix-compatible software system" composed entirely of free software. Work began in 1984. Later, in 1985, Stallman started the Free Software Foundation and wrote the GNU General Public License (GNU GPL) in 1989. By the early 1990s, many of the programs required in an operating system (such as libraries, compilers, text editors, a Unix shell, and a windowing system) were completed, although low-level elements such as device drivers, daemons, and the kernel were stalled and incomplete. Linus Torvalds has said that if the GNU kernel had been available at the time (1991), he would not have decided to write his own.


BSD 

Although not released until 1992 due to legal complications, development of 386BSD, from which NetBSD, OpenBSD and FreeBSD descended, predated that of Linux. Linus Torvalds has said that if 386BSD had been available at the time, he probably would not have created Linux. 


MINIX 

MINIX is an inexpensive minimal Unix-like operating system, designed for education in computer science, written by Andrew S. Tanenbaum. Starting with version 3 in 2005, MINIX became free and was redesigned for "serious" use.


Genesis

In 1991 while attending the University of Helsinki, Torvalds became curious about operating systems and frustrated by the licensing of MINIX, which limited it to educational use only. He began to work on his own operating system which eventually became the Linux kernel.

Torvalds began the development of the Linux kernel on MINIX, and applications written for MINIX were also used on Linux. Later Linux matured and further Linux development took place on Linux systems. GNU applications also replaced all MINIX components, because it was advantageous to use the freely available code from the GNU Project with the fledgling operating system. (Code licensed under the GNU GPL can be reused in other projects as long as they also are released under the same or a compatible license.) Torvalds initiated a switch from his original license, which prohibited commercial redistribution, to the GNU GPL. Developers worked to integrate GNU components with Linux to make a fully functional and free operating system. 


Development

Torvalds continues to direct the development of the kernel. Stallman heads the Free Software Foundation, which in turn supports the GNU components. Finally, individuals and corporations develop third-party non-GNU components. These third-party components comprise a vast body of work and may include both kernel modules and user applications and libraries. Linux vendors and communities combine and distribute the kernel, GNU components, and non-GNU components, with additional package management software in the form of Linux distributions.

Simplified history of Unix-like operating systems. Linux shares similar architecture and concepts (as part of the POSIXstandard) but does not share non-free source code with the original Unix or MINIX.

The primary difference between Linux and many other popular contemporary operating systems is that the Linux kernel and other components are free and open source software. Linux is not the only such operating system, although it is by far the most widely used.Some free and open source software licenses are based on the principle of copyleft, a kind of reciprocity: any work derived from a copyleft piece of software must also be copyleft itself. The most common free software license, the GNU General Public License(GPL), is a form of copyleft, and is used for the Linux kernel and many of the components from the GNU Project.

Linux based distributions are intended by developers for interoperability with other operating systems and established computing standards. Linux systems adhere to POSIX, SUS, LSB, ISO, and ANSI standards where possible, although to date only one Linux distribution has been POSIX.1 certified, Linux-FT. 

Free software projects, although developed in a collaborative fashion, are often produced independently of each other. The fact that the software licenses explicitly permit redistribution, however, provides a basis for larger scale projects that collect the software produced by stand-alone projects and make it available all at once in the form of a Linux distribution.

Many Linux distributions, or "distros", manage a remote collection of system software and application software packages available for download and installation through a network connection. This allows users to adapt the operating system to their specific needs. Distributions are maintained by individuals, loose-knit teams, volunteer organizations, and commercial entities. A distribution is responsible for the default configuration of the installed Linux kernel, general system security, and more generally integration of the different software packages into a coherent whole. Distributions typically use a package manager such as dpkg, Synaptic, YAST, yum, or Portage to install, remove and update all of a system's software from one central location.


Design

A Linux-based system is a modular Unix-like operating system. It derives much of its basic design from principles established in Unix during the 1970s and 1980s. Such a system uses amonolithic kernel, the Linux kernel, which handles process control, networking, and peripheral and file system access. Device drivers are either integrated directly with the kernel or added as modules loaded while the system is running.

Separate projects that interface with the kernel provide much of the system's higher-level functionality. The GNU userland is an important part of most Linux-based systems, providing the most common implementation of the C library, a popular shell, and many of the common Unix tools which carry out many basic operating system tasks. The graphical user interface (or GUI) used by most Linux systems is built on top of an implementation of the X Window System.

Some components of an installed Linux system are:

A bootloader - for example GRUB or LILO. This is a program which is executed by the computer when it is first turned on, and loads the Linux kernel into memory.

An init program. This is a process launched by the Linux kernel, and is at the root of the process tree: in other terms, all processes are launched through init. It starts processes such as system services and login prompts (whether graphical or in terminal mode)

Software libraries which contain code which can be used by running processes. On Linux systems using ELF-format executable files, the dynamic linker which manages use of dynamic libraries is "ld-linux.so". The most commonly used software library on Linux systems is the GNU C Library. If the system is set up for the user to compile software themselves, header files will also be included to describe the interface of installed libraries.

User interface programs such as command shells or windowing environments


User interface

The user interface, also known as the shell, is either a command-line interface (CLI), a graphical user interface (GUI), or through controls attached to the associated hardware, which is common for embedded systems. For desktop systems, the default mode is usually a graphical user interface, although the CLI is available through terminal emulator windows or on a separate virtual console. Most low-level Linux components, including the GNU userland, use the CLI exclusively. The CLI is particularly suited for automation of repetitive or delayed tasks, and provides very simple inter-process communication.

On desktop systems, the most popular user interfaces are the extensive desktop environments KDE Plasma Desktop, GNOME, Unity and Xfce, though a variety of additional user interfaces exist. Most popular user interfaces are based on the X Window System, often simply called "X". It provides network transparency and permits a graphical application running on one system to be displayed on another where a user may interact with the application. 

Other GUIs may be classified as simple X window managers, such as FVWM, Enlightenment, and Window Maker, which provide a minimalist functionality with respect to the desktop environments. A window manager provides a means to control the placement and appearance of individual application windows, and interacts with the X Window System. The desktop environments include window managers as part of their standard installations (Mutter for GNOME, KWin for KDE, Xfwm for Xfce as of January 2012) although users may choose to use a different window manager if preferred. 

Whether Linux is difficult to learn depends on the person you're asking. Experienced UNIX users will say no, because Linux is an ideal operating system for power-users and programmers, because it has been and is being developed by such people.

Everything a good programmer can wish for is available: compilers, libraries, development and debugging tools. These packages come with every standard Linux distribution. The C-compiler is included for free, all the documentation and manuals are there, and examples are often included to help you get started in no time. It feels like UNIX and switching between UNIX and Linux is a natural thing.
In the early days of Linux, being an expert was kind of required to start using the system. Those who mastered Linux felt better than the rest of the "lusers" who hadn't seen the light yet. It was common practice to tell a beginning user to "RTFM" (read the manuals). While the manuals were on every system, it was difficult to find the documentation, and even if someone did, explanations were in such technical terms that the new user became easily discouraged from learning the system.

The Linux-using community started to realize that if Linux was ever to be an important player on the operating system market, there had to be some serious changes in the accessibility of the system.
Programming on Linux

Most Linux distributions support dozens of programming languages. The original development tools used for building both Linux applications and operating system programs are found within theGNU toolchain, which includes the GNU Compiler Collection (GCC) and the GNU build system. Amongst others, GCC provides compilers for Ada, C, C++, Java, and Fortran. First released in 2003, the Low Level Virtual Machine project provides an alternative open-source compiler for many languages. Proprietary compilers for Linux include the Intel C++ Compiler, Sun Studio, and IBM XL C/C++ Compiler. BASIC in the form of Visual Basic is supported in such forms as Gambas, FreeBASIC, and XBasic, and in terms of terminal programming or QuickBASIC or Turbo BASICprogramming in the form of QB64.

A common feature of Unix-like systems, Linux includes traditional specific-purpose programming languages targeted at scripting, text processing and system configuration and management in general. Linux distributions support shell scripts, awk, sed and make. Many programs also have an embedded programming language to support configuring or programming themselves. For example, regular expressions are supported in programs like grep, or locate, while advanced text editors, like GNU Emacs have a complete Lisp interpreter built-in.

Most distributions also include support for PHP, Perl, Ruby, Python and other dynamic languages. While not as common, Linux also supports C# (via Mono), Vala, and Scheme. A number ofJava Virtual Machines and development kits run on Linux, including the original Sun Microsystems JVM (HotSpot), and IBM's J2SE RE, as well as many open-source projects like Kaffe andJikesRVM.

GNOME and KDE are popular desktop environments and provide a framework for developing applications. These projects are based on the GTK+ and Qt widget toolkits, respectively, which can also be used independently of the larger framework. Both support a wide variety of languages. There are a number of Integrated development environments available including  Anjuta ,  Code::Blocks,CodeLite , Eclipse , Geany , ActiveState Komodo, KDevelop, Lazarus, MonoDevelop, NetBeans, and Qt Creator, while the long-established editors Vim, nano and Emacs remain popular.
Application of Linux systems

Today Linux has joined the desktop market. Linux developers concentrated on networking and services in the beginning, and office applications have been the last barrier to be taken down. We don't like to admit that Microsoft is ruling this market, so plenty of alternatives have been started over the last couple of years to make Linux an acceptable choice as a workstation, providing an easy user interface and MS compatible office applications like word processors, spreadsheets, presentations and the like.

On the server side, Linux is well-known as a stable and reliable platform, providing database and trading services for companies like Amazon, the well-known online bookshop, US Post Office, the German army and such. Especially Internet providers and Internet service providers have grown fond of Linux as firewall, proxy- and web server, and you will find a Linux box within reach of every UNIX system administrator who appreciates a comfortable management station. Clusters of Linux machines are used in the creation of movies such as "Titanic", "Shrek" and others. In post offices, they are the nerve centers that route mail and in large search engine, clusters are used to perform internet searches.These are only a few of the thousands of heavy-duty jobs that Linux is performing day-to-day across the world.

It is also worth to note that modern Linux not only runs on workstations, mid- and high-end servers, but also on "gadgets" like PDA's, mobiles, a shipload of embedded applications and even on experimental wristwatches. This makes Linux the only operating system in the world covering such a wide range of hardware.


Uses

As well as those designed for general purpose use on desktops and servers, distributions may be specialized for different purposes including: computer architecture support, embedded systems, stability, security, localization to a specific region or language, targeting of specific user groups, support for real-time applications, or commitment to a given desktop environment. Furthermore, some distributions deliberately include only free software. Currently, over three hundred distributions are actively developed, with about a dozen distributions being most popular for general-purpose use.

Linux is a widely ported operating system kernel. The Linux kernel runs on a highly diverse range of computer architectures: in the hand-held ARM-based iPAQ and the mainframe IBM System z9, System z10; in devices ranging from mobile phones to supercomputers. Specialized distributions exist for less mainstream architectures. The ELKS kernel fork can run on Intel 8086 orIntel 80286 16-bit microprocessors, while the µClinux kernel fork may run on systems without a memory management unit. The kernel also runs on architectures that were only ever intended to use a manufacturer-created operating system, such as Macintosh computers (with both PowerPC and Intel processors), PDAs, video game consoles, portable music players, and mobile phones. See List of Linux supported architectures.

There are several industry associations and hardware conferences devoted to maintaining and improving support for diverse hardware under Linux, such as FreedomHEC.


Properties of Linux

Linux Pros

A lot of the advantages of Linux are a consequence of Linux' origins, deeply rooted in UNIX, except for the first advantage, of course:

Linux is free:

As in free beer, they say. If you want to spend absolutely nothing, you don't even have to pay the price of a CD. Linux can be downloaded in its entirety from the Internet completely for free. No registration fees, no costs per user, free updates, and freely available source code in case you want to change the behavior of your system.
Most of all, Linux is free as in free speech:

The license commonly used is the GNU Public License (GPL). The license says that anybody who may want to do so, has the right to change Linux and eventually to redistribute a changed version, on the one condition that the code is still available after redistribution. In practice, you are free to grab a kernel image, for instance to add support for teletransportation machines or time travel and sell your new code, as long as your customers can still have a copy of that code.

Linux is portable to any hardware platform:

A vendor who wants to sell a new type of computer and who doesn't know what kind of OS his new machine will run (say the CPU in your car or washing machine), can take a Linux kernel and make it work on his hardware, because documentation related to this activity is freely available.

Linux was made to keep on running:

As with UNIX, a Linux system expects to run without rebooting all the time. That is why a lot of tasks are being executed at night or scheduled automatically for other calm moments, resulting in higher availability during busier periods and a more balanced use of the hardware. This property allows for Linux to be applicable also in environments where people don't have the time or the possibility to control their systems night and day.

Linux is secure and versatile:

The security model used in Linux is based on the UNIX idea of security, which is known to be robust and of proven quality. But Linux is not only fit for use as a fort against enemy attacks from the Internet: it will adapt equally to other situations, utilizing the same high standards for security. Your development machine or control station will be as secure as your firewall.

Linux is scalable:

From a Palmtop with 2 MB of memory to a petabyte storage cluster with hundreds of nodes: add or remove the appropriate packages and Linux fits all. You don't need a supercomputer anymore, because you can use Linux to do big things using the building blocks provided with the system. If you want to do little things, such as making an operating system for an embedded processor or just recycling your old 486, Linux will do that as well.

The Linux OS and Linux applications have very short debug-times:

Because Linux has been developed and tested by thousands of people, both errors and people to fix them are found very quickly. It often happens that there are only a couple of hours between discovery and fixing of a bug.


Linux Cons

There are far too many different distributions:

"Quot capites, tot rationes", as the Romans already said: the more people, the more opinions. At first glance, the amount of Linux distributions can be frightening, or ridiculous, depending on your point of view. But it also means that everyone will find what he or she needs. You don't need to be an expert to find a suitable release.

When asked, generally every Linux user will say that the best distribution is the specific version he is using. So which one should you choose? Don't worry too much about that: all releases contain more or less the same set of basic packages. On top of the basics, special third party software is added making, for example, TurboLinux more suitable for the small and medium enterprise, RedHat for servers and SuSE for workstations. However, the differences are likely to be very superficial. The best strategy is to test a couple of distributions; unfortunately not everybody has the time for this. Luckily, there is plenty of advice on the subject of choosing your Linux. One place is LinuxJournal, which discusses hardware and support, among many other subjects. The Installation HOWTO also discusses choosing your distribution.

Linux is not very user friendly and confusing for beginners:

In light of its popularity, considerable effort has been made to make Linux even easier to use, especially for new users. More information is being released daily, such as this guide, to help fill the gap for documentation available to users at all levels.

Is an Open Source product trustworthy?

How can something that is free also be reliable? Linux users have the choice whether to use Linux or not, which gives them an enormous advantage compared to users of proprietary software, who don't have that kind of freedom. After long periods of testing, most Linux users come to the conclusion that Linux is not only as good, but in many cases better and faster that the traditional solutions. If Linux were not trustworthy, it would have been long gone, never knowing the popularity it has now, with millions of users. Now users can influence their systems and share their remarks with the community, so the system gets better and better every day. It is a project that is never finished, that is true, but in an ever changing environment, Linux is also a project that continues to strive for perfection.



Tuesday, July 9, 2013

Programming Languages

Programming Languages

Alan Perlis once said: "A language that doesn't affect the way you think about programming, is not worth knowing".

Here are some opinions and facts about a selection of programming languages by Dr Mark Utting (a lecturer in the Department of Computer Science at The University of Waikato).
The Open Directory Project has lots of programming language information.
For examples of programming in 200+ different languages, check out the 99 Bottles of Beer page. The Dylan version is nice, but make sure you check out all the C++ versions too! The template version is amazing!
Another overview of programming and web languages is on test-king.com.

Object-Oriented Languages

The Cetus Team maintains a large collection of links about most object-oriented languages.
Let us start with some lesser-known, but more novel, object-oriented languages, then work down to 
the well-known mainstream ones.

One of my favourite object-oriented languages is Cecil, by Craig Chambers. It is a multiple-dispatch language that supports both exploratory untyped programming and large-scale statically-typed programming. It includes some new and very expressive ideas (see the paper "Predicate Dispatching: A Unified Theory of Dispatch" by Michael Ernst, Craig Kaplan and Craig Chambers). Cecil is quite similar to the theoretical language that I developed in my PhD thesis.

An equally nice language is Dylan. Like Cecil, Dylan is a safe, strongly-typed, pure object-oriented language that supports multiple dispatch, modules, first-class functions etc. Dylan was originally designed by Andrew Shalit at Apple. There is a commercial implementation of it for Windows 95/NT platforms available from Functional Objects Inc., with a personal version available via free download. Free versions of Dylan for various UNIX machines are available from the Gywdion group. Other useful 

Dylan sites include:

the Introduction of Shalit's book, `The Dylan Reference Manual', gives an overview and rationale for Dylan;
Eric Kidd's 'Getting Started With Dylan' tutorial is the best online tutorial;
an A First Look at Dylan: Classes, Functions, and Modules an introductory article about Dylan from Apple (Steve Strassman);
Gwydion's 12 short example Dylan programs.
Paul Haahr's Procedural Programming in Dylan compares Pascal and Dylan versions of several simple functions. Section 3 introduces Dylan's support for higher-order functions in a gentle way. (His site also has a YACC grammar for Dylan, and an alternative multiple-inheritance linearization;
A small Dylan FAQ (Frequently Asked Questions).
The open directory project has lots of dylan links.
The Dylan Language Standard group is managing changes to the Dylan language.
The draft Dylan Reference Manual is available in PDF format (2Mb). A final version of this was published by Apple (via Addison-Wesley) in 1996, and is available at a special price from Functional Objects. There is also a nice browsable html version of it.
the Gywdion implementation of Dylan, started by the CMU Gwydion Group and being continued by volunteers (here is their mailing list archives). It is available for various machines
The Open Directory Project's Dylan page.
the Dylan Code Repository for reusable Dylan code.
Chris Double has written several example programs including one that displays .bmp files in a window.
Peter Norvig's slide presentation on Design Patterns in Dynamic Languages includes examples of patterns in Dylan, LISP, C++, Smalltalk and Sather.
A Dr. Dobbs Journal article on Dylan (by Tamme D. Bowen and Kelly M. Hall) which defines the semantics of the main Dylan features in Haskell!
This 1995 MacTech Magazine article (Vol 11, No. 8). includes a brief description and some screenshots of the original Apple Dylan Development Environment.
Miscellaneous old Dylan documents at the CMU AI repository.

Python is another favourite. Interpreted, and ideal for knocking up quick prototypes, but with a nice module system, lots of handy libraries, and almost purely object-oriented.

Apart from Simula-67, Smalltalk started the OO craze. Implementations are becoming more easily available now. (See also ObjectShare's non-commercial VisualWorks Smalltalk, available for Linux and Windows)Squeak is an open source Smalltalk that is becoming very popular. A lot of Smalltalk-related information and projects are accessible from the Panasoft Smalltalk Links. Here is a nice Smalltalk tutorial from IBM.

Some other clean OOLs are:

Scala is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. All Java classes can be imported and used within Scala programs.
Blue, a clean OOL especially designed for teaching first-year students.
Eiffel was the first object-oriented language to give good support for software engineering concepts like design by contract.
Modula-3
Oberon, from Nicolas Wirth, the designer of Pascal.
Sather
Component Pascal is an object oriented programming language most closely related to Oberon-2. Compared to Oberon-2 it adds a number of annotations which are intended to enhance the type-safety of component oriented programs. QUT offers an open source compiler which generates Java bytecodes or Microsoft.NET output. Alternatively, Oberon Microsystems have made their 'BlackBox Component Builder' compiler/environment for Component Pascal open source now.
TOM is a new object-oriented programming language that advocates unplanned reuse of code (classes can be extended in very flexible ways, even without source code for them).
Suneido is a free, open-source, pure-OO language whose syntax is similar to C++ or Java, but simpler. It is a safe, dynamic language like Smalltalk, enabling rapid development. It supports automatic garbage collection, exception handling and has builtin client-server relational database, user interface and reporting frameworks. Available for all Windows platforms, but a Linux version is planned.
D from Digital Mars is intended to be a clean successor to C++. It has good support for design-by-contract programming, like Eiffel.
How about a simple OO Forth? It takes less than one screenful of Forth to define objects, classes and single inheritance.
Then we have the less clean C extensions: Objective-C seems less widely used now, but is supported by gcc.

C++ is the most widely used object-oriented language. See: Readings, FAQS, ANSI Standard or here
A recommended book on the design of C++ is

"The Design and Evolution of C++", by Bjarne Stroustrup, Addison-Wesley, 1995.

I quite like the standard template library (STL) of C++ (local docs here). It allows higher-order programming to a certain extent and comes with about 10 generic data structures and 70 simple algorithms over them. See Mumit's STL Newbie guide for some handy STL hints. Other STL-like libraries include: the Graph Template Library (GTL).

There seem to be two major contenders for the "best GUI toolkit" title at the moment. GTK+ (the GIMP toolkit) is more C oriented, but does slots and signals without a preprocessor, whereas Qt uses a preprocessor (MOC) but has the dis/advantage of being a complete solution for porting to Windows 95/NT. The GTK+ toolkit has bindings for several languages, including a C++ wrapper for GTK+ called gtk-- (or FTP).

D is another object-oriented extension of C, designed for systems programming, but with garbage collection, runtime type identification and templates.
Of course, there is also Java which was designed to be safer and cleaner than C++ (see the Java white paper, a Java tutorial, Java Games and Java Puzzles).
[TODO: update this section, now that I've used Java for a few years.]

The two most attractive aspects of Java are that it can be a safe language (all errors are caught by the compiler or bytecode checker or cause runtime exceptions), and its portability (especially its wide range of standard libraries).

Some problems with Java that I've heard about include: hard to format a floating point number, integers etc. are not objects so cannot be subtyped or subranged, non-portable thread semantics, text I/O difficult for beginners. The lack of generics was a real pain in Java (lots of type casting), but now Java 5.0 has fixed this at last.
Here are several interesting extensions/variants of Java:
The Java Modelling Language, is Java extended with specification facilities (class invariants, preconditions, postconditions etc.); These can be added within comments, so that existing Java tools are unaffected, but the JML tools can perform deeper analysis of the program to detect more errors.
Jbed is a commercial real-time subset of Java that supports deadline-driven scheduling.
There are also quite a few other languages being implemented on top of the Java Virtual Machine, see here, here and here.

Objects have also been added onto Perl (Perl 4 was my least-liked language!) and Ada. In fact, Ada was actually the first ISO standardized OO language (Ada95)! A new ISO version of Ada, currently known as Ada200Y, will include Java-like interfaces and a larger predefined library etc.

Rational Software Corporation have done an interesting comparison between development in C and Ada.

Rational Software Corporation also sell Purify (a heap-memory checker) and are responsible for the OO Unified Modelling Language, which is now the industry standard for specifying the structure of OO systems.

Finally, CLU is an old but influential language that introduced important ideas for iterating through collection objects, for exception handling and a carefully-designed theory of object invariants, pre/post conditions etc.

The book Abstraction and Specification in Program Development, by Barbara Liskov and John Guttag, MIT Press, 1986. Here are some of my notes on the book.
A 1978 paper: A Critique of the Programming Language CLU by James Peterson. This also gives a brief overview of the language.
Here are some Software Engineering methods/tools for object-oriented programming:
Project Technology: Shlaer-Mellor methodology
ObjectTime: Real-Time Object-Oriented Modeling (ROOM)
Rational: Unified Method & Jacobson

See John Yeager's S/W Engineering resources for more information.

Functional Programming Languages

Haskell is the most popular functional programming language and is the one that I've used a lot (for example, my Z animator, Jaza). It is an elegant lazy high-level language, with fast compiled implementations plus a interpreter (HUGS) that is good for development. It also comes with a large collection of amazing libraries for writing parsers, pretty-printers, MIDI composition programmes (Haskore) etc., plus the ability to interface to arbitrary C procedures in a functionally clean way.

One of the advantages of Haskell is that expert programmers can extend the language by defining their own operators and 'monads', to get a very concise application-specific language. The disadvantage of this power is that if you overuse it, it becomes difficult for other people to read your programs!
Other popular functional programming languages include the eager (non-lazy) ML family of languages, such as Standard ML and Objective CAML. Here is an introductory book Objective CAML for Scientists.

Logic Programming Languages

There is a WWW virtual library for logic programming. Michael Ley has a database/logic programming bibliography The ALP (Association of Logic Programming) newsletter.
I am part of the Starlog research group, which is designing and implementing a new pure logic-programming language that is especially suited to reactive and real-time programming. Recently, I've implemented a version of Starlog for controlling Lego Robots!

Prolog is the most commonly known logic programming language, albeit impure. A few well-known implementations are: Quintus Prolog, SICStus Prolog, Eclipse Prolog, SWI Prolog (free!). Qu-Prolog is Prolog customised for formal methods (it handles quantifiers, object-variables and substitutions as primitives).

The Prolog at VIP is free for non-commercial use. Another free one is TRINC-Prolog. Michael D. Kersey recommends Amzi! Logic Explorer and the "Adventures in Prolog" (with a "very nice and complete tutorial"). Seehere for other free Prologs. [mindgap@my-dejanews.com, Alexander.Apostolovski@worldonline.be, and mkersey@metricom.com; comp.lang.prolog, 12Mar99.]

Roman Bartak's Interactive Prolog Guide includes FAQs, program samples, implementations, and references.

The BURKS project provides documentation and free Prolog implementations for DOS, Windows etc.
LPA Prolog for Windows -- with an IDE and single-step debugger -- offers a free 30-day trial. [Nov98]

Amzi! Logic Explorer is free for personal use. It comes with a full tutorial and sample programs, plus a GUI development environment. Amzi! inc. also offers a Prolog compiler and embeddable libraries (for C/C++, Java, Delphi, VB, etc) for a 90-day trial. [Dec98]

Mercury is an elegant, pure, logic programming language from Melbourne University. The fastest logic programming language around...

The Cetus Links OO Prolog page has links to object-oriented logic programming languages. Curry is an extension of Haskell that adds logic-programming features like logical variables, constraint solving and concurrent and distributed programming.

Here are some useful online sites for constraint logic programming:

The constraints archive;
Bartak's online constraint programming tutorial;
Tsang's 1993 book, Foundations of Constraint Satisfaction is out of print, but available from him via online order.
CLPGUI is an open-source Graphical User Interface for Constraint Logic Programming.
Not really CLP, but here is a useful site on good algorithms for solving numerical problems (numerical analysis books etc.).
The quarterly Logic Programming Newsletter is now online.
The textbook Logic, Programming and Prolog (2ed) by Ulf Nilsson and Jan Maluszynski is now available online. It covers theoretical aspects of logic programming as well as practical programming in Prolog, and extensions logic programming such as equational logic programming, constraint logic programming and query answering in deductive databases.
Transformation Languages
Some languages for transforming models and programs:
QVT (Query/View/Transformation) is an OMG standard for transforming models into other models.

Text Formatting Languages

LaTeX is the defacto text formatting system for academic papers containing mathematics. There is lots of online reference material for it. See also the Comprehensive TeX Archive Network (CTAN). More documentation is here.

Basser Lout is another text formatting language that produces Postscript/PDF directly and has a more elegant (and functional!) programming/macro language than TeX.

For HTML (the web markup language):

A simple HTML tutorial.
Ian Graham's guide to HTML.
Tips on writing HTML files to reduce net load.
Nelson Minar's html-helper-mode is an excellent macro package for writing writing HTML pages in Emacs. I use it with the table extensions by Joe Hildebrand.
XML-related Languages
The World Wide Web Consortium (W3C) is the official source for XML-related documents, and has lots of tools links.
ZVON.org has lots of XML-related tutorials and reference manuals, including an XML glossary, unicode character references a good reference for XSLT
Documentation Generators
There are lots of programs available for generating HTML and/or LaTeX documentation from C++ source files etc. For example:
Javadoc generates HTML pages from Java source code.
Doxygen generates crosslinked HTML pages in a style similar to the Qt documentation. It also handles the Signal/Slot declarations of Qt.

Free Implementations

A Catalog of Free Compilers and Interpreters.
Poplog is an open source, extendable, portable, multilanguage software development environment providing incremental compilers for several interactive programming languages: Pop-11, Prolog, Common Lisp, and Standard ML. It comes with documentation, libraries, and teaching materials for AI and Computer science (and more general programming).

Language Design Issues and Mistakes

Here are a few interesting papers about language design:

Go To Statement Considered Harmful (a classic, by Dijkstra)
Arrays and Pointers Considered Harmful, [Ince 92] D.C.INCE, ACM SigPlan Notices, January 1992.
Primitive Types Considered Harmful (why Java should be a pure OO language).
Interface Pointers Considered Harmful (About COM and C++, in The C++ Report, Sep 1995)
COM Smart Pointers Even More Harmful (A follow-up article in The C++ Report, Feb 1996)
An interesting comparison of language abstraction levels which showed that an almost functional language, CAML, was the best language for a large complex numerical simulation task.
Garbage collection is an important aspect of modern programming languages. Richard Jones's Garbage Collection Pages and Ravenbrook's Memory Management Reference are good resources for everyone interested in memory management and garbage collection.
Source Code
Sourcebank is a search engine for finding reusable source code, postscript papers about software, and articles in online programming journals.

List of programming languages

The aim of this list of programming languages is to include all notable programming languages in existence, both those in current use and historical ones, in alphabetical order, except for dialects of BASIC and esoteric programming languages.

Note: Dialects of BASIC have been moved to the separate List of BASIC dialects.
Note: This page does not list esoteric programming languages.

A

A# .NET
A# (Axiom)
A-0 System
A+
A++
ABAP
ABC
ABC ALGOL
ABLE
ABSET
ABSYS
Abundance
ACC
Accent
Ace DASL
ACT-III
Action!
ActionScript
Ada
Adenine
Agda
Agilent VEE
Agora
AIMMS
Alef
ALF
ALGOL 58
ALGOL 60
ALGOL 68
Alice
Alma-0
AmbientTalk
Amiga E
AMOS
AMPL
APL
AppleScript
Arc
ARexx
Argus
AspectJ
Assembly language
ATS
Ateji PX
AutoHotkey
Autocoder
AutoIt
AutoLISP / Visual LISP
Averest
AWK
Axum

B

B
Babbage
BAIL
Bash
BASIC
bc
BCPL
BeanShell
Batch (Windows/Dos)
Bertrand
BETA
Bigwig
Bistro
BitC
BLISS
Blue
Bon
Boo
Boomerang
Bourne shell (including bash and ksh)
BREW
BPEL
BUGSYS
BuildProfessional

C

C
C--
C++ - ISO/IEC 14882
C# - ISO/IEC 23270
C/AL
Caché ObjectScript
C Shell
Caml
Candle
Cayenne
CDuce
Cecil
Cel
Cesil
Ceylon
CFML
Cg
Ch
Chapel
CHAIN
Charity
Charm
Chef
CHILL
CHIP-8
chomski
ChucK
CICS
Cilk
CL (IBM)
Claire
Clarion
Clean
Clipper
CLIST
Clojure
CLU
CMS-2
COBOL - ISO/IEC 1989
CobolScript
Cobra
CODE
CoffeeScript
Cola
ColdC
ColdFusion
Cool
COMAL
Combined Programming Language (CPL)
Common Intermediate Language (CIL)
Common Lisp (also known as CL)
COMPASS
Component Pascal
COMIT
Constraint Handling Rules (CHR)
Converge
Coral 66
Corn
CorVision
Coq
COWSEL
CPL
csh
CSP
Csound
Curl
Curry
Cyclone
Cython

D

D
DASL (Datapoint's Advanced Systems Language)
DASL (Distributed Application Specification Language)
Dart
DataFlex
Datalog
DATATRIEVE
dBase
dc
DCL
Deesel (formerly G)
Delphi
DinkC
DIBOL
Dog
Draco
Dylan
DYNAMO

E

E
E#
Ease
Easy PL/I
EASYTRIEVE PLUS
ECMAScript
Edinburgh IMP
EGL
Eiffel
ELAN
Elixir
Elm
Emacs Lisp
Emerald
Epigram
Erlang
es
Escapade
Escher
ESPOL
Esterel
Etoys
Euclid
Euler
Euphoria
EusLisp Robot Programming Language
CMS EXEC
EXEC 2

F

F
F#
Factor
Falcon
Fancy
Fantom
FAUST
Felix
Ferite
FFP
Fjölnir
FL
Flavors
Flex
FLOW-MATIC
FOCAL
FOCUS
FOIL
FORMAC
@Formula
Forth
Fortran - ISO/IEC 1539
Fortress
FoxBase
FoxPro
FP
FPr
Franz Lisp
Frink
F-Script
FSProg

G

G
Game Maker Language
GameMonkey Script
GAMS
GAP
G-code
Genie
GDL
Gibiane
GJ
GEORGE
GLSL
GNU E
GM
Go
Go!
GOAL
Gödel
Godiva
GOM (Good Old Mad)
Goo
Gosu
GOTRAN
GPSS
GraphTalk
GRASS
Groovy

H

HAL/S
Hamilton C shell
Harbour
Hartmann pipelines
Haskell
Haxe
High Level Assembly
HLSL
Hop
Hope
Hugo
Hume
HyperTalk

I

IBM Basic assembly language
IBM HAScript
IBM Informix-4GL
IBM RPG
ICI
Icon
Id
IDL
Idris
IMP
Inform
Io
Ioke
IPL
IPTSCRAE
ISLISP
ISPF
ISWIM

J

J
J#
J++
JADE
Jako
JAL
Janus
JASS
Java
JavaScript
JCL
JEAN
Join Java
JOSS
Joule
JOVIAL
Joy
JScript
JavaFX Script
Julia

K

K
Kaleidoscope
Karel
Karel++
Kaya
KEE
KIF
Kojo
KRC
KRL
KRL (KUKA Robot Language)
KRYPTON
ksh

L

L
L# .NET
LabVIEW
Ladder
Lagoona
LANSA
Lasso
LaTeX
Lava
LC-3
Leadwerks Script
Leda
Legoscript
LIL
LilyPond
Limbo
Limnor
LINC
Lingo
Linoleum
LIS
LISA
Lisaac
Lisp - ISO/IEC 13816
Lite-C
Lithe
Little b
Logo
Logtalk
LPC
LSE
LSL
LiveCode
Lua
Lucid
Lustre
LYaPAS
Lynx

M

M
M2001
M4
Machine code
MAD (Michigan Algorithm Decoder)
MAD/I
Magik
Magma
make
Maple
MAPPER (Unisys/Sperry) now part of BIS
MARK-IV (Sterling/Informatics) now VISION:BUILDER of CA
Mary
MASM Microsoft Assembly x86
Mathematica
MATLAB
Maxima (see also Macsyma)
Max (Max Msp - Graphical Programming Environment)
MaxScript internal language 3D Studio Max
Maya (MEL)
MDL
Mercury
Mesa
Metacard
Metafont
MetaL
Microcode
MicroScript
MIIS
MillScript
MIMIC
Mirah
Miranda
MIVA Script
ML
Moby
Model 204
Modelica
Modula
Modula-2
Modula-3
Mohol
MOO
Mortran
Mouse
MPD
MSIL - deprecated name for CIL
MSL
MUMPS

N

Napier88
NASM
NATURAL
Neko
Nemerle
NESL
Net.Data
NetLogo
NetRexx
NewLISP
NEWP
Newspeak
NewtonScript
NGL
Nial
Nice
Nickle
NPL
Not eXactly C (NXC)
Not Quite C (NQC)
Nu
NSIS
NWScript

O

o:XML
Oak
Oberon
Obix
OBJ2
Object Lisp
ObjectLOGO
Object REXX
Object Pascal
Objective-C
Objective-J
Obliq
Obol
OCaml
occam
occam-π
Octave
OmniMark
Onyx
Opa
Opal
OpenEdge ABL
OPL
OPS5
OptimJ
Orc
ORCA/Modula-2
Oriel
Orwell
Oxygene
Oz

P

P#
PARI/GP
Pascal - ISO 7185
Pawn
PCASTL
PCF
PEARL
PeopleCode
Perl
PDL
PHP
Phrogram
Pico
Pict
Pike
PIKT
PILOT
Pipelines
Pizza
PL-11
PL/0
PL/B
PL/C
PL/I - ISO 6160
PL/M
PL/P
PL/SQL
PL360
PLANC
Plankalkül
PLEX
PLEXIL
Plus
POP-11
PostScript
PortablE
Powerhouse
PowerBuilder - 4GL GUI appl. generator from Sybase
PowerShell
PPL
Processing
Processing.js
Prograph
PROIV
Prolog
Visual Prolog
Promela
PROTEL
ProvideX
Pro*C
Pure
Python

Q

Q (equational programming language)
Q (programming language from Kx Systems)
Qalb
QBasic
Qi
Qore
QtScript
QuakeC
QPL

R

R
R++
Racket
RAPID
Rapira
Ratfiv
Ratfor
rc
REBOL
Red
Redcode
REFAL
Reia
Revolution
rex
REXX
Rlab
ROOP
RPG
RPL
RSL
RTL/2
Ruby
Rust

S

S
S2
S3
S-Lang
S-PLUS
SA-C
SabreTalk
SAIL
SALSA
SAM76
SAS
SASL
Sather
Sawzall
SBL
Scala
Scheme
Scilab
Scratch
Script.NET
Sed
Seed7
Self
SenseTalk
SequenceL
SETL
Shift Script
SIMPOL
SIMSCRIPT
Simula
Simulink
SISAL
SLIP
SMALL
Smalltalk
Small Basic
SML
SNOBOL(SPITBOL)
Snowball
SOL
Span
SPARK
SPIN
SP/k
SPS
Squeak
Squirrel
SR
S/SL
Starlogo
Strand
Stata
Stateflow
Subtext
SuperCollider
SuperTalk
SYMPL
SyncCharts
SystemVerilog

T

T
TACL
TACPOL
TADS
TAL
Tcl
Tea
TECO
TELCOMP
TeX
TEX
TIE
Timber
TMG, compiler-compiler
Tom
TOM
Topspeed
TPU
Trac
TTM
T-SQL
TTCN
Turing
TUTOR
TXL
TypeScript

U

Ubercode
UCSD Pascal
Unicon
Uniface
UNITY
Unix shell
UnrealScript

V

Vala
VBA
VBScript
Verilog
VHDL
Visual Basic
Visual Basic .NET
Microsoft Visual C++
Visual C#
Visual DataFlex
Visual DialogScript
Visual Fortran
Visual FoxPro
Visual J++
Visual J#
Visual Objects
VSXu
Vvvv


W

WATFIV, WATFOR
WebDNA
WebQL
Windows PowerShell
Winbatch

X

X++
X#
X10
XBL
XC (exploits XMOS architecture)
xHarbour
XL
XOTcl
XPL
XPL0
XQuery
XSB
XSLT - See XPath

Y

Yorick
YQL

Z

Z notation
Zeno
ZOPL
ZPL


Source:
http://www.cs.waikato.ac.nz
http://en.wikipedia.org