Intro

Computers can do a myriad number of tasks and types of tasks. There is an endless number of ways to implement each task. One of the variables involved is to choose which programming language or languages to use.

Here is how Ziring [http://users.erols.com/ziring/dopl.html] grouped languages by type:

Applicable Environment

Some languages are designed to work in different environments. Here are a few applicable environments:

The different class libraries that a language can work with have a tremendous affect as to the power and applicability of a language.

Compiled v Interpreted

A compiled programming language must be developed using an API (Application Programming Interface, software that for programming in a particular programming language). The code that a developer sees and modifies using the API is called source code. All the source code must be checked and translated by a compiler into platform specific object code.  The resulting object code is usually either in assembly or machine language. The resulting object may be code modules that must be pulled together by a linker (aka link editor or binder) or brought over from some source into main memory by a loader. The final result is usually an executable program (EG: .exe) or a component (EG: .dll).

An interpreted language (aka script language), on the other hand, can be written using an API or a regular text editor (since the files produced are ordinary text). The script is interpreted sequentially (line by line) by an interpreter (like a browser) into executable machine language. Bits of script can be also be generated on the fly.

EG:

Data Type Checking

Each variable has a data type (EG: text, integer, or floating point). It is important to check the data type of variables so as to avoid errors when data types are confused (EG: storing a floating point value in a Boolean variable).

Variable typing for some languages:

Untyped means that variables can change the data type it holds. EG: x = 6; x = "six";.

Static type checking checks the data types at compilation time. This is inflexible but allows the runtime execution to go faster.

Dynamic type checking checks the data types at runtime. This allows more flexibility and complexity at runtime but slows down execution, is less safe, and is harder to debug. 

Development Environment

Some languages have very simple development environments. EG: Any text editor.

Some have more sophisticated development environments, usually called an IDE (Integrated Development Environment). The IDEs usually have a GUI (Graphical User Interface), whereas the simpler development environments are usually text based, i.e. non-GUI.

Free-Form

In earlier programs, the positioning of characters was significant because physical punch cards were used and the idea of positioned characters was carried over. A free-form language uses whitespace (instead of positioning) to delimit tokens (the smallest lexical component of a programming language).

Imperative v Declarative

Imperative programming (aka procedural programming) is computation that retains knowledge of the system state. Imperative programming describes what is done and how. Most languages are imperative (EGs: FORTRAN; ALGOL; PASCAL; C; Ada; Java. See also Imperative programming languages [W]).

Declarative programming is computation that offhands the system state. Declarative programming describes what is done but not how.

Here is a rough definition of functional programming.

Functional programming is a style of programming that emphasizes the evaluation of expressions, rather than execution of commands. The expressions in these language are formed by using functions to combine basic values. A functional language is a language that supports and encourages programming in a functional style. -FAQ at comp.lang.functional.

Bottom line: A solution that takes many lines of code in imperative languages (EGs: C, Java, C#), might only take a few lines of code in a functional language (EGs: Lisp, Scheme, ML, Haskell, Caml, F#). This is because much lower-level (like numerous for-loops and massive overloading) is handled very easily.

See also the comp.lang.functional FAQ [§].

Imperative v Functional

Language Level

The more a programming language resembles machine language, the "lower" it is considered. In the early days of computers, humans had to manipulate the hardware directly. Then they developed pairs of machine and assembly languages for each kind of system. Since then it has become much more common to use high-level languages. However, humans still write in assembly language for cases of extreme speed or for when functionality not available to a high-level language.

 

Object Oriented

POP (Process Oriented Programming) conceptually focuses on developing processes whereas OOP develops objects and the processes involved with them. A POP program tends to start at the first line of code and then proceed on through the program in a particular sequence.

OOP (Object Oriented Programming) has three signature principles:

OOP allows you to make classes (and hence objects) that encapsulate the data and the functions that operate on that data. This makes programs more modular and thus easier to debug, reuse, maintain, and enhance. An OOP program tends to execute different sections of code in response to different events, such as clicking a button.

Programming language examples:

The quantity, quality, and types of class libraries that a language can work with (esp. built-in or by 3rd party vendors) are a tremendous factor in determining the power and applicability of a language.

Open Source

"Source" code is the version of a computer program that can be read and manipulated by programmers. Source code is eventually translated into assembly, i.e. machine language, raw binary instructions, that can be run as software.

There are two primary rights that are important regarding software distribution: editorial and financial. This is usually established by a copyright license.

While the term "free" is confusing (Free-source or free-cost or both?), it is nevertheless historically entangled with the whole idea of "open source". Hopefully the schism between the two camps will settle and disappear.

  GRATIS
No Cost
Free Beer		 COMMERCIAL
Some Cost
Priced Beer
LIBRE
Open Source
Free Speech
  • EG: Mozilla Firefox, a web browser.
  • Public domain software.
  • Free software. Aka FLOSS or F/LOSS (Free/Libre Open Source Software); GLOSS or G/LOSS (Gratis/Libre OSS); or some other combination.
  • EG: Red Hat Linux, an operating system.
  • OSS (Open Source Software).
  • Shared source. Microsoft is sharing some source code but staying commercial.
PROPRIETARY
Closed Source
Censored Speech
  • EG: Microsoft Internet Explorer, a web browser.
  • Freeware. Usually gratis but if used commercially then there is a charge.
    • Baitware. Software that is more like an ad or a tease.
  • Shareware. Aka trialware; demoware. Half-gratis. Distributed free on a trial basis. Shareware may be a limited version of the full version or has some annoying feature.
    • Adware. Advertising supported software. Usually annoying.
    • Beerware. The only possible cost is a beer or some other minor contribution.
    • Careware. Aka charityware; donateware. The only possible cost is a contribution to a charity.
    • Crippleware. Aka hostageware. A very limited version of the full version.
    • Emailware. The only possible cost is that the user send the maker an email.
    • Nagware. Has some annoying feature until paid for.
    • Postcardware. The only possible cost is that the user send the maker a postcard.
  • EG: Microsoft Windows, an operating system.
  • Abondonware. Proprietary commercial software that is no longer supported by the copyright holder. Many feel that these should be moved into the public domain.
  • Private software.

Some distinctions:

1983. Richard Stallman invented the concept of "free software" in response to his perception of restrictiveness at MIT.edu. His GNU project (GNU's Not Unix) is most famous for its free-source version of Unix. The GNU projecet has grown from Gnu.org into the Free Software Foundation [FSF.org]. Many licenses are still modeled upon the GPL (aka GNU General Public License; GNU GPL).

"Free software'' is a matter of liberty, not price. To understand the concept, you should think of "free'' as in "free speech,'' not as in "free beer.''

Free software is a matter of the users' freedom to run, copy, distribute, study, change and improve the software. More precisely, it refers to four kinds of freedom, for the users of the software:

  • The freedom to run the program, for any purpose (freedom 0).
  • The freedom to study how the program works, and adapt it to your needs (freedom 1). Access to the source code is a precondition for this.
  • The freedom to redistribute copies so you can help your neighbor (freedom 2).
  • The freedom to improve the program, and release your improvements to the public, so that the whole community benefits (freedom 3). Access to the source code is a precondition for this.

- GNU.org/philosophy/free-sw.html

The Open Source Definition [off-site] was first drafted by Bruce Perens in 1997 as "The Debian Free Software Guidelines". The term "open source" was derived in 1998 by Bruce Perens, Eric S. Raymond, and others who formed the OSI (Open Source Initiative) [OpenSource.org]. They list many licenses that support open-source.

While there are many profit issues that need to be worked out, open source has been showing many advantages over closed-source: The advantage of open source v closed source is similar to the advantage of parallel processing over serial processing because many, many programmers can work on an open source app, while only  the few that can work on a closed source app.

Some of the languages most associated with open source include: c/c++, java, perl, php, python, ruby, tcl, Eiffel, Lua, Smalltalk & Squeak.

2007-09-14 20:27:17Z