Genealogy of Programming Languages Assignment

Genealogy of Programming Languages Assignment Words: 6463

Genealogy of Programming Languages Pre-computer era Analytical engine The analytical engine, an important step in the history of computers, was the design of a mechanical general- purpose computer by the British mathematician Charles Babbage. It was first described in 1837. Because of financial, political, and legal issues, the engine was never built. In its logical design the machine was essentially modern, anticipating the first completed general-purpose computers by about 100 years.

The input (programs and data) was to be provided to the machine via punched cards, a method being used at the time to direct mechanical looms such as the Jacquard loom. For output, the machine would have a printer, a curve plotter and a bell. The machine would also be able to punch numbers onto cards to be read in later. It employed ordinary base-10 fixed-point arithmetic. There was to be a store (i. e. , a memory) capable of holding 1,000 numbers of 50 decimal digits each (ca. 20. 7kB). An arithmetical unit (the “mill”) would be able to perform all four arithmetic operations, plus comparisons and optionally square roots.

Don’t waste your time!
Order your assignment!

order now

Like the central processing unit (CPU) in a modern computer, the mill would rely upon its own internal procedures, to be stored in the form of pegs inserted into rotating drums called “barrels,” in order to carry out some of the more complex instructions the user’s program might specify. The programming language to be employed by users was akin to modern day assembly languages. Loops and conditional branching were possible and so the language as conceived would have been Turing-complete long before Alan Turing’s concept.

Three different types of punch cards were used: one for arithmetical operations, one for numerical constants, and one for load and store operations, transferring numbers from the store to the arithmetical unit or back. There were three separate readers for the three types of cards. Early computer era Plankalkl Plankalkl is a computer language developed for engineering purposes by Konrad Zuse. It was the _rst high- level non-von Neumann programming language to be designed for a computer and was designed between 1943 and 1945.

Also, notes survive with scribblings about such a plan calculation dating back to 1941. Plankalkl was not published at that time owing to a combination of factors such as conditions in wartime and postwar Nazi Germany. By 1946, Zuse had written a book on the subject but this remained unpublished. In 1948 Zuse published a paper about the Plankalkl in the “Archiv der Mathematik” but still did not attract much feedback – for a long time to come programming a computer would only be thought of as programming with machine code.

The Plankalkl was eventually more comprehensively published in 1972 and the first compiler for it was implemented in 1998. Another independent implementation followed in the year 2000 by the Free University of Berlin. Plankalkl drew comparisons to APL and relational algebra. It includes assignment statements, subroutines, conditional statements, iteration, floating point arithmetic, arrays, hierarchical record structures, assertions, exception handling, and other advanced features such as goal-directed execution.

Thus, this language included many of the syntactical elements of structured programming languages that would be invented later, but it failed to be recognized widely. Short Code Short Code was one of the first higher-level languages ever developed for an electronic computer. Unlike machine code, Short Code statements represented mathematic expressions rather than a machine instruction. Short Code was proposed by John Mauchly in 1949 and originally known as Brief Code. William Schmitt implemented a version of Brief Code in 1949 for the BINAC computer, though it was never debugged and tested.

The following year Schmitt implemented a new version of Brief Code for the UNIVAC I where it was now known as Short Code. While Short Code represented expressions, the representation itself was not direct and required a process of manual conversion. Elements of an expression were represented by two-character codes and then divided into 6-code groups in order to conform to the 12 byte words used by BINAC and Univac computers. Along with basic arithmetic, Short Code allowed for branching and calls to a library of functions.

The language was interpreted and ran about 50 times slower than machine code. A-0 The A-0 system (Arithmetic Language version 0), written by Grace Hopper in 1951 and 1952 for the UNIVAC I, was the first compiler ever developed for an electronic computer. The A-0 functioned more as a loader or linker than the modern notion of a compiler. A program was specified as a sequence of subroutines and arguments. The subroutines were identified by a numeric code and the arguments to the subroutines were written directly after each subroutine code.

The A-0 system converted the specification into machine code that could be fed into the computer a second time to execute the program. The A-0 system was followed by the A-1, A-2, A-3 (released as ARITH-MATIC), AT-3 (released as MATH-MATIC) and B-0 (released as FLOW-MATIC). Modern/Structured programming languages Fortran Fortran (previously FORTRAN) is a general-purpose, procedural, imperative programming language that is especially suited to numeric computation and scientific computing.

Originally developed by IBM in the 1950s for scientific and engineering applications, Fortran came to dominate this area of programming early on and has been in continual use for over half a century in computationally intensive areas such as numerical weather prediction, finite element analysis, computational fluid dynamics (CFD), computational physics, and computational chemistry. It is one of the most popular languages in the area of high-performance computing and is the language used for programs that benchmark and rank the world’s fastest supercomputers.

Fortran (a blend derived from The IBM Mathematical Formula Translating System) encompasses a lineage of versions, each of which evolved to add extensions to the language while usually retaining compatibility with previous versions. Successive versions have added support for processing of character-based data (FORTRAN 77), array programming, modular programming and object-based programming (Fortran 90 / 95), and object- oriented and generic programming (Fortran 2003). Algol ALGOL (short for ALGOrithmic Language) is a family of imperative computer programming languages originally developed in the mid 1950s which greatly nfluenced many other languages and became the de facto way algorithms were described in textbooks and academic works for almost the next 30 years. It was designed to avoid some of the perceived problems with FORTRAN and eventually gave rise to many other programming languages (including BCPL, B, Pascal, Simula and C). ALGOL introduced code blocks and was the first language to use begin and end pairs for delimiting them. John Backus developed the Backus normal form method of describing programming languages specifically for ALGOL 58.

It was revised and expanded by Peter Naur for ALGOL 60, and at Donald Knuth’s suggestion renamed BackusNaur Form. Niklaus Wirth based his own ALGOLWon ALGOL 60 before moving to develop Pascal. LISP LISP is a family of computer programming languages with a long history and a distinctive, fully parenthesized syntax. Originally specified in 1958, Lisp is the second-oldest high-level programming language in widespread use today; only Fortran is older. Like Fortran, Lisp has changed a great deal since its early days, and a number of dialects have existed over its history.

Today, the most widely known general-purpose Lisp dialects are Clojure, Common Lisp and Scheme. Lisp was originally created as a practical mathematical notation for computer programs, influenced by the notation of Alonzo Church’s lambda calculus. It quickly became the favored programming language for artificial intelligence (AI) research. As one of the earliest programming languages, Lisp pioneered many ideas in computer science, including tree data structures, automatic storage management, dynamic typing, and the self-hosting compiler. The name LISP derives from “LISt Processing”.

Linked lists are one of Lisp languages’ major data structures, and Lisp source code is itself made up of lists. As a result, Lisp programs can manipulate source code as a data structure, giving rise to the macro systems that allow programmers to create new syntax or even new domain-specific programming languages embedded in Lisp. Cobol COBOL is one of the oldest programming languages. Its name is an acronym for COmmon Business-Oriented Language, defining its primary domain in business, finance, and administrative systems for companies and governments. A pecification of COBOL was initially created during the second half of 1959 by Grace Hopper. The specifications were to a great extent inspired by the FLOW-MATIC language invented by Grace Hopper, commonly referred to as “the mother of the COBOL language”. Since 1959 COBOL has undergone several modifications and improvements. In an attempt to overcome the problem of incompatibility between different versions of COBOL, the American National Standards Institute (ANSI) developed a standard form of the language in 1968. This version was known as American National Standard (ANS) COBOL.

In 1974, ANSI published a revised version of (ANS) COBOL, containing a number of features that were not in the 1968 version. In 1985, ANSI published still another revised version that had new features not in the 1974 standard. The language continues to evolve today. The COBOL 2002 standard includes support for object-oriented programming and other modern language features. Simula Simula is a name for two programming languages, Simula I and Simula 67, developed in the 1960s at the Norwegian Computing Center in Oslo, by Ole-Johan Dahl and Kristen Nygaard. Syntactically, it is a fairly faithful superset of Algol 60.

Simula 67 introduced objects, classes, subclasses, virtual methods, coroutines, discrete event simulation, and features garbage collection. Simula is considered the first object-oriented programming language. As its name implies, Simula was designed for doing simulations, and the needs of that domain provided the framework for many of the features of object-oriented languages today. Simula has been used in a wide range of applications such as simulating VLSI designs, process modeling, protocols, algorithms, and other applications such as typesetting, computer graphics, and education.

Since Simula-type objects are reimplemented in C++, Java and C# the inuence of Simula is often understated. The creator of C++, Bjarne Stroustrup, has acknowledged that Simula 67 was the greatest influence on him to develop C++, to bring the kind of productivity enhancements offered by Simula to the raw computational speed offered by lower level languages like BCPL. Basic In computer programming, BASIC (an acronym for Beginner’s All-purpose Symbolic Instruction Code) is a family of high-level programming languages.

The original BASIC was designed in 1964 by John George Kemeny and Thomas Eugene Kurtz at Dartmouth College in New Hampshire, USA to provide computer access to non-science students. At the time, nearly all use of computers required writing custom software, which was something only scientists and mathematicians tended to be able to do. The language and its variants became widespread on microcomputers in the late 1970s and 1980s. The language was based partly on FORTRAN II and partly on ALGOL 60.

It was intended to address the complexity issues of older languages with a new language design specifically for the new class of users that the then new time-sharing systems allowed that is, a less technical user who did not have the mathematical background of the more traditional users and was not interested in acquiring it. Being able to use a computer to support teaching and research was quite novel at the time. The eight original design principles of BASIC were: * Be easy for beginners to use. * Be a general-purpose programming language. * Allow advanced features to be added for experts (while keeping the language simple for beginners). Be interactive. * Provide clear and friendly error messages. * Respond quickly for small programs. * Not to require an understanding of computer hardware. * Shield the user from the operating system. BASIC remains popular to this day in a handful of highly modi_ed dialects and new languages influenced by BASIC such as Microsoft Visual Basic. As of 2006, 59% of developers for the . NET platform used Visual Basic . NET as their only language. ISWIM ISWIM is an abstract computer programming language (or a family of programming languages) devised by Peter J.

Landin and first described in his article, The Next 700 Programming Languages, published in the Communications of the ACM in 1966. The acronym stands for “If you See What I Mean”. Although not implemented, it has proved very influential in the development of programming languages, especially functional programming languages such as SASL, Miranda, ML, Haskell and their successors. A notationally distinctive feature of ISWIM is its use of where clauses. An ISWIM program is a single expression qualified by where clauses (auxiliary definitions including equations among variables), conditional expressions and function definitions.

With CPL, ISWIM was one of the first programming languages to use where clauses, which are used widely in functional and declarative programming languages. Pascal Pascal is an influential imperative and procedural programming language, designed in 1968/9 and published in 1970 by Niklaus Wirth as a small and efficient language intended to encourage good programming practices using structured programming and data structuring. Pascal is based on the ALGOL programming language and named in honor of the French mathematician and philosopher Blaise Pascal.

Wirth subsequently developed the Modula-2 and Oberon, languages similar to Pascal. Before, and leading up to Pascal, Wirth developed the language Euler, followed by Algol-W. Initially, Pascal was largely, but not exclusively, intended to teach students structured programming. Generations of students have used Pascal as an introductory language in undergraduate courses. A derivative known as Object Pascal was designed for object oriented programming. Smalltalk Smalltalk is an object-oriented, dynamically typed, reflective programming language.

Smalltalk was created as the language to underpin the “new world” of computing exemplified by “humancomputer symbiosis. ” It was designed and created in part for educational use at the Learning Research Group of Xerox PARC by Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Scott Wallace, and others during the 1970s. The language was first generally released as Smalltalk-80 and has been widely used since. Smalltalk-like languages are in continuing active development, and have gathered loyal communities of users around them. ANSI Smalltalk was ratified in 1998 and represents the standard version of Smalltalk.

One of the early versions, Smalltalk-76, was one of the first programming languages to be implemented along with a development environment featuring most of the now familiar tools, including a class library code browser/editor. Smalltalk-80 added metaclasses, to help maintain the everything is an object” (except private instance variables) paradigm by associating properties and behavior with individual classes. Smalltalk programs are usually compiled to bytecode, which is then interpreted by a virtual machine or dynamically translated into machine-native code as in just-in-time compilation.

Smalltalk has influenced the wider world of computer programming in four main areas. It inspired the syntax and semantics of other computer programming languages. Secondly, it was a prototype for a model of computation known as message passing. Thirdly, its WIMP GUI inspired the windowing environments of personal computers in the late twentieth and early twenty-first centuries, so much so that the windows of the first Macintosh desktop look almost identical to the MVC windows of Smalltalk-80.

Finally, the integrated development environment was the model for a generation of visual programming tools that look like Smalltalk’s code browsers and debuggers. As in other object-oriented languages, the central concept in Smalltalk-80 (but not in Smalltalk-72) is that of an object. An object is always an instance of a class. Classes are lueprints” that describe the properties and behavior of their instances. For example, a Window class would declare that windows have properties such as the label, the position and whether the window is visible or not.

The class would also declare that instances support operations such as opening, closing, moving and hiding. Each particular Window object would have its own values of those properties, and each of them would be able to perform operations defined by its class. A Smalltalk object can do exactly three things: 1. Hold state (references to other objects). 2. Receive a message from itself or another object. 3. In the course of processing a message, send messages to itself or another object. The state an object holds is always private to that object.

Other objects can query or change that state only by sending requests (messages) to the object to do so. Any message can be sent to any object: when a message is received, the receiver determines whether that message is appropriate. (Alan Kay has commented that despite the attention given to objects, messaging is the most important concept in Smalltalk. ) Smalltalk is a “pure” object-oriented programming language, meaning that, unlike Java and C++, there is no difference between values which are objects and values which are primitive types.

In Smalltalk, primitive values such as integers, booleans and characters are also objects, in the sense that they are instances of corresponding classes, and operations on them are invoked by sending messages. A programmer can change the classes that implement primitive values, so that new behavior can be defined for their instances -for example, to implement new control structures -or even so that their existing behavior will be changed. This fact is summarized in the commonly heard phrase “In Smalltalk everything is an object”. Since all values are objects, classes themselves are also objects.

Each class is an instance of the metaclass of that class. Metaclasses in turn are also objects, and are all instances of a class called Metaclass. Code blocks are also objects. Smalltalk-80 is a totally reflective system, implemented in Smalltalk-80 itself. Smalltalk-80 provides both structural and computational reflection. Smalltalk is a structurally reflective system whose structure is defined by Smalltalk-80 objects. The classes and methods that define the system are themselves objects and fully part of the system that they help define.

The Smalltalk compiler compiles textual source code into method objects, typically instances of CompiledMethod. These get added to classes by storing them in a class’s method dictionary. The part of the class hierarchy that defines classes can add new classes to the system. The system is extended by running Smalltalk-80 code that creates or defines classes and methods. In this way a Smalltalk-80 system is a “living” system, carrying around the ability to extend itself at run time. Since the classes are themselves objects, they can be asked questions such as “what methods do you implement? or “what fields/slots/instance variables do you define? “. So objects can easily be inspected, copied, (de)serialized and so on with generic code that applies to any object in the system. Smalltalk-80 also provides computational reflection, the ability to observe the computational state of the system. In languages derived from the original Smalltalk-80 the current activation of a method is accessible as an object named via a keyword, thisContext. By sending messages to thisContext a method activation can ask questions like who sent this message to me”.

These facilities make it possible to implement co-routines or Prolog-like back-tracking without modifying the virtual machine. When an object is sent a message that it does not implement, the virtual machine sends the object the doesNotUnderstand: message with a reification of the message as an argument. The message (another object, an instance of Message) contains the selector of the message and an Array of its arguments. In an interactive Smalltalk system the default implementation of doesNotUnderstand: is one that opens an error window reporting the error to the user.

Through this and the reflective facilities the user can examine the context in which the error occurred, redefine the offending code, and continue, all within the system, using Smalltalk-80’s reflective facilities. C C is a general-purpose computer programming language developed in 1972 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system. Although C was designed for implementing system software, it is also widely used for developing portable application software. C is one of the most popular programming languages.

It is widely used on many different software platforms, and there are few computer architectures for which a C compiler does not exist. C has greatly influenced many other popular programming languages, most notably C++, which originally began as an extension to C. C is an imperative (procedural) systems implementation language. It was designed to be compiled using a relatively straightforward compiler, to provide low-level access to memory, to provide language constructs that map efficiently to machine instructions, and to require minimal run-time support.

C was therefore useful for many applications that had formerly been coded in assembly language. Despite its low-level capabilities, the language was designed to encourage machine-independent programming. A standards-compliant and portably written C program can be compiled for a very wide variety of computer platforms and operating systems with little or no change to its source code. The language has become available on a very wide range of platforms, from embedded microcontrollers to supercomputers. C also exhibits the following more specific characteristics: * lack of nested function definitions variables may be hidden in nested blocks * partially weak typing; for instance, characters can be used as integers * low-level access to computer memory by converting machine addresses to typed pointers * function and data pointers supporting ad hoc run-time polymorphism * array indexing as a secondary notion, defined in terms of pointer arithmetic * a preprocessor for macro definition, source code _le inclusion, and conditional compilation * complex functionality such as I/O, string manipulation, and mathematical functions consistently delegated to library routines * A relatively small set of reserved keywords C does not have some features that are available in some other programming languages: * No direct assignment of arrays or strings (copying can be done via standard functions; assignment of objects having struct or union type is supported) * No automatic garbage collection * No requirement for bounds checking of arrays * No operations on whole arrays * No syntax for ranges, such as the A..

B notation used in several languages * Prior to C99, no separate Boolean type (zero/nonzero is used instead)[6] * No functions as parameters (only function and variable pointers) * No exception handling; standard library functions signify error conditions with the global errno variable and/or special return values * Only rudimentary support for modular programming * No compile-time polymorphism in the form of function or operator overloading * Only rudimentary support for generic programming * Very limited support for object-oriented programming with regard to polymorphism and inheritance * Limited support for encapsulation No native support for multithreading and networking * No standard libraries for computer graphics and several other application programming needs Prolog Prolog is a general purpose logic programming language associated with artificial intelligence and computational linguistics. Prolog has its roots in formal logic, and unlike many other programming languages, Prolog is declarative: The program logic is expressed in terms of relations, represented as facts and rules. Execution is triggered by running queries over these relations.

The language was first conceived by a group around Alain Colmerauer in Marseille, France, in the early 1970s and the first Prolog system was developed in 1972 by Alain Colmerauer and Phillipe Roussel. Prolog was one of the first logic programming languages, and remains among the most popular such languages today, with many free and commercial implementations available. While initially aimed at natural language processing, the language has since then stretched far into other areas like theorem proving, expert systems, games, automated answering systems, ontologies and sophisticated control systems.

Modern Prolog environments support the creation of graphical user interfaces, as well as administrative and networked applications. ML ML is a general-purpose functional programming language developed by Robin Milner and others in the late 1970s at the University of Edinburgh, whose syntax is inspired by ISWIM. Historically, ML stands for metalanguage: it was conceived to develop proof tactics in the LCF theorem prover (whose language, pplambda, a combination of the first-order predicate calculus and the simply typed polymorphic lambda- calculus, had ML as its metalanguage).

It is known for its use of the Hindley-Milner type inference algorithm, which can automatically infer the types of most expressions without requiring explicit type annotations. ML is often referred to as an impure functional language, because it does not encapsulate side-effects, unlike purely functional programming languages such as Haskell. Features of ML include a call-by-value evaluation strategy, first class functions, automatic memory management through garbage collection, parametric polymorphism, static typing, type inference, algebraic data types, pattern matching, and exception handling.

Unlike Haskell, ML uses eager evaluation, which means that all subexpressions are always evaluated. However, lazy evaluation can be achieved through the use of closures. Thus one can create and use infinite streams as in Haskell, however, their expression is comparatively indirect. Today there are several languages in the ML family; the two major dialects are Standard ML (SML) and Caml, but others exist, including F# – a language which Microsoft supports for their . NET platform. Ideas from ML have influenced numerous other languages, like ML; , Haskell, Cyclone, and Nemerle.

ML’s strengths are mostly applied in language design and manipulation (compilers, analyzers, theorem provers), but it is a general-purpose language also used in bioinformatics, financial systems, and applications including a genealogical database, a peer-to-peer client/server program, etc. Scheme Scheme is one of the two main dialects of the programming language Lisp. Unlike Common Lisp, the other main dialect, Scheme follows a minimalist design philosophy specifying a small standard core with powerful tools for language extension.

Its compactness and elegance have made it popular with educators, language designers, programmers, implementors, and hobbyists, and this diverse appeal is seen as both a strength and, because of the diversity of its constituencies and the wide divergence between implementations, one of its weaknesses. Scheme was developed at the MIT AI Lab by Guy L. Steele and Gerald Jay Sussman who introduced it to the academic world via a series of memos, now referred to as the Lambda Papers, over the period 1975-1980. Scheme had a significant influence on the effort that led to the development of its sister, Common LISP.

C++ C++ is a statically typed, free-form, multi-paradigm, compiled, general-purpose programming language. It is regarded as a middle-level language, as it comprises a combination of both high-level and low-level language features. It was developed by Bjarne Stroustrup starting in 1979 at Bell Labs as an enhancement to the C programming language and originally named “C with Classes”. It was renamed C++ in 1983. C++ is widely used in the software industry, and remains one of the most popular languages ever created.

Some of its application domains include systems software, application software, device drivers, embedded software, high-performance server and client applications, and entertainment software such as video games. Several groups provide both free and proprietary C++ compiler software, including the GNU Project, Microsoft, Intel, Borland and others. The language began as enhancements to C, first adding classes, then virtual functions, operator over-loading, multiple inheritance, templates, and exception handling among other features. Stroustrup began work on “C with Classes” in 1979.

The idea of creating a new language originated from Stroustrup’s experience in programming for his Ph. D. thesis. Stroustrup found that Simula had features that were very helpful for large software development, but the language was too slow for practical use, while BCPL (the ancestor of C) was fast but too low-level to be suitable for large software development. Remembering his Ph. D. experience, Stroustrup set out to enhance the C language with Simula-like features. C was chosen because it was general-purpose, fast, portable and widely used. Besides C and Simula, some other languages that inspired him were ALGOL 68, Ada, CLU and ML.

At first, the class, derived class, strong type checking, inlining, and default argument features were added to C via Cfront. The first commercial release occurred in October 1985. [3] In 1983, the name of the language was changed from C with Classes to C++ (++ being the increment operator in C and C++). New features were added including virtual functions, function name and operator overloading, references, constants, user-controlled free-store memory control, improved type checking, and BCPL style single-line comments with two forward slashes (//).

In 1985, the first edition of The C++ Programming Language was released, providing an important reference to the language, since there was not yet an official standard. Release 2. 0 of C++ came in 1989. New features included multiple inheritance, abstract classes, static member functions, const member functions, and protected members. In 1990, The Annotated C++ Reference Manual was published. This work became the basis for the future standard. Late addition of features included templates, exceptions, namespaces, new casts, and a Boolean type.

As the C++ language evolved, a standard library also evolved with it. The _rst addition to the C++ standard library was the stream I/O library which provided facilities to replace the traditional C functions such as printf and scanf. Later, among the most signi_cant additions to the standard library, was the Standard Template Library. C++ continues to be used and is one of the preferred programming languages to develop professional applications. The language has gone from being mostly Western to attracting programmers from all over the world.

Bjarne Stroustrup describes some rules that he uses for the design of C++: * C++ is designed to be a statically typed, general-purpose language that is as efficient and portable as C * C++ is designed to directly and comprehensively support multiple programming styles (procedural programming, data abstraction, object-oriented programming, and generic programming) * C++ is designed to give the programmer choice, even if this makes it possible for the programmer to choose incorrectly * C++ is designed to be as compatible with C as possible, therefore providing a smooth transition from C * C++ avoids features that are platform specific or not general purpose * C++ does not incur overhead for features that are not used (the “zero-overhead principle”) * C++ is designed to function without a sophisticated programming environment Stroustrup also mentions that C++ was always intended to make programming more fun and that many of the double meanings in the language are intentional, such as the name of the language. Ada

Ada is a structured, statically typed, imperative, wide-spectrum, and object-oriented high-level computer programming language, extended from Pascal and other languages. It was originally designed by a team led by Jean Ichbiah of CII Honeywell Bull under contract to the United States Department of Defense (DoD) from 1977 to 1983 to supersede the hundreds of programming languages then used by the DoD. Ada is strongly typed and compilers are validated for reliability in mission-critical applications, such as avionics software. Ada was named after Ada Lovelace (18151852), who is often credited as being the first computer programmer. Perl Perl is a high-level, general-purpose, interpreted, dynamic programming language.

Perl was originally developed by Larry Wall, a linguist working as a systems administrator for NASA, in 1987, as a general-purposeUnix scripting language to make report processing easier. Since then, it has undergone many changes and revisions and become widely popular amongst programmers. Larry Wall continues to oversee development of the core language, and its upcoming version, Perl 6. Perl borrows features from other programming languages including C, shell scripting (sh), AWK, and sed. The language provides powerful text processing facilities without the arbitrary data length limits of many contemporary Unix tools, facilitating easy manipulation of text files.

It is also used for graphics programming, system administration, network programming, applications that require database access and CGI programming on the Web. Python Python is a general-purpose high-level programming language. Its design philosophy emphasizes code readability. Python claims to [combine] remarkable power with very clear syntax”, and its standard library is large and comprehensive. Its use of indentation for block delimiters is unusual among popular programming languages. Python supports multiple programming paradigms (primarily object oriented, imperative, and functional) and features a fully dynamic type system and automatic memory management, similar to Perl, Ruby, Scheme, and Tcl. Like other dynamic languages, Python is often used as a scripting language.

The language has an open, community-based development model managed by the non-profit Python Software Foundation, which maintains the de facto definition of the language in CPython, the reference implementation. Python is a multi-paradigm programming language. Rather than forcing programmers to adopt a particular style of programming, it permits several styles: object-oriented programming and structured programming are fully supported, and there are a number of language features which support functional programming and aspect-oriented programming (including by metaprogramming and by magic methods). Many other paradigms are supported using extensions, such as pyDBC and Contracts for Python which allow Design by Contract. Python is often used as a scripting language for web applications, and has seen extensive use in the information security industry.

Python has been successfully embedded in a number of software products as a scripting language, including in finite element method software such as Abaqus, 3D animation packages such as Maya, MotionBuilder, Softimage, Cinema 4D, BodyPaint 3D, modo, and Blender, and 2D imaging programs like GIMP, Inkscape, Scribus, and Paint Shop Pro. It has even been used in several videogames. For many operating systems, Python is a standard component; it ships with most Linux distributions, with NetBSD, and OpenBSD, and with Mac OS X. Among the users of Python are YouTube and the original BitTorrent client. Large organizations that make use of Python include Google, Yahoo! , CERN and NASA. Haskell Haskell is a standardized, general-purpose purely functional programming language, with non-strict semantics and strong static typing. It is named after logician Haskell Curry. Haskell is a purely functional language, which means that in general, functions in Haskell do not have side effects.

There is a distinct type for representing side effects, orthogonal to the type of functions. A pure function may return a side effect which is subsequently executed, modeling the impure functions of other languages. Haskell has a non-strict semantics. Most implementations of Haskell use lazy evaluation. Haskell has a strong, static, type system based on Hindley-Milner type inference. Haskell’s principal innovation in this area is to add type classes, which were originally conceived as a principled way to add overloading to the language, but have since found many more uses Following the release of Miranda by Research Software Ltd, in 1985, interest in lazy functional languages grew.

By 1987, more than a dozen non-strict, purely functional programming languages existed. Of these, Miranda was the most widely used, but was not in the public domain. At the conference on Functional Programming Languages and Computer Architecture (FPCA ’87) in Portland, Oregon, a meeting was held during which participants formed a strong consensus that a committee should be formed to de_ne an open standard for such languages. The committee’s purpose was to consolidate the existing functional languages into a common one that would serve as a basis for future research in functional-language design. The first version of Haskell (“Haskell 1. 0”) was defined in 1990.

The committee’s efforts resulted in a series of language definitions. In late 1997, the series culminated in Haskell 98, intended to specify a stable, minimal, portable version of the language and an accompanying standard library for teaching, and as a base for future extensions. Java Java is a programming language originally developed by James Gosling at Sun Microsystems and released in 1995 as a core component of Sun Microsystems’ Java platform. The language derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities. Java applications are typically compiled to bytecode (class _le) that can run on any Java Virtual Machine (JVM) regardless of computer architecture.

Java is general-purpose, concurrent, class-based, and object-oriented, and is specifically designed to have as few implementation dependencies as possible. It is intended to let application developers “write once, run anywhere”. There were five primary goals in the creation of the Java language: * It should be “simple, object oriented, and familiar”. * It should be “robust and secure”. * It should be “architecture neutral and portable”. * It should execute with “high performance”. * It should be “interpreted, threaded, and dynamic”. Programs written in Java have a reputation for being slower and requiring more memory than those written in some other languages.

However, Java programs’ execution speed improved significantly with the introduction of Just-in-time compilation in 1997/1998 for Java 1. 1, the addition of language features supporting better code analysis, and optimizations in the Java Virtual Machine itself, such as HotSpot becoming the default for Sun’s JVM in 2000. Java uses an automatic garbage collector to manage memory in the object lifecycle. The programmer determines when objects are created, and the Java runtime is responsible for recovering the memory once objects are no longer in use. Once no references to an object remain, the unreachable memory becomes eligible to be freed automatically by the garbage collector.

Something similar to a memory leak may still occur if a programmer’s code holds a reference to an object that is no longer needed, typically when objects that are no longer needed are stored in containers that are still in use. If methods for a nonexistent object are called, a “null pointer exception” is thrown. One of the ideas behind Java’s automatic memory management model is that programmers be spared the burden of having to perform manual memory management. In some languages memory for the creation of objects is implicitly allocated on the stack, or explicitly allocated and deallocated from the heap. Either way, the responsibility of managing memory resides with the programmer. If the program does not deallocate an object, a memory leak occurs.

If the program attempts to access or deallocate memory that has already been deallocated, the result is undefined and difficult to predict, and the program is likely to become unstable and/or crash. This can be partially remedied by the use of smart pointers, but these add overhead and complexity. Note that garbage collection does not prevent ‘logical’ memory leaks, i. e. those where the memory is still referenced but never used. Garbage collection may happen at any time. Ideally, it will occur when a program is idle. It is guaranteed to be triggered if there is insufficient free memory on the heap to allocate a new object; this can cause a program to stall momentarily. Explicit memory management is not possible in Java.

Java does not support C/C++ style pointer arithmetic, where object addresses and unsigned integers (usually long integers) can be used interchangeably. This allows the garbage collector to relocate referenced objects, and ensures type safety and security. As in C++ and some other object-oriented languages, variables of Java’s primitive data types are not objects. This was a conscious decision by Java’s designers for performance reasons. Because of this, Java was not considered to be a pure object-oriented programming language. However, as of Java 5. 0, autoboxing enables programmers to proceed as if primitive types are instances of their wrapper classes.

How to cite this assignment

Choose cite format:
Genealogy of Programming Languages Assignment. (2020, Nov 30). Retrieved January 22, 2021, from