Top List Curated by Listnerd
  • Public list
  • Nov 27th 2012
  • 4.420 views
  • 27 votes
  • 3 voters
  • 0%
Best Programming Language of All Time

More about Best Programming Language of All Time:

Best Programming Language of All Time is a public top list created by Listnerd on rankly.com on November 27th 2012. Items on the Best Programming Language of All Time top list are added by the rankly.com community and ranked using our secret ranking sauce. Best Programming Language of All Time has gotten 4.420 views and has gathered 27 votes from 3 voters. O O

Best Programming Language of All Time is a top list in the Technology category on rankly.com. Are you a fan of Technology or Best Programming Language of All Time? Explore more top 100 lists about Technology on rankly.com or participate in ranking the stuff already on the all time Best Programming Language of All Time top list below.

If you're not a member of rankly.com, you should consider becoming one. Registration is fast, free and easy. At rankly.com, we aim to give you the best of everything - including stuff like the Best Programming Language of All Time list.

Get your friends to vote! Spread this URL or share:

Items just added

    1

    ANSI C

    • Influenced: C*
    ANSI C refers to the family of successive standards published by the American National Standards Institute (ANSI) for the C programming language. Software developers writing in C are encouraged to conform to the standards, as doing so aids portability between compilers. The first standard for C was published by ANSI. Although this document was subsequently adopted by International Organization for Standardization (ISO) and subsequent revisions published by ISO have been adopted by ANSI, the name ANSI C (rather than ISO C) is still more widely used. While some software developers use the term ISO C, others are standards body–neutral and use Standard C. In 1983, the American National Standards Institute formed a committee, X3J11, to establish a standard specification of C. After a long and arduous process, the standard was completed in 1989 and ratified as ANSI X3.159-1989 "Programming Language C." This version of the language is often referred to as "ANSI C", or sometimes "C89" (to distinguish it from C99). The same standard was ratified by the International Organization for Standardization as ISO/IEC 9899:1990, with only formatting changes, which is sometimes referred to as C90.
    10.00
    1 votes
    2

    Lambda calculus

    • Influenced: Unlambda
    Lambda calculus (also written as λ-calculus or called "the lambda calculus") is a formal system in mathematical logic for expressing computation by way of variable binding and substitution. It was first formulated by Alonzo Church as a way to formalize mathematics through the notion of functions, in contrast to the field of set theory. Although not very successful in that respect, the lambda calculus found early successes in the area of computability theory, such as a negative answer to Hilbert's Entscheidungsproblem. Because of the importance of the notion of variable binding and substitution, there is not just one system of lambda calculus. Historically, the most important system was the untyped lambda calculus. In the untyped lambda calculus, function application has no restrictions (so the notion of the domain of a function is not built into the system). In the Church–Turing Thesis, the untyped lambda calculus is claimed to be capable of computing all effectively calculable functions. The typed lambda calculus is a variety that restricts function application, so that functions can only be applied if they are capable of accepting the given input's "type" of data. Today, the
    10.00
    1 votes
    3

    Scheme

    • Language Paradigms: Functional programming
    • Influenced: Common Lisp
    • Influenced By: Lisp
    Scheme is a functional programming language and 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. The language's diverse appeal is seen as a strong point, though the consequently wide divergence between implementations is seen as one of the language's weak points. 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. The Scheme language is standardized in the official IEEE standard, and a de facto standard called the Revised Report on the Algorithmic Language Scheme (RnRS). The most widely implemented standard is R5RS (1998), and a new standard R6RS was ratified in 2007. Scheme was the first dialect of Lisp to choose lexical scope and the first to require implementations to perform tail-call optimization. It was also one of the
    10.00
    1 votes
    4
    PLT Scheme

    PLT Scheme

    • Language Paradigms: Functional programming
    • Influenced: Scheme
    • Influenced By: Scheme
    Racket (formerly named PLT Scheme) is a general purpose, multi-paradigm programming language in the Lisp/Scheme family. One of its design goals is to serve as a platform for language creation, design, and implementation. The language is used in a variety of contexts such as scripting, general-purpose programming, computer science education, and research. The platform provides an implementation of the Racket language (including a sophisticated run-time system, various libraries, JIT compiler, and more) along with a development environment called DrRacket (formerly named DrScheme) written in Racket itself. The IDE and an accompanying programming curriculum is used in the ProgramByDesign outreach program, an attempt to turn computing and programming into "an indispensable part of the liberal arts curriculum". The core language is known for its extensive macro system which enables the creation of embedded and domain-specific languages, language constructs such as classes or modules, and separate dialects of Racket with different semantics. The platform distribution is free and open source software distributed under the LGPL license. Extensions and packages written by the community are
    9.00
    1 votes
    5
    Ruby

    Ruby

    • Language Paradigms: Reflective programming
    • Influenced: Groovy
    • Influenced By: Smalltalk
    Ruby is a dynamic, reflective, general-purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features. It was also influenced by Eiffel and Lisp. Ruby was first designed and developed in the mid-1990s by Yukihiro "Matz" Matsumoto in Japan. Ruby supports multiple programming paradigms, including functional, object oriented, imperative and reflective. It also has a dynamic type system and automatic memory management; it is therefore similar in varying respects to Smalltalk, Python, Perl, Lisp, Dylan, Pike, and CLU. The standard 1.8.7 implementation is written in C, as a single-pass interpreted language. The language specifications for Ruby were developed by the Open Standards Promotion Center of the Information-Technology Promotion Agency (a Japanese government agency) for submission to the Japanese Industrial Standards Committee and then to the International Organization for Standardization. It was accepted as a Japanese Industrial Standard (JIS X 3017) in 2011 and an international standard (ISO/IEC 30170) in 2012. As of 2010, there are a number of complete or upcoming alternative implementations of Ruby, including YARV, JRuby,
    9.00
    1 votes
    6
    DRAKON

    DRAKON

    DRAKON (Russian: ДРАКОН, "dragon" – backronym for Дружелюбный Русский Алгоритмический язык, Который Обеспечивает Наглядность, "friendly Russian algorithmic language that guarantees clarity") is an algorithmic visual programming language developed for the Buran space project. Its development, started in 1986, was directed by Vladimir Parondzhanov. The goal was to replace specialised languages PROL2 (ПРОЛ2), DIPOL (ДИПОЛЬ) and LAKS (ЛАКС) used in the Buran project with one universal language. The work was finished in 1996 (3 years after the Buran project was officially closed), when an automated CASE programming system called "Grafit-Floks" was developed. After that it was used in Sea Launch and other space projects. DRAKON rules for creating diagrams are cognitively optimised for easy comprehension, making it a tool for intelligence augmentation. This article may be expanded with text translated from the corresponding article ru:ДРАКОН in the Russian Wikipedia.
    5.50
    2 votes
    7
    R

    R

    • Language Paradigms: Functional programming
    • Influenced: PCASTL
    • Influenced By: S programming language
    R is an open source programming language and software environment for statistical computing and graphics. The R language is widely used among statisticians for developing statistical software and data analysis. R is an implementation of the S programming language combined with lexical scoping semantics inspired by Scheme. S was created by John Chambers while at Bell Labs. R was created by Ross Ihaka and Robert Gentleman at the University of Auckland, New Zealand, and now, R is developed by the R Development Core Team, of which Chambers is a member. R is named partly after the first names of the first two R authors (Robert Gentleman and Ross Ihaka), and partly as a play on the name of S. R is part of the GNU project. The source code for the R software environment is written primarily in C, Fortran, and R. R is freely available under the GNU General Public License, and pre-compiled binary versions are provided for various operating systems. R uses a command line interface; however, several graphical user interfaces are available for use with R. R provides a wide variety of statistical and graphical techniques, including linear and nonlinear modeling, classical statistical tests,
    8.00
    1 votes
    8
    Haskell

    Haskell

    • Language Paradigms: Functional programming
    • Influenced: Python
    • Influenced By: ML
    Haskell (/ˈhæskəl/) is a standardized, general-purpose purely functional programming language, with non-strict semantics and strong static typing. It is named after logician Haskell Curry. In Haskell, "a function is a first-class citizen" of the programming language. As a functional programming language, the primary control construct is the function. The language is rooted in the observations of Haskell Curry and his intellectual descendants, that "a proof is a program; the formula it proves is a type for the program". 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 define 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
    7.00
    1 votes
    9
    Lisp

    Lisp

    • Language Paradigms: Procedural programming
    • Influenced: Dylan
    • Influenced By: Information Processing Language
    Lisp (historically, LISP) is a family of computer programming languages with a long history and a distinctive, fully parenthesized Polish prefix notation. Originally specified in 1958, Lisp is the second-oldest high-level programming language in widespread use today; only Fortran is older (by one year). 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 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
    7.00
    1 votes
    10
    Python

    Python

    • Language Paradigms: Object-oriented programming
    • Influenced: Ruby
    • Influenced By: Modula-3
    Python is a general-purpose, interpreted high-level programming language whose design philosophy emphasizes code readability. Its syntax is said to be clear and expressive. Python has a large and comprehensive standard library. Python supports multiple programming paradigms, primarily but not limited to object-oriented, imperative and, to a lesser extent, functional programming styles. It features a fully dynamic type system and automatic memory management, similar to that of Scheme, Ruby, Perl, and Tcl. Like other dynamic languages, Python is often used as a scripting language, but is also used in a wide range of non-scripting contexts. Using third-party tools, Python code can be packaged into standalone executable programs. Python interpreters are available for many operating systems. CPython, the reference implementation of Python, is free and open source software and has a community-based development model, as do nearly all of its alternative implementations. CPython is managed by the non-profit Python Software Foundation. Python was conceived in the late 1980s and its implementation was started in December 1989 by Guido van Rossum at CWI in the Netherlands as a successor to
    7.00
    1 votes
    11
    Assembly language

    Assembly language

    • Influenced: C
    An assembly language is a low-level programming language for a computer, microcontroller, or other programmable device, in which each statement corresponds to a single machine code instruction. Each assembly language is specific to a particular computer architecture, in contrast to most high-level programming languages, which are generally portable across multiple systems. Assembly language is converted into executable machine code by a utility program referred to as an assembler; the conversion process is referred to as assembly, or assembling the code. Assembly language uses a mnemonic to represent each low-level machine operation or opcode. Some opcodes require one or more operands as part of the instruction, and most assemblers can take labels and symbols as operands to represent addresses and constants, instead of hard coding them into the program. Macro assemblers include a macroinstruction facility so that assembly language text can be pre-assigned to a name, and that name can be used to insert the text into other code. Many assemblers offer additional mechanisms to facilitate program development, to control the assembly process, and to aid debugging. An assembler creates
    6.00
    1 votes
    12

    Perl

    • Language Paradigms: Object-oriented programming
    • Influenced: Ruby
    • Influenced By: C
    Perl is a high-level, general-purpose, interpreted, dynamic programming language. Though Perl is not officially an acronym, there are various backronyms in usage, such as: Practical Extraction and Reporting Language. Perl was originally developed by Larry Wall in 1987 as a general-purpose Unix scripting language to make report processing easier. Since then, it has undergone many changes and revisions. The latest major stable revision is 5.16, released in May 2012. Perl 6 is a complete redesign of the language, announced in 2000 and still under active development as of 2012. 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. Perl gained widespread popularity in the late 1990s as a CGI scripting language, in part due to its parsing abilities. In addition to CGI, Perl is used for graphics programming, system administration, network programming, finance, bioinformatics, and other applications. Perl is nicknamed "the Swiss Army chainsaw of scripting languages"
    6.00
    1 votes
    13
    PHP

    PHP

    • Language Paradigms: Object-oriented programming
    • Influenced: Ferite
    • Influenced By: Perl
    PHP is a general-purpose server-side scripting language originally designed for Web development to produce dynamic Web pages. It is one of the first developed server-side scripting languages to be embedded into an HTML source document rather than calling an external file to process data. The code is interpreted by a Web server with a PHP processor module which generates the resulting Web page. It also has evolved to include a command-line interface capability and can be used in standalone graphical applications. PHP can be deployed on most Web servers and also as a standalone shell on almost every operating system and platform free of charge. A competitor to Microsoft's Active Server Pages (ASP) server-side script engine and similar languages, PHP is installed on more than 20 million Web sites and 1 million Web servers. Software that uses PHP includes MediaWiki, Joomla, Wordpress, Concrete5, MyBB, and Drupal. PHP was originally created by Rasmus Lerdorf in 1995. The main implementation of PHP is now produced by The PHP Group and serves as the formal reference to the PHP language. PHP is free software released under the PHP License, which is incompatible with the GNU General Public
    6.00
    1 votes
    14
    *Lisp

    *Lisp

    • Language Paradigms: Parallel computing
    • Influenced By: Lisp
    The *Lisp (aka StarLisp) programming language was conceived of in 1985 by Cliff Lasser and Steve Omohundro (employees of the Thinking Machines Corporation) as a way of providing an efficient yet high-level language for programming the nascent Connection Machine. At the time the Connection Machine was being designed and built, the only language being actively developed for it was an Assembly-level language known as PARIS (Parallel Instruction Set). It became evident that a better way to program the machine was needed and needed quickly. Waiting for the completion of CM Lisp, or "Connection Machine Lisp" (an implementation of the very high-level programming language Lisp with parallel programming extensions) was not an option. CM Lisp had been proposed by Danny Hillis, and development was expected to continue for several more years. A *Lisp interpreter was initially developed. It quickly became apparent that a *Lisp compiler, translating *Lisp into Lisp and PARIS, would be needed to attain the gigaflop speeds that were theoretically attainable by a Connection Machine. The *Lisp compiler was written by Jeff Mincy and was first released in 1986. (An application achieving more than two
    5.00
    1 votes
    15

    Brainfuck

    • Language Paradigms: cell based
    • Influenced By: FALSE
    Brainfuck is an esoteric programming language noted for its extreme minimalism. It is a Turing tarpit, designed to challenge and amuse programmers, and was not made to be suitable for practical use. It was created in 1993 by Urban Müller. The name of the language is generally not capitalized except at the start of a sentence, although it is a proper noun. Urban Müller created brainfuck in 1993 with the intention of designing a language which could be implemented with the smallest possible compiler, inspired by the 1024-byte compiler for the FALSE programming language. Several brainfuck compilers have been made smaller than 200 bytes. The classic distribution is Müller's version 2, containing a compiler for the Amiga, an interpreter, example programs, and a readme document. The language consists of eight commands, listed below. A brainfuck program is a sequence of these commands, possibly interspersed with other characters (which are ignored). The commands are executed sequentially, except as noted below; an instruction pointer begins at the first command, and each command it points to is executed, after which it normally moves forward to the next command. The program terminates
    5.00
    1 votes
    16
    C++

    C++

    • Language Paradigms: Object-oriented programming
    • Influenced: D
    • Influenced By: C
    C++ (pronounced "see plus plus") is a statically typed, free-form, multi-paradigm, compiled, general-purpose programming language. It is regarded as an intermediate-level language, as it comprises a combination of both high-level and low-level language features. Developed by Bjarne Stroustrup starting in 1979 at Bell Labs, it adds object oriented features, such as classes, and other enhancements to the C programming language. Originally named C with Classes, the language was renamed C++ in 1983, as a pun involving the increment operator. C++ is one of the most popular programming languages and is implemented on a wide variety of hardware and operating system platforms. As an efficient compiler to native code, 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 and Embarcadero Technologies. C++ has greatly influenced many other popular programming languages, most notably C# and Java. Other successful languages such as
    3.00
    1 votes
    17
    Clojure

    Clojure

    • Language Paradigms: Functional programming
    • Influenced By: Erlang
    Clojure (pronounced like "closure") is a recent dialect of the Lisp programming language created by Rich Hickey. It is a functional general-purpose language. Its focus on programming with immutable values and explicit progression-of-time constructs are intended to facilitate the development of more robust programs, particularly multithreaded ones. Clojure runs on the Java Virtual Machine, Common Language Runtime, and JavaScript engines. Like other Lisps, Clojure treats code as data and has a sophisticated macro system. Rich Hickey is the creator of the Clojure programming language. Before Clojure, he developed dotLisp, a similar project based on the .NET platform. Hickey spent about 2½ years working on Clojure before releasing it to the world, much of that time working exclusively on Clojure without external funding. At the end of this period Hickey sent an email announcing the language to some friends in the Common Lisp community. Hickey developed Clojure because he wanted a modern Lisp for functional programming, symbiotic with the established Java platform, and designed for concurrency. Clojure's approach to concurrency is characterized by the concept of identities, which
    3.00
    1 votes
    18

    Emacs Lisp

    • Language Paradigms: Functional programming
    • Influenced By: Lisp
    Emacs Lisp is a dialect of the Lisp programming language used by the GNU Emacs and XEmacs text editors (which this article will refer to collectively as "Emacs"). It is used for implementing most of the editing functionality built into Emacs, the remainder being written in C (as is the Lisp interpreter itself). Users of Emacs commonly write Emacs Lisp code to customize and extend Emacs. Emacs Lisp can also function as a scripting language, much like the Unix Bourne shell, Perl, Python, scsh, or GNU Guile. Just as with those languages, it may be called from the command line or via an executable file. Its editing functions, such as buffers and movement commands, complement the features of Lisp and work in batch mode. Some people refer to Emacs Lisp as Elisp, at the risk of confusion with an older unrelated Lisp dialect with the same name. In terms of features, it is closely related to the Maclisp dialect, with some later influence from Common Lisp. It supports imperative and functional programming methods. Richard Stallman chose Lisp as the extension language for his rewrite of Emacs (the original used TECO as its extension language) because of its powerful features, including the
    3.00
    1 votes
    19
    JavaScript

    JavaScript

    • Language Paradigms: Ajax
    • Influenced: mjt
    • Influenced By: Self
    JavaScript (sometimes abbreviated JS) is a prototype-based scripting language that is dynamic, weakly typed and has first-class functions. It is a multi-paradigm language, supporting object-oriented, imperative, and functional programming styles. JavaScript was formalized in the ECMAScript language standard and is primarily used in the form of client-side JavaScript, implemented as part of a Web browser in order to create enhanced user interfaces and dynamic websites. This enables programmatic access to computational objects within a host environment. JavaScript's use in applications outside Web pages—for example in PDF documents, site-specific browsers, and desktop widgets—is also significant. Newer and faster JavaScript VMs and frameworks built upon them (notably Node.js) have also increased the popularity of JavaScript for server-side web applications. JavaScript uses syntax influenced by that of C. JavaScript copies many names and naming conventions from Java, but the two languages are otherwise unrelated and have very different semantics. The key design principles within JavaScript are taken from the Self and Scheme programming languages. JavaScript was originally developed in
    3.00
    1 votes
    20
    ASP.NET

    ASP.NET

    ASP.NET is a Web application framework developed and marketed by Microsoft to allow programmers to build dynamic Web sites, Web applications and Web services. It was first released in January 2002 with version 1.0 of the .NET Framework, and is the successor to Microsoft's Active Server Pages (ASP) technology. ASP.NET is built on the Common Language Runtime (CLR), allowing programmers to write ASP.NET code using any supported .NET language. The ASP.NET SOAP extension framework allows ASP.NET components to process SOAP messages. After four years of development, and a series of beta releases in 2000 and 2001, ASP.NET 1.0 was released on January 5, 2002 as part of version 1.0 of the .NET Framework. Even prior to the release, dozens of books had been written about ASP.NET, and Microsoft promoted it heavily as part of its platform for Web services. Scott Guthrie became the product unit manager for ASP.NET, and development continued apace, with version 1.1 being released on April 24, 2003 as a part of Windows Server 2003. This release focused on improving ASP.NET's support for mobile devices. ASP.NET Web pages, known officially as Web Forms, are the main building block for application
    2.00
    1 votes
    21
    BASIC

    BASIC

    • Language Paradigms: Procedural programming
    • Influenced: BBC BASIC
    • Influenced By: ALGOL
    BASIC is a family of general-purpose, high-level programming languages whose design philosophy emphasizes ease of use; the name is an acronym from Beginner's All-purpose Symbolic Instruction Code. The original Dartmouth 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 do. The language and its variants became widespread on microcomputers in the late 1970s and 1980s, when it was typically a standard feature, and often part of the firmware of the machine. The presence of an easy-to-learn language such as BASIC on these early personal computers allowed small business owners to develop their own custom application software, leading to widespread use of these computers in businesses that previously did not have access to computing technology. BASIC remains popular in numerous dialects and new languages influenced by BASIC such as Microsoft Visual Basic. In 2006, 59% of developers for the .NET Framework used Visual Basic .NET as their
    2.00
    1 votes
    22
    Cascading Style Sheets

    Cascading Style Sheets

    Cascading Style Sheets (CSS) is a style sheet language used for describing the presentation semantics (the look and formatting) of a document written in a markup language. Its most common application is to style web pages written in HTML and XHTML, but the language can also be applied to any kind of XML document, including plain XML, SVG and XUL. CSS is designed primarily to enable the separation of document content (written in HTML or a similar markup language) from document presentation, including elements such as the layout, colors, and fonts. This separation can improve content accessibility, provide more flexibility and control in the specification of presentation characteristics, enable multiple pages to share formatting, and reduce complexity and repetition in the structural content (such as by allowing for tableless web design). CSS can also allow the same markup page to be presented in different styles for different rendering methods, such as on-screen, in print, by voice (when read out by a speech-based browser or screen reader) and on Braille-based, tactile devices. It can also be used to allow the web page to display differently depending on the screen size or device on
    2.00
    1 votes
    23
    ActionScript

    ActionScript

    • Language Paradigms: Object-oriented programming
    • Influenced: HaXe
    • Influenced By: JavaScript
    ActionScript is an object-oriented language originally developed by Macromedia Inc. (now owned by Adobe Systems). It is a dialect of ECMAScript (meaning it is a superset of the syntax and semantics of the language more widely known as JavaScript), and is used primarily for the development of websites and software targeting the Adobe Flash Player platform, used on Web pages in the form of embedded SWF files. The language itself is open-source in that its specification is offered free of charge and both an open source compiler (as part of Adobe Flex) and open source virtual machine (Mozilla Tamarin) are available. ActionScript was initially designed for controlling simple 2D vector animations made in Adobe Flash (formerly Macromedia Flash). Initially focused on animation, early versions of Flash content offered few interactivity features and thus had very limited scripting capability. Later versions added functionality allowing for the creation of Web-based games and rich Internet applications with streaming media (such as video and audio). Today, ActionScript is suitable for use in some database applications, and in basic robotics, as with the Make Controller Kit. Flash MX 2004
    1.00
    1 votes
    24
    AppleScript

    AppleScript

    • Influenced By: Smalltalk
    AppleScript is a scripting language created by Apple Inc. and built into Macintosh operating systems since System 7. The term "AppleScript" may refer to the scripting system itself, or to particular scripts that are written in the AppleScript language. AppleScript is primarily an inter-application processing system, designed to exchange data between and control other applications in order to automate repetitive tasks. AppleScript has some limited processing abilities of its own – basic calculation abilities, and some more intricate text processing tools – and is extensible, allowing the addition of scripting additions which add new functions to the language itself. Mainly, however, AppleScript relies on the built-in functionality of other applications and processes to handle complex tasks. AppleScript has some elements of object-oriented programming, particularly in the construction of script objects, and some Lisp-like natural language programming tendencies, but does not strictly conform to either category. The AppleScript project was an outgrowth of the (now discontinued) HyperCard project. HyperCard contained an English language-based scripting language called HyperTalk, which
    1.00
    1 votes
    25
    JavaFX Script

    JavaFX Script

    • Language Paradigms: Object-oriented programming
    JavaFX Script is a scripting language designed by Sun Microsystems, forming part of the JavaFX family of technologies on the Java Platform. JavaFX targets the Rich Internet Application domain (competing with Adobe Flex and Microsoft Silverlight), specializing in rapid development of visually rich applications for the desktop and mobile markets. JavaFX Script works with integrated development environments such as NetBeans and Eclipse. JavaFX is released under the GNU General Public License, via the Sun sponsored OpenJFX project. JavaFX Script used to be called F3 for Form Follows Function. F3 was primarily developed by Chris Oliver, who became a Sun employee through their acquisition of SeeBeyond Technology Corporation in September 2005. Its name was changed to JavaFX Script, and it became open sourced at JavaOne 2007. All the code, documentation and demos are shared in the Project OpenJFX Development Website. JavaFX 1.0 was released on December 4, 2008. On September 10, 2010 Oracle announced at JavaOne that JavaFX Script would be discontinued, although the JavaFX API would be made available to other languages for the Java Virtual Machine. On September 27, 2010 Stephen Chin
    1.00
    1 votes
    26

    Objective-C

    • Language Paradigms: Object-oriented programming
    • Influenced: Tom
    • Influenced By: Smalltalk
    Objective-C is a general-purpose, high-level, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. It is the main programming language used by Apple for the OS X and iOS operating systems and their respective APIs, Cocoa and Cocoa Touch. Originally developed in the early 1980s, it was selected as the main language used by NeXT for its NeXTSTEP operating system, from which OS X and iOS are derived. Generic Objective-C programs that do not use these libraries can also be compiled for any system supported by GCC or Clang. Objective-C was created primarily by Brad Cox and Tom Love in the early 1980s at their company Stepstone. Both had been introduced to Smalltalk while at ITT Corporation's Programming Technology Center in 1981. The earliest work on Objective-C traces back to around that time. Cox was intrigued by problems of true reusability in software design and programming. He realized that a language like Smalltalk would be invaluable in building development environments for system developers at ITT. However, he and Tom Love also recognized that backward compatibility with C was critically important in ITT's telecom engineering
    1.00
    1 votes
    27
    3APL

    3APL

    An Abstract Agent Programming Language or Artificial Autonomous Agents Programming Language or 3APL (pronounced triple-A-P-L) is an experimental tool and programming language for the development, implementation and testing of multiple cognitive agents using the Belief-Desire-Intention (BDI) approach. 3APL was developed and is maintained by a team at the computer science department of the University of Utrecht in the Netherlands. It facilitates specification of cognitive agent behavior using actions, beliefs, goals, plans, and rules. It has been subject to at least 15 papers and conferences, and at least 4 theses. The 3APL platform has a visual interface for the monitoring and debugging of agents being run therein, and a syntax-coloring editor for source code editing. It has been released as a Java-based software, which comes with some specification Java interfaces that can be used to develop Java-based plug-ins and libraries. These can be used to provide a visible representation of a virtual environment, for instance. A 3APL platform can also connect in client or server roles to other 3APL platforms across a network, to allow communication among 3APL agents on each platform. A
    0.00
    0 votes
    28

    A++

    • Language Paradigms: Functional programming
    • Influenced By: Lambda calculus
    A++ stands for abstraction plus reference plus synthesis which is used as a name for the minimalistic programming language that is built on ARS. ARS is an abstraction from the Lambda Calculus, taking its three basic operations, and giving them a more general meaning, thus providing a foundation for the three major programming paradigms: functional programming, object-oriented programming and imperative programming. ARS Based Programming is used as a name for programming which consists mainly of applying patterns derived from ARS to programming in any language. A++ was developed in 2002 with the purpose to serve as a learning instrument rather than as a programming language used to solve practical problems. Dr. Barry came to this conclusion when taking suggestions from a local elemetary school where he often applied his technique. It is supposed to be an efficient tool to become familiar with the core of programming and with programming patterns that can be applied in other languages needed to face the real world. A++ is a language similar to C++, with its interpreter available in Scheme, Java, C, C++ and Python, and offers an ideal environment for basic training in programming,
    0.00
    0 votes
    29
    ABAP

    ABAP

    • Language Paradigms: Object-oriented programming
    • Influenced By: COBOL
    ABAP (Advanced Business Application Programming, originally Allgemeiner Berichts-Aufbereitungs-Prozessor, German for "general report creation processor") is a high-level programming language created by the German software company SAP. It is currently positioned, alongside the more recently introduced Java, as the language for programming the SAP Application Server, part of its NetWeaver platform for building business applications. The syntax of ABAP is somewhat similar to COBOL. ABAP is one of the many application-specific fourth-generation languages (4GLs) first developed in the 1980s. It was originally the report language for SAP R/2, a platform that enabled large corporations to build mainframe business applications for materials management and financial and management accounting. ABAP used to be an abbreviation of Allgemeiner BerichtsAufbereitungsProzessor, German for "generic report preparation processor", but was later renamed to the English Advanced Business Application Programming. ABAP was one of the first languages to include the concept of Logical Databases (LDBs), which provides a high level of abstraction from the basic database level(s). The ABAP programming language
    0.00
    0 votes
    30
    Ada

    Ada

    • Language Paradigms: Multi-paradigm programming language
    • Influenced: PL/SQL
    • Influenced By: Modula-2
    Ada is a structured, statically typed, imperative, wide-spectrum, and object-oriented high-level computer programming language, extended from Pascal and other languages. It has strong built-in language support for explicit concurrency, offering tasks, synchronous message passing, protected objects, and non-determinism. Ada is an international standard; the current version (known as Ada 2005) is defined by joint ISO/ANSI standard, combined with major Amendment ISO/IEC 8652:1995/Amd 1:2007. Ada 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 was named after Ada Lovelace (1815–1852), who is sometimes credited as being the first computer programmer. Ada was originally targeted at embedded and real-time systems. The Ada 95 revision, designed by S. Tucker Taft of Intermetrics between 1992 and 1995, improved support for systems, numerical, financial, and object-oriented programming (OOP). Notable features of Ada include: strong typing, modularity mechanisms (packages), run-time checking, parallel
    0.00
    0 votes
    31
    Agda theorem prover

    Agda theorem prover

    • Language Paradigms: Functional programming
    • Influenced By: Cayenne
    Agda is both a proof assistant for developing constructive proofs and a functional programming language with dependent types. More specifically, it is an interactive system for based on the idea of the Curry-Howard correspondence as embodied in Per Martin-Löf's Type Theory. The latest version of Agda, Agda 2, is a complete rewrite originally developed by Ulf Norell, a research engineer at Chalmers University of Technology. Agda, unlike Coq has limited support for tactics and proofs are generally written in functional programming style. The language has ordinary programming constructs such as data-types, pattern matching, records, let-expressions and modules, and a Haskell-like syntax. The system has an Emacs interface but can also be run in batch mode from the command line. There are three compiler backends, MAlonzo which targets Haskell, a JavaScript backend, and an Epic backend. The current version of Agda is Agda 2. The main difference since Agda 1 is support for a richer family of datatypes and pattern matching on them. Agda 2 also makes extensive use of Unicode as a way to obtain easily readable proofs. Agda 2 provides a powerful Emacs mode, developed by Makoto Takeyama and
    0.00
    0 votes
    32
    AgentSheets

    AgentSheets

    • Language Paradigms: Object-oriented programming
    • Influenced: EToys
    • Influenced By: Lisp
    AgentSheets is an educational Cyberlearning tool to create Web-based simulation games. AgentSheets is used worldwide to teach students programming and related information technology skills through game design. The built-in drag-and-drop language is accessible enough that students without programming background can make their own simple Frogger-like game, and publish it on the Web, in their first session. At the same time, AgentSheets is powerful enough to make sophisticated The Sims-like games with artificial intelligence. To transition from visual programming to more traditional programming students can render their games into Java source code. AgentSheets is supported by a middle and high school curriculum called Scalabable Game Design aligned with the ISTE National Educational Technology Standards (NETS). The mission of this project is to reinvent computer science in public schools by motivating & educating all students including women and underrepresented communities to learn about computer science through game design starting at the middle school level. Through this curriculum students build increasingly sophisticated games and, as part of this process, learn about
    0.00
    0 votes
    33
    Alef

    Alef

    • Language Paradigms: Compiled language
    • Influenced: Limbo programming language
    • Influenced By: C
    The Alef programming language was designed as part of the Plan 9 operating system by Phil Winterbottom of Bell Labs. In a February 2000 slideshow, Rob Pike noted: "…although Alef was a fruitful language, it proved too difficult to maintain a variant language across multiple architectures, so we took what we learned from it and built the thread library for C." This example was taken from Alef Language Reference Manual. The piece illustrates the use of tuple data type.
    0.00
    0 votes
    34

    ALGOL

    • Language Paradigms: Imperative programming
    • Influenced: CLU
    • Influenced By: ALGOL 58
    ALGOL (short for ALGOrithmic Language) is a family of imperative computer programming languages originally developed in the mid 1950s which greatly influenced many other languages and was the standard method for algorithm description used by the ACM, in textbooks, and academic works for the next 30 years and more. In the sense that most modern languages are "algol-like", it was arguably the most successful of the four high level programming languages with which it was roughly contemporary, Fortran, Lisp, and COBOL. 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 the begin and end pairs for delimiting them and it was also the first language implementing nested function definitions with lexical scope. Moreover, it was the first programming language which gave serious attention to formal language definition and through the Algol 60 Report introduced Backus-Naur Form, a principal notation for language design. There were three major specifications: Niklaus Wirth based his own ALGOL W on ALGOL 60 before developing Pascal. Algol-W
    0.00
    0 votes
    35

    ALGOL 58

    • Language Paradigms: Procedural programming
    • Influenced: ALGOL
    • Influenced By: Fortran
    ALGOL 58, originally known as IAL, is one of the family of ALGOL computer programming languages. It was an early compromise design soon superseded by ALGOL 60. According to John Backus "The Zurich ACM-GAMM Conference had two principal motives in proposing the IAL: (a) To provide a means of communicating numerical methods and other procedures between people, and (b) To provide a means of realizing a stated process on a variety of machines..." ALGOL 58 introduced the fundamental notion of the compound statement, but it was restricted to control flow only, and it was not tied to identifier scope in the way that Algol 60's blocks were. Bauer attributes the name to Bottenbruch: "He [Bottenbruch] was also the man who coined at that time [1957] the word 'algorithmic language' (algorithmische Sprache) at least in Germany." There were proposals for a universal language by the Association for Computing Machinery (ACM) and also by the GAMM. It was decided to organize a joint meeting to combine them. The meeting took place from May 27 to June 2, 1958, at ETH Zurich and was attended by the following people: The language was originally proposed to be called IAL (International Algebraic Language)
    0.00
    0 votes
    36

    ALGOL 68

    • Language Paradigms: Imperative programming
    • Influenced: Ada
    • Influenced By: ALGOL
    ALGOL 68 (short for ALGOrithmic Language 1968) is an imperative computer programming language that was conceived as a successor to the ALGOL 60 programming language, designed with the goal of a much wider scope of application and more rigorously defined syntax and semantics. Contributions of ALGOL 68 to the field of computer science are deep and wide ranging, although some of them were not publicly identified until they were passed, in one form or another, to one of many subsequently developed programming languages. ALGOL 68 features include expression-based syntax, user-declared types and structures/tagged-unions, a reference model of variables and reference parameters, string, array and matrix slicing, and also concurrency. ALGOL 68 was designed by IFIP Working Group 2.1. On December 20, 1968 the language was formally adopted by Working Group 2.1 and subsequently approved for publication by the General Assembly of IFIP. ALGOL 68 was defined using a two-level grammar formalism invented by Adriaan van Wijngaarden. Van Wijngaarden grammars use a context-free grammar to generate an infinite set of productions that will recognize a particular ALGOL 68 program; notably, they are able
    0.00
    0 votes
    37

    ALGOL W

    • Language Paradigms: Imperative programming
    • Influenced: Modula-2
    ALGOL W is a programming language. It was based on a proposal for ALGOL X by Niklaus Wirth and C. A. R. Hoare as a successor to ALGOL 60 in IFIP Working Group 2.1. When the committee decided that the proposal was not a sufficient advance over ALGOL 60, the proposal was published as A contribution to the development of ALGOL. After making small modifications to the language Wirth supervised a high quality implementation for the IBM/360 at Stanford University that was widely distributed. It represented a relatively conservative modification of ALGOL 60, adding string, bitstring, complex number and reference to record datatypes and call-by-result passing of parameters, introducing the while statement, replacing switch with the case statement, and generally tightening up the language. The implementation was written in PL/360, an ALGOL-like assembly language designed by Wirth. The implementation included influential debugging and profiling abilities. ALGOL W's syntax is built on a subset of the EBCDIC character set. In ALGOL 60 reserved words are distinct lexical items, but in ALGOL W they are merely sequences of characters, and do not need to be stropped. Reserved words and identifiers
    0.00
    0 votes
    38
    APL

    APL

    • Language Paradigms: Mathematics
    • Influenced: FP
    APL (named after the book A Programming Language) is an interactive array-oriented language and integrated development environment, which is available from a number of commercial and noncommercial vendors and for most computer platforms. It is based on a mathematical notation developed by Kenneth E. Iverson and associates that features special attributes for the design and specifications of digital computing systems, both computer hardware and software. APL has a combination of unique and relatively uncommon features that appeal to programmers and make it a productive programming language: APL is used in scientific, actuarial, statistical, and financial applications where it is used by practitioners for their own work and by programmers to develop commercial applications. It was an important influence on the development of spreadsheets, functional programming, and computer math packages. It has also inspired several other programming languages. It is also associated with rapid and lightweight development projects in volatile business environments. The first incarnation of what was later to be the APL programming language was published and formalized in A Programming Language, a
    0.00
    0 votes
    39
    Apply

    Apply

    In mathematics and computer science, Apply is a function that applies functions to arguments. It is central to programming languages derived from lambda calculus, such as LISP and Scheme, and also in functional languages. In particular, it has a role in the study of the denotational semantics of computer programs, because it is a continuous function on complete partial orders. In category theory, Apply is important in Cartesian closed categories, (and thus, also in Topos theory), where it is a universal morphism, right adjoint to currying. In computer programming, apply applies a function to a list of arguments. Eval and apply are the two interdependent components of the eval-apply cycle, which is the essence of evaluating Lisp, described in SICP. Apply is also the name of a special function in many languages, which takes a function and a list, and uses the list as the function's own argument list, as if the function were called with the elements of the list as the arguments. This is important in languages with variadic functions, because this is the only way to call a function with an indeterminate (at compile time) number of arguments. In Common Lisp apply is a function that
    0.00
    0 votes
    40
    APT programming language

    APT programming language

    APT or Automatically Programmed Tool is a high-level computer programming language used to generate instructions for numerically controlled machine tools. Douglas T. Ross is considered by many to be the father of APT. APT is a language and system that makes numerically controlled manufacturing possible. This early language was used widely into the 1970s and is still a standard internationally. APT is used to program CNC machine tools to create complex parts using a cutting tool moving in space. It is used to calculate a path that a tool must follow to generate a desired form. APT is a special-purpose language and the predecessor to modern CAM systems. It was created and refined during the late 1950s and early 1960s to simplify the task of calculating geometry points that a tool must traverse in space to cut the complex parts required in the aerospace industry. It was a direct result of the new numerical control technology becoming available at that time and the daunting task that a machinist or engineer faced calculating the movements of the machine for the complex parts for which it was capable. APT was created before graphical interfaces were available, and so it relies on text
    0.00
    0 votes
    41

    Atari ST BASIC

    Atari ST BASIC (or ST Basic) was the first dialect of BASIC that was produced for the Atari ST line of computers. It was bundled with all new STs in the early years of the ST's lifespan, and quickly became the standard BASIC for that platform. However, many users disliked it, and improved dialects of BASIC quickly came out to replace it. ST BASIC became famous for its abundance of bugs. It was possible to crash ST BASIC with the following line of code: Atari commissioned MetaComCo to write a version of BASIC that would take advantage of the GEM environment on the Atari ST. This was based on a version already written for Digital Research called DR-Basic, which was bundled with DR's CP/M-86 operating system. The result was called ST BASIC. At the time the ST was launched, ST BASIC was bundled with all new STs. A further port of the same Basic called ABasiC ended up being supplied for a time with the ST's bitter rival, the Amiga. The user interface consisted of four windows. An edit-window in which one could enter the source code, a list-window where the entire source code could be browsed, a command/debug-window where instructions were entered that were immediately executed, and the
    0.00
    0 votes
    42
    ATLAS Transformation Language

    ATLAS Transformation Language

    ATL (ATL Transformation Language) is a model transformation language and toolkit developed and maintained by OBEO and AtlanMod. It was initiated by the AtlanMod team (previously called ATLAS Group). In the field of Model-Driven Engineering (MDE), ATL provides ways to produce a set of target models from a set of source models. Released under the terms of the Eclipse Public License, ATL is an M2M (Eclipse) component, inside of the Eclipse Modeling Project (EMP). ATL is a model transformation language (MTL) developed by OBEO and INRIA to answer the QVT Request For Proposal. QVT is an Object Management Group standard for performing model transformations. It can be used to do syntactic or semantic translation. ATL is built on top of a model transformation Virtual Machine. ATL is the ATLAS INRIA & LINA research group answer to the OMG MOF/QVT RFP. It is a model transformation language specified both as a metamodel and as a textual concrete syntax. It is a hybrid of declarative and imperative. The preferred style of transformation writing is declarative, which means simple mappings can be expressed simply. However, imperative constructs are provided so that some mappings too complex to be
    0.00
    0 votes
    43
    AutoIt

    AutoIt

    • Influenced: Beginners Programming Language
    • Influenced By: BASIC
    AutoIt (pronounced aw-tow-it) is a freeware automation language for Microsoft Windows. In its earliest release, the software was primarily intended to create automation scripts (sometimes called macros) for Microsoft Windows programs but has since grown to include enhancements in both programming language design and overall functionality. With the release of Version 3, the syntax of AutoIt has been restructured to be more like the BASIC family of languages. It is a third-generation programming language using a classical data model, using a variant data type that can store several types of data, including arrays. It is compatible with Windows 95, 98, ME, NT4, 2000, XP, 2003, Vista and Windows 7 (however, support for operating systems older than Windows 2000 was discontinued with the release of v3.3.0). An AutoIt automation script can be compiled into a compressed, stand-alone executable which can be run on computers that do not have the AutoIt interpreter installed. A wide range of function libraries (known as UDF's, or "User Defined Functions") are also included as standard or are available from the website to add specialized functionality. AutoIt is also distributed with an IDE
    0.00
    0 votes
    44

    BBC BASIC

    • Language Paradigms: Procedural programming
    • Influenced By: BASIC
    BBC BASIC is a programming language, developed in 1981 as a native programming language for the MOS Technology 6502 based Acorn BBC Micro home/personal computer, mainly by Sophie Wilson. It is a version of the BASIC programming language adapted for a UK computer literacy project of the BBC. BBC BASIC, based on the older Atom BASIC (for the Acorn Atom), extended traditional BASIC with named DEF PROC/DEF FN procedures and functions, REPEAT UNTIL loops, and IF THEN ELSE structures inspired by COMAL. The interpreter also included powerful statements for controlling the BBC Micro's four-channel sound output and its low / high-resolution eight mode graphics display. One of the unique features of BBC BASIC was the presence of an inline assembler allowing users to write 6502 assembly language programs. The assembler was fully integrated into the BASIC interpreter and shared variables with it, which can be included between the [ and ] characters, saved via *SAVE and *LOAD, and called via the CALL or USR commands. This allowed developers to write not just assembly language code, but also BASIC code to emit assembly language, making it possible to use code generation techniques and even write
    0.00
    0 votes
    45
    Befunge

    Befunge

    • Language Paradigms: Stack-oriented programming language
    • Influenced: Argh!
    Befunge is a stack-based, reflective, esoteric programming language. It differs from conventional languages in that programs are arranged on a two-dimensional grid. "Arrow" instructions direct the control flow to the left, right, up or down, and loops are constructed by sending the control flow in a cycle. It has been described as "a cross between Forth and Lemmings." A worthy companion to INTERCAL; a computer language family which escapes the quotidian limitation of linear control flow and embraces program counters flying through multiple dimensions with exotic topologies. — Jargon File The language was originally created by Chris Pressey in 1993 as an attempt to devise a language which is as hard to compile as possible — note that the p command allows for self-modifying code. Nevertheless, a number of compilers have subsequently been written. A number of extensions to the original "Befunge-93" specification also exist, most notably Funge-98, which extends the concept to an arbitrary number of dimensions and can be multithreaded, with multiple instruction pointers operating simultaneously on the same space. Befunge-extensions and variants are called Fungeoids or just Funges. The
    0.00
    0 votes
    46
    Bidule

    Bidule

    Bidule is a commercial software application for the creation of interactive computer music and multimedia produced by the Canadian company Plogue Arts and Technology. It runs on both Windows and Mac computers. Bidule uses a modular structure based on a patch cord metaphor much like AudioMulch, Reaktor, Pure Data, and Max/MSP. Individual modules are called bidules (the Plogue web site states that the word "Bidule" is French for "thingy" or "gadget"). A set of bidules and connections is called a layout, and sub-patches called groups can be built within layouts and saved for use elsewhere. The program features real time audio, MIDI, Open Sound Control (OSC), and spectral processing. It runs as a ReWire mixer or device. It can be run standalone or as a VST, VSTi or AU plugin, and can host the same. ASIO/CoreAudio is supported for low latency audio. Parameters can be linked to MIDI or OSC input or to other module parameters. Over one hundred modules and groups are available, and modules include the ability to perform high-level math on signals.
    0.00
    0 votes
    47

    BLISS

    • Language Paradigms: Procedural programming
    • Influenced By: ALGOL
    BLISS is a system programming language developed at Carnegie Mellon University by W. A. Wulf, D. B. Russell, and A. N. Habermann around 1970. It was perhaps the best known systems programming language right up until C made its debut a few years later. Since then, C took off and BLISS faded into obscurity. When C was in its infancy, a few projects within Bell Labs were debating the merits of BLISS vs. C. BLISS is a typeless block-structured language based on expressions rather than statements, and includes constructs for exception handling, coroutines, and macros. It does not include a goto statement. The name is variously said to be short for "Basic Language for Implementation of System Software" or "System Software Implementation Language, Backwards". It was sometimes called "Bill's Language for Implementing System Software", after Bill Wulf. The original Carnegie Mellon compiler was notable for its extensive use of optimizations, and formed the basis of the classic book The Design of an Optimizing Compiler. DEC developed and maintained BLISS compilers for the PDP-10, PDP-11, DEC Alpha, DEC PRISM, Intel IA-32, Intel IA-64, and VAX, and used it heavily in-house into the 1980s; most
    0.00
    0 votes
    48

    C--

    • Language Paradigms: Imperative programming
    • Influenced By: C
    C-- (pronounced "see minus minus") is a C-like programming language. Its creators, functional programming researchers Simon Peyton Jones and Norman Ramsey, designed it to be generated mainly by compilers for very high-level languages rather than written by human programmers. Unlike many other intermediate languages, its representation is plain ASCII text, not bytecode or another binary format. C-- is a "portable assembly language", designed to ease the task of implementing a compiler which produces high-quality machine code by having the compiler generate C-- code, delegating the harder work of low-level code generation and optimisation to a C-- compiler. Work on C-- began in the late 1990s. Since writing a custom code generator is a challenge in itself, and the compiler back ends available to researchers at that time were complex and poorly documented, several projects had written compilers which generated C code (for instance, the original Modula-3 compiler). However, C is a poor choice for functional languages: it does not support tail recursion, accurate garbage collection or efficient exception handling. C-- is a simpler, tightly-defined alternative to C which does support all
    0.00
    0 votes
    49

    Cat

    • Language Paradigms: Concatenative programming language
    • Influenced: Ambi
    • Influenced By: Joy
    Cat is a functional stack-oriented programming language inspired by the Joy programming language. Joy and Cat differ from most functional languages (e.g. Scheme, Haskell) and language formalisms (e.g. lambda calculus, combinatory logic) in that they are based on the composition of functions rather than function application. Cat and Joy both bear more resemblance to combinatorial logic calculi (such as the SKI calculus or the B,C,K,W system) than to the lambda calculus due to the lack of names. The Cat language was designed with static typing in mind, and as such there is somewhat less flexibility but more safety than is available in the Joy programming language. Cat is intended as a multi-purpose language with an emphasis on usage as an intermediate language and as an educational language. Like Joy, programs in Cat are constructed from existing programs using two operations: composition and quotation. All Cat programs can be thought of as functions that map from one stack to another. Because Cat has no operations that refer to previous stack states, Cat can be easily implemented using a single mutable shared stack. Two adjacent terms in Cat imply the composition of functions that
    0.00
    0 votes
    50

    Cecil programming language

    • Language Paradigms: Object-oriented programming
    Cecil is a pure object-oriented programming language that was developed by Craig Chambers at the University of Washington in 1992 to be part of the Vortex project there. Cecil has many similarities to other object-oriented languages, most notably Objective-C, Modula-3, and Self. The main goals of the project were extensibility, orthogonality, efficiency, and ease-of-use. The language supports multiple dispatch and multimethods, dynamic inheritance, and optional static type checking. Unlike most other OOP systems, Cecil allows subtyping and code inheritance to be used separately, allowing run-time or external extension of object classes or instances. Like Objective-C, all object services in Cecil are invoked by message passing, and the language supports run-time class identification. These features allow Cecil to support dynamic, exploratory programming styles. Parameterized types and methods (generics, polymorphism), garbage collection, and delegation are also supported. Cecil also supports a module mechanism for isolating independent libraries or packages. Cecil does not presently support threads or any other form of concurrency. A standard library for Cecil is also available and
    0.00
    0 votes
    51

    Ch interpreter

    Ch ( /ˌsiːˈeɪtʃ/) is a proprietary cross-platform C and C++ interpreter originally designed by Harry H. Cheng as a scripting language for beginners to learn mathematics, computing, numeric methods, and programming in C/C++. Ch is now developed and marketed by SoftIntegration, Inc. A student edition is freely available. Ch can be embedded into the C/C++ application programs. It has numerical computing and graphical plotting features. ChIDE provides quick code navigation and step-by-step debug features. It is based on embedded Ch, Scite and Scintilla. Ch can also be run as an interactive shell to execute C statements and scripts. Unix commands can run in Unix Ch shell, and Windows commands can run in Windows Ch Shell. Ch is written in C and runs under Microsoft Windows, Linux, Mac OS X, FreeBSD, AIX, Solaris, QNX, and HP-UX. It supports C90 and major C99 features, but it does not support the full set of C++ features. C99 complex number, IEEE-754 floating-point arithmetic, and variable-length array features were supported in Ch before they became part of the C99 standard. An article published by CRN named Ch as notable among C-based virtual machines for its functionality and the
    0.00
    0 votes
    52
    Chinese BASIC

    Chinese BASIC

    Chinese BASIC (Chinese: 中文培基; pinyin: Zhōngwén Péijī) is the name given to several Chinese-localized versions of the BASIC programming language in the early 1980s. At least two versions of Chinese BASIC were modified Applesoft BASIC that accepted Chinese commands and variables. They were built into some Taiwan-made Apple II clones. One of these was shipped with the best-selling Multitech Microprofessor II (known as Acer today). Another version was shipped with MiTAC's Little Intelligent Computer (小神通) . In addition to Apple II clones, Multitech also developed a Zilog Z80-based port of the Chinese BASIC for its own line of high-end computers. In a typical Chinese BASIC environment, Chinese and English commands are interchangeable. It may also accept Chinese and Latin alphabet variables. For example you may use PRINT A in line 50, 印 A in line 200 and ? A in line 250. They all do the same thing -- to print out the value of A on screen. This program calculates the sum of log (E) + log (E+1) + log (E+2) + ... + log (F). The Chinese characters used as variables are the 24 radicals of the Cangjie method, one of the earliest QWERTY keyboard-compatible Chinese input methods. The author of
    0.00
    0 votes
    53
    CHIP-8

    CHIP-8

    CHIP-8 is an interpreted programming language, developed by Joseph Weisbecker. It was initially used on the COSMAC VIP and Telmac 1800 8-bit microcomputers in the mid-1970s. CHIP-8 programs are run on a CHIP-8 virtual machine. It was made to allow video games to be more easily programmed for said computers. Roughly twenty years after CHIP-8 was introduced, derived interpreters appeared for some models of graphing calculators (from the late 1980s onward, these handheld devices in many ways have more computing power than most mid-1970s microcomputers for hobbyists). An active community of users and developers existed in the late 1970s, beginning with ARESCO's "VIPer" newsletter whose first three issues revealed the machine code behind the CHIP-8 interpreter. There are a number of classic video games ported to CHIP-8, such as Pong, Space Invaders, Tetris, and Pac-Man. There's also a random maze generator available. These programs are reportedly placed in the public domain, and can be easily found on the Internet. There is a CHIP-8 implementation for almost every platform imaginable, as well as some development tools. Despite this, there are only a small number of games for the
    0.00
    0 votes
    54
    ChucK

    ChucK

    • Language Paradigms: Multi-paradigm programming language
    ChucK is a concurrent, strongly timed audio programming language for real-time synthesis, composition, and performance, which runs on Mac OS X, Linux, Microsoft Windows, and iPhone/iPad. It is designed to favor readability and flexibility for the programmer over other considerations such as raw performance. It natively supports deterministic concurrency and multiple, simultaneous, dynamic control rates. Another key feature is the ability to add, remove, and modify code on the fly, while the program is running, without stopping or restarting. It has a highly precise timing/concurrency model, allowing for arbitrarily fine granularity. It offers composers and researchers a powerful and flexible programming tool for building and experimenting with complex audio synthesis programs, and real-time interactive control. ChucK is distributed freely under the terms of the GNU General Public License on Mac OS X, Linux and Microsoft Windows. On iPhone/iPad, ChiP (ChucK for iPhone) is distributed under a limited, closed source license, and is not currently licensed to the public. However, the core team has stated that it would like to explore "ways to open ChiP by creating a beneficial
    0.00
    0 votes
    55
    CLACL

    CLACL

    • Language Paradigms: Logic programming
    • Influenced: C
    CLACL (representing CLAC-Language where CLAC stands for Logical Composition with the Assistance of Computers) is the result of a theoretical research, still in progress, which aims to provide a formal description of the logical choices relating to the definition of organisational processes of composition. The logic of "CLACL" is not based on the processing of numerical information, but on 'spatial-relational' information. They generate a logical configuration. Then, with a tool called "Plasma" you can shape the created domain in a physical form such as music or graphics. example of Instances and Domain example of a Model CLACL is an interpreted language and integrated into a production environment that provides several tools to facilitate the writing of the code and its graphical representation. The first version (00.02.00) of the language was made available on the Internet in 2000 at the site of the project. The version (00.06.00) was distributed at the 2009 Festival of Mathematics held in Rome and during which the project CLAC was presented. The last version is 00.08.01. Given this background, it is clear that the target of potential users of the language is those working within
    0.00
    0 votes
    56

    Claire programming language

    • Language Paradigms: Object-oriented programming
    • Influenced By: C
    Claire is a high-level functional and object-oriented programming language with rule processing abilities. It was designed by Yves Caseau at Bouygues' e-Lab research laboratory, and received its final definition in 2004. Claire provides: Claire's reference implementation, consisting of an interpreter and compiler, was fully open-sourced with the release of version 3.3.46 in February 2009. Another implementation, WebClaire, is commercially supported. Claire is a general-purpose programming language, best suited to application software requiring sophisticated data modeling, rule processing or problem solving. WebClaire adds extensions for fuller integration with the operating system and for programming web applications. Though Claire can be used for complete projects, it is designed to integrate smoothly with C++ or Java: Claire programs may include C++ or Java code, and Claire code may be translated into C++ or Java for use in C++ or Java projects. The key set of features that distinguishes Claire from other programming languages has been dictated by experience in solving complex optimization problems. Two features not found in other mixed functional/object-oriented languages, such
    0.00
    0 votes
    57
    Clascal

    Clascal

    • Language Paradigms: Object-oriented programming
    Clascal was an object-oriented programming language developed in 1983 by the Personal Office Systems (POS) division (later renamed The Lisa Division, still later The 32-Bit Systems Division) of Apple Computer. It was an extension of Lisa Pascal, which in turn harked back to the UCSD Pascal model originally implemented on the Apple II. It was strongly influenced by Xerox PARC's release of Smalltalk-80, v1 (which had been ported to the Lisa previously), and also by Modula. Clascal was the inspiration for Object Pascal on the Macintosh in 1985. With the demise of the Lisa in 1986, Pascal and Object Pascal continued to be used in the Macintosh Programmer's Workshop for systems and application development for several more years, until it was finally supplanted by the C and C++ programming languages. The MacApp application template was based on sample programs originally written in Clascal, and on the "Toolkit", or class library. Ultimately Object Pascal evolved into the programming language of Borland Delphi.
    0.00
    0 votes
    58

    CLOS

    • Language Paradigms: Object-oriented programming
    • Influenced: Dylan
    • Influenced By: Lisp
    The Common Lisp Object System (CLOS) is the facility for object-oriented programming which is part of ANSI Common Lisp. CLOS is a powerful dynamic object system which differs radically from the OOP facilities found in more static languages such as C++ or Java. CLOS was inspired by earlier Lisp object systems such as MIT Flavors and CommonLOOPS, although it is more general than either. Originally proposed as an add-on, CLOS was adopted as part of the ANSI standard for Common Lisp and has been adapted into other Lisp dialects like EuLisp or Emacs Lisp. The basic building blocks of CLOS are classes, instances of classes, generic functions and their methods. CLOS provides macros to define those: defclass, defgeneric and defmethod. Instances are created with the function make-instance. Classes can have multiple superclasses, a list of slots (member variables in C++/Java parlance) and a special meta class. Slots can be allocated by class (all instances of a class are sharing the slot) or by instance. Each slot has a name and the value of a slot can be accessed by that name using the function slot-value. Additionally special generic functions can be defined to write or read values of
    0.00
    0 votes
    59

    CLU

    • Language Paradigms: Object-oriented programming
    • Influenced: Ruby
    • Influenced By: ALGOL
    CLU is a programming language created at MIT by Barbara Liskov and her students between 1974 and 1975. It was notable for its use of constructors for abstract data types that included the code that operated on them, a key step in the direction of object-oriented programming (OOP). However many of the other features of OOP are (intentionally) missing, notably inheritance, and the language is also hindered by a sometimes frustrating if elegant syntax. The syntax of CLU was based on ALGOL, then the starting point for most new language design. The key addition was the concept of a cluster, CLU's type extension system and the root of the language's name (CLUster). Clusters correspond generally to the concept of an "object" in an OO language, and have roughly the same syntax. For instance, here is the CLU syntax for a cluster that implements complex numbers: Cluster names are global, and no namespace mechanism was provided to group clusters or allow them to be created "locally" inside other clusters. CLU does not perform implicit type conversions. In a cluster, the explicit type conversions 'up' and 'down' change between the abstract type and the representation. There is a universal type
    0.00
    0 votes
    60

    COBOL

    • Language Paradigms: Object-oriented programming
    • Influenced: PL/I
    • Influenced By: FLOW-MATIC
    COBOL ( /ˈkoʊbɒl/) 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. The COBOL 2002 standard includes support for object-oriented programming and other modern language features. The COBOL specification was created by a committee of researchers from private industry, universities, and government during the second half of 1959. 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." The IBM COMTRAN language invented by Bob Bemer was also drawn upon, but the FACT language specification from Honeywell was not distributed to committee members until late in the process and had relatively little impact. FLOW-MATIC's status as the only language of the bunch to have actually been implemented made it particularly attractive to the committee. The scene was set on April 8, 1959 at a meeting of computer manufacturers, users, and university people at the University of Pennsylvania Computing Center. The United States Department
    0.00
    0 votes
    61
    CoffeeScript

    CoffeeScript

    • Language Paradigms: Multi-paradigm programming language
    • Influenced: MoonScript
    • Influenced By: JavaScript
    CoffeeScript is a programming language that translates into JavaScript. It mostly keeps the semantics of JavaScript itself, But the syntax is different and inspired by Haskell, Ruby and other Languages. CoffeScript transcompiles predictable into JavaScript and code written in either language can be used from the other one without the need to write wrappers, bridges or similar and CoffeScript usually needs ⅓ less lines of code compared to equal code in JavaScript, which makes it an popular choice for saving development times. Brendan Eich (Known for the creation of JavaScript) has referenced CoffeeScript as an influence on his thoughts about the future of JavaScript.
    0.00
    0 votes
    62
    ColdFusion Markup Language

    ColdFusion Markup Language

    • Language Paradigms: Imperative programming
    ColdFusion Markup Language, more commonly known as CFML, is a scripting language for web development that runs on the JVM, the .NET framework, and Google App Engine. Multiple commercial and open source implementations of CFML engines are available, including Adobe ColdFusion, New Atlanta BlueDragon (who makes both a Java-based and a .NET-based version), Railo, and Open BlueDragon as well as other CFML server engines. The CFML language was guided by the CFML Advisory Committee beginning in 2009. This committee included representatives from Adobe, Railo, and Open BlueDragon, but the committee was disbanded in 2010. General language discussions and feature suggestions now tend to happen on the CFML Conventional Wisdom Google Group or on various other CFML mailing lists. In its simplest form, like many other web scripting languages CFML augments standard HTML files with database commands, conditional operators, high-level formatting functions, and other elements to produce web applications. CFML also includes numerous other constructs including ColdFusion Components (CFCs), CFML's version of objects, that allow for separation of business logic from presentation. CFML can be written
    0.00
    0 votes
    63
    Common Language Infrastructure

    Common Language Infrastructure

    The Common Language Infrastructure (CLI) is an open specification developed by Microsoft and standardized by ISO and ECMA that describes the executable code and runtime environment that form the core of the Microsoft .NET Framework and the free and open source implementations Mono and Portable.NET. The specification defines an environment that allows multiple high-level languages to be used on different computer platforms without being rewritten for specific architectures. Among other things, the CLI specification describes the following four aspects: All compatible languages compile to Common Intermediate Language (CIL), which is an intermediate language that is abstracted from the platform hardware. When the code is executed, the platform-specific VES will compile the CIL to the machine language according to the specific hardware and operating system. In August 2000, Microsoft, Hewlett-Packard, Intel, and others worked to standardize CLI. By December 2001, it was ratified by the ECMA, with ISO standardization following in April 2003. Microsoft and its partners hold patents for CLI. ECMA and ISO require that all patents essential to implementation be made available under
    0.00
    0 votes
    64
    ConTeXt

    ConTeXt

    ConTeXt is a general-purpose document processor. It is especially suited for structured documents, automated document production, very fine typography, and multi-lingual typesetting. It is based in part on the TeX typesetting system, and uses a document markup language for manuscript preparation. The typographical and automated capabilities of ConTeXt are extensive, including interfaces for handling microtypography, multiple footnotes and footnote classes, and manipulating OpenType fonts and features. Moreover, it offers extensive support for colors, backgrounds, hyperlinks, presentations, figure-text integration, and conditional compilation. It gives the user extensive control over formatting while making it easy to create new layouts and styles without learning the low-level TeX macro language. ConTeXt may be compared and contrasted with LaTeX, but the primary thrust of the two are rather distinct. ConTeXt from the ground up is a typography and typesetting system meant to provide users easy and consistent access to advanced typographical control—important for general-purpose typesetting tasks. The original vision of LaTeX is to insulate the user from typographical decisions—a
    0.00
    0 votes
    65
    Coq

    Coq

    • Language Paradigms: Functional programming
    • Influenced: Agda theorem prover
    • Influenced By: ML
    In computer science, Coq is an interactive theorem prover. It allows the expression of mathematical assertions, mechanically checks proofs of these assertions, helps to find formal proofs, and extracts a certified program from the constructive proof of its formal specification. Coq works within the theory of the calculus of inductive constructions, a derivative of the calculus of constructions. Coq is not an automated theorem prover but includes automatic theorem proving tactics and various decision procedures. Coq implements a dependently typed functional programming language. It is developed in France, in the PI.R2 team of the PPS laboratory, jointly operated by INRIA, École Polytechnique, Paris-Sud 11 University, Paris Diderot University and CNRS. There was also formerly a group at École Normale Supérieure de Lyon. The project manager of Coq is Hugo Herbelin. Coq is implemented in OCaml. The word coq means "rooster" in French, and stems from a tradition of naming French research development tools with animal names. It is also a reference to Thierry Coquand, who developed the aforementioned calculus of constructions along with Gérard Huet. Also, at first it was simply called Coc,
    0.00
    0 votes
    66

    Curry programming language

    • Language Paradigms: Functional programming
    • Influenced By: Haskell
    Curry is an experimental functional logic programming language, based on the Haskell language. It merges elements of functional and logic programming, including constraint programming integration. It is nearly a superset of Haskell, lacking support mostly for overloading using type classes, which some implementations provide anyway as a language extension, such as the Münster Curry Compiler. A functional program is a set of functions defined by equations or rules. A functional computation consists of replacing subexpressions by equal (with regards to the function definitions) subexpressions until no more replacements (or reductions) are possible and a value or normal form is obtained. For instance, consider the function double defined by The expression “double 1” is replaced by 1+1. The latter can be replaced by 2 if we interpret the operator “+” to be defined by an infinite set of equations, e.g., 1+1 = 2, 1+2 = 3, etc. In a similar way, one can evaluate nested expressions (where the subexpression to be replaced are quoted): There is also another order of evaluation if we replace the arguments of operators from right to left: In this case, both derivations lead to the same result,
    0.00
    0 votes
    67
    Cω

    • Language Paradigms: Functional programming
    • Influenced: Language Integrated Query
    • Influenced By: Polyphonic C sharp
    Cω (pronounced "cee omega"; usually written "Cw" or "Comega") is a free extension to the C# programming language, developed by the WebData team in Microsoft SQL Server in collaboration with Microsoft Research in the UK and Redmond. It was formerly known as the codenames "X#" (X Sharp) and "Xen". It was renamed Cω after Polyphonic C#, another research language based on the join calculus, was integrated into it. Cω attempts to make datastores (such as databases and XML documents) accessible with the same ease and type safety as traditional types like strings and arrays. Many of these ideas were inherited from an earlier incubation project within the WebData XML team called X# and Xen. Cω also includes new constructs to support concurrent programming; these features were largely derived from the earlier Polyphonic C# project. Available now as a compiler preview, Cω's features have been used in the creation of the LINQ extensions in C#. The concurrency constructs have also been released in a slightly modified form as a library, named Joins Concurrency Library, for C# and other .NET languages by Microsoft Research.
    0.00
    0 votes
    68

    D

    • Language Paradigms: Object-oriented programming
    • Influenced: MiniD
    • Influenced By: C++
    The D programming language is an object-oriented, imperative, multi-paradigm system programming language created by Walter Bright of Digital Mars. It originated as a re-engineering of C++, but even though it is mainly influenced by that language, it is not a variant of C++. D has redesigned some C++ features and has been influenced by concepts used in other programming languages, such as Java, Python, Ruby, C#, and Eiffel. D's design goals attempt to combine the performance of compiled languages with the safety and expressive power of modern dynamic languages. Idiomatic D code is commonly as fast as equivalent C++ code, while being shorter and memory-safe. Type inference, automatic memory management and syntactic sugar for common types allow faster development, while bounds checking, design by contract features and a concurrency-aware type system help reduce the occurrence of bugs. D is designed with lessons learned from practical C++ usage rather than from a theoretical perspective. Even though it uses many C/C++ concepts it also discards some, and as such is not compatible with C/C++ source code. It adds to the functionality of C++ by also implementing design by contract, unit
    0.00
    0 votes
    69
    Dao Language

    Dao Language

    • Language Paradigms: Multi-paradigm programming language
    • Influenced By: Perl
    Dao is an object-oriented scripting language with dynamically typed variables supporting complex data structures. It has text processing abilities, such as regular expression matching. It provides many built-in numerical datatypes such as complex numbers and multi-dimensional numeric arrays, as well as their corresponding arithmetic operations. Support for multi-threaded programming is also an integrated part of Dao. The Dao interpreter is implemented as a lightweight virtual register machine (Dao VM) in standard C. The Dao VM can be extended with C or C++. Advanced features of the language include: The classic hello world program can be written as follows: Here io(=stdio) is the standard library to handle input and output. The std.listmeth routine can be used to display the methods in a library. The methods in math, for example, can be displayed using: A Dao variable can be implicitly declared by assigning the result of an expression to a variable name. By default, a variable will have a fixed type that is inferred from the expression that is used to declare the variable; this is called implicit typing. The type of a variable can also be specified explicitly, using the following
    0.00
    0 votes
    70

    Dartmouth ALGOL 30

    Dartmouth ALGOL 30 was an 1960s-era implementation, firstly of the ALGOL 58 programming language, then of ALGOL 60 for the LGP-30 at Dartmouth College, hence the name. Since the limited size of the LGP-30 precluded a full implementation of ALGOL 60, certain of its features (arrays called by value, own arrays, strings, variable array bounds, and recursion) were omitted; but the implementors did include parameters called by name, using "thunks" (Ingerman, 1961; Irons and Wally Feurzeig, 1961), and integer labels. They dubbed their work ALGOL 30, since it was for the LGP-30 (Kurtz, 1962a, Feb., 1962b, Mar.). From this project emerged a small group of undergraduate students who were well equipped to perform further work in the development of computer languages. For instance, one student (Steve Garland) discovered that compound statements and blocks could be included in the Samelson and Bauer scanning algorithm. This simple fact was not published until some years later. (The author has been unable to identify the source that he clearly remembers; the closest is Gries, 1968.) "The ALGOL 30 system suffered one defect that hindered its wide use as a student-oriented language: it was a
    0.00
    0 votes
    71

    Dylan

    • Language Paradigms: Dynamic programming language
    • Influenced: Ruby
    • Influenced By: Lisp
    Dylan ( /ˈdɪlən/) is a multi-paradigm programming language that includes support for functional and object-oriented programming, and is dynamic and reflective while providing a programming model designed to support efficient machine code generation, including fine-grained control over dynamic and static behaviors. It was created in the early 1990s by a group led by Apple Computer. Dylan derives from Scheme and Common Lisp and adds an integrated object system derived from the Common Lisp Object System (CLOS). In Dylan, all values (including numbers, characters, functions, and classes) are first-class objects. Dylan supports multiple inheritance, polymorphism, multiple dispatch, keyword arguments, object introspection, pattern-based syntax extension macros, and many other advanced features. Programs can express fine-grained control over dynamism, admitting programs that occupy a continuum between dynamic and static programming and supporting evolutionary development (allowing for rapid prototyping followed by incremental refinement and optimization). Dylan's main design goal is to be a dynamic language well-suited for developing commercial software. Dylan attempts to address
    0.00
    0 votes
    72

    E

    • Language Paradigms: Object-oriented programming
    • Influenced: AmbientTalk
    • Influenced By: Joule
    E is an object-oriented programming language for secure distributed computing, created by Mark S. Miller, Dan Bornstein, and others at Electric Communities in 1997. E is mainly descended from the concurrent language Joule and from Original-E, a set of extensions to Java for secure distributed programming. E combines message-based computation with Java-like syntax. A concurrency model based on event loops and promises ensures that deadlock can never occur. The entire language is designed with secure computing in mind; this is accomplished chiefly by strict adherence to the object-oriented computing model, which in its pure form has properties that support secure computing. The E language and its standard library employ a capability-based design philosophy throughout in order to help programmers build secure software and to enable software components to co-operate even if they don't fully trust each other. In E, object references serve as capabilities, hence capabilities add no computational or conceptual overhead costs. The language syntax is designed to be easy for people to audit for security flaws. For example, lexical scoping limits the amount of code that has to be examined for
    0.00
    0 votes
    73

    Ease programming language

    • Language Paradigms: Parallel computing
    • Influenced By: Occam
    Ease is a general purpose parallel programming language, designed by Steven Ericsson-Zenith of Yale University. It combines the process constructs of CSP with logically shared data structures called contexts. Contexts are parallel data types that are constructed by processes and provide a way for processes to interact. The language includes two process constructors. A cooperation includes an explicit barrier synchronization and is written: If one process finishes before the other than it will wait until the other processes are finished. A subordination creates a process that shares the contexts that are in scope when created and finishes when complete (it does not wait for other processes) and is written: Subordinate processes stop if they attempt to interact with a context that has completed because the parent process has stopped. This enables speculative processes to be created that will finish if their result is not needed. Powerful replication syntax allows multiple processes to be created. For example creates n synchronized processes each with a local constant i. Processes cannot share local variables and cooperate in the construction of shared contexts. Certain context types,
    0.00
    0 votes
    74
    EC

    EC

    eC (Ecere C) is an object-oriented language derived from and compatible with C designed and developed by Ecere Corporation. It aims at being fast, light and easy to write. It is supported by a cross-platform runtime library including its own GUI toolkit, 2D/3D graphics engine as well as networking support. The Ecere SDK is completely free and includes a full-featured Integrated Development Environment as well as a compiling tools for the eC language. Some of eC Features Hello, World!! in eC Properties & Conversions in eC Hello, World!! in a GUI eCeCeCeC
    0.00
    0 votes
    75

    ECMAScript

    • Language Paradigms: Object-oriented programming
    • Influenced: JScript .NET
    • Influenced By: Self
    ECMAScript is the scripting language standardized by Ecma International in the ECMA-262 specification and ISO/IEC 16262. The language is widely used for client-side scripting on the web, in the form of several well-known dialects such as JavaScript, JScript, and ActionScript. JavaScript was originally developed by Brendan Eich of Netscape under the name Mocha, later LiveScript, and finally renamed to JavaScript. In December 1995, Sun Microsystems and Netscape announced JavaScript in a press release. In March 1996, Netscape Navigator 2.0 was released, featuring support for JavaScript. Due to the widespread success of JavaScript as a client-side scripting language for web pages, Microsoft developed a compatible dialect of the language, naming it JScript to avoid trademark issues. JScript added new date methods to fix the non-Y2K-friendly methods in JavaScript, which were based on the Java Date class. JScript was included in Internet Explorer 3.0, released in August 1996. Netscape delivered JavaScript to Ecma International for standardization and the work on the specification, ECMA-262, began in November 1996. The first edition of ECMA-262 was adopted by the Ecma General Assembly of
    0.00
    0 votes
    76

    Edinburgh IMP

    Edinburgh IMP is a development of ATLAS Autocode, initially developed around 1966-1969 at Edinburgh University, Scotland. IMP was a general-purpose programming language which was used heavily for systems programming. Expressively, IMP is extremely similar to Algol and includes all the Algol-style block structure, reserved keywords, and datatypes such as arrays and records. It adds to Algol-style languages a string type (akin to a flex array of char) and built-in operators for string manipulation and character handling. IMP provides significant control over the storage mapping of data, plus commands for addressing within parts of words. Most Imp compilers offer compiler-generated run-time checks and a backtrace facility by default, even in production code. IMP allows the programmer to inline machine language instructions in the IMP source code. Early IMP compilers were developed for the ICL System 4, UNIVAC 1108, IBM 360, DEC PDP-9, DEC PDP-15 and CTL Modular One computers. IMP was used to implement the EMAS operating system. In later years a version of IMP called IMP77 was developed by Peter Robertson within the Computer Science department at Edinburgh which was a portable compiler
    0.00
    0 votes
    77

    Educational programming language

    An educational programming language is a programming language that is designed primarily as a learning instrument and not so much as a tool for writing programs for real-world work. Many educational programming languages position themselves inside a learning path, that is a sequence of languages each designed to build on the others moving a student from easy to understand and entertaining environments to full professional environments. Some of the better known are presented below. Originally, machine code was the first and only way to program computers. Assembly language was the next type of language used, and thus is one of the oldest families of computer languages in use today. Many dialects and implementations are available, usually some for each computer processor architecture. It is very basic and termed a low level programming language. It is one of the more difficult languages to work with being untyped and rigid, but this is how computers work at low level. Several simplified dialects exist for education. Low level languages must be written for a specific processor architecture and cannot be written or taught in isolation without referencing the processor for which it was
    0.00
    0 votes
    78
    Eiffel

    Eiffel

    • Language Paradigms: Object-oriented programming
    • Influenced: D
    • Influenced By: Ada
    Eiffel is an ISO-standardized, object-oriented programming language designed by Bertrand Meyer (an object-orientation proponent and author of Object-Oriented Software Construction) and Eiffel Software. The design of the language is closely connected with the Eiffel programming method. Both are based on a set of principles, including design by contract, command-query separation, the uniform-access principle, the single-choice principle, the open-closed principle, and option-operand separation. Many concepts initially introduced by Eiffel later found their way into Java, C#, and other languages. New language design ideas, particularly through the Ecma/ISO standardization process, continue to be incorporated into the Eiffel language. The key characteristics of the Eiffel language include: Eiffel emphasizes declarative statements over procedural code and attempts to eliminate the need for bookkeeping instructions. Eiffel shuns coding tricks or coding techniques intended as optimization hints to the compiler. The aim is not only to make the code more readable, but also to allow programmers to concentrate on the important aspects of a program without getting bogged down in implementation
    0.00
    0 votes
    79
    Embarcadero Delphi

    Embarcadero Delphi

    • Language Paradigms: Object-oriented programming
    Embarcadero Delphi is an integrated development environment for console, desktop graphical, web, and mobile applications. Delphi's compilers use its own Object Pascal dialect of Pascal and generate native code for 32- and 64-bit Windows operating systems, as well as 32-bit Mac OS X and iOS. (iOS code generation is done with the Free Pascal compiler.) As of late 2011 support for the Linux and Android operating system was planned by Embarcadero. To create applications for managed code platforms, a similar (but not mutually compatible) alternative is Delphi Prism. Delphi was originally developed by Borland as a rapid application development tool for Windows, and as the successor of Borland Pascal. Delphi and its C++ counterpart, C++Builder, shared many core components, notably the IDE and VCL, but remained separate until the release of RAD Studio 2007. RAD Studio is a shared host for Delphi, C++Builder, and others. In 2006, Borland’s developer tools section were transferred to a wholly owned subsidiary known as CodeGear, which was sold to Embarcadero Technologies in 2008. Delphi was originally one of many codenames of a pre-release development tool project at Borland. Borland
    0.00
    0 votes
    80
    English Language

    English Language

    English is a West Germanic language that was first spoken in England and is now the most widely used language in the world. It is spoken as a first language by a majority of the inhabitants of several nations, including the United Kingdom, the United States, Canada, Australia, the Republic of Ireland, New Zealand, and a number of Caribbean nations. It is the third most common native language in the world, after Mandarin Chinese and Spanish. It is widely learned as a second language and is an official language of the European Union, many Commonwealth countries and the United Nations, as well as in many world organisations. English arose in the Anglo-Saxon kingdoms of England and what is now south-east Scotland, but was then under the control of the kingdom of Northumbria. Following the extensive influence of Great Britain and the United Kingdom from the 17th century to the mid-20th century, via the British Empire, and of the United States since the mid-20th century, it has been widely propagated around the world, becoming the leading language of international discourse and the lingua franca in many regions. Historically, English originated from the fusion of closely related
    0.00
    0 votes
    81

    Epigram programming language

    • Language Paradigms: Functional programming
    • Influenced: Agda theorem prover
    • Influenced By: Haskell
    Epigram is the name of a functional programming language with dependent types. Epigram also refers to the IDE usually packaged with the language. Epigram's type system is strong enough to express program specifications. The goal is to support a smooth transition from ordinary programming to integrated programs and proofs whose correctness can be checked and certified by the compiler. Epigram exploits the propositions as types principle, and is based on intuitionistic type theory. The Epigram prototype was implemented by Conor McBride based on joint work with James McKinna. Its development is continued by the Epigram group in Nottingham, Durham, St Andrews and Royal Holloway in the UK. The current experimental implementation of the Epigram system is freely available together with a user manual, a tutorial and some background material. The system has been used under Linux, Windows and Mac OS X. Epigram uses a two-dimensional syntax, with a LaTeX version and an ASCII version. Here are some examples from The Epigram Tutorial: The following declaration defines the natural numbers: The declaration says that Nat is a type with kind * (i.e., it is a simple type) and two constructors: zero
    0.00
    0 votes
    82
    Erlang

    Erlang

    • Language Paradigms: Functional programming
    • Influenced: Scala
    • Influenced By: Prolog
    Erlang ( /ˈɜrlæŋ/ ER-lang) is a general-purpose concurrent, garbage-collected programming language and runtime system. The sequential subset of Erlang is a functional language, with strict evaluation, single assignment, and dynamic typing. It was designed by Ericsson to support distributed, fault-tolerant, soft-real-time, non-stop applications. It supports hot swapping, so that code can be changed without stopping a system. While threads require external library support in most languages, Erlang provides language-level features for creating and managing processes with the aim of simplifying concurrent programming. Though all concurrency is explicit in Erlang, processes communicate using message passing instead of shared variables, which removes the need for locks. The first version was developed by Joe Armstrong in 1986. It was originally a proprietary language within Ericsson, but was released as open source in 1998. The name "Erlang", attributed to Bjarne Däcker, has been understood as a reference to Danish mathematician and engineer Agner Krarup Erlang, and (initially at least) simultaneously as an abbreviation of "Ericsson Language". Erlang was designed with the aim of
    0.00
    0 votes
    83
    EToys

    EToys

    • Language Paradigms: Object-oriented programming
    • Influenced: Scratch
    • Influenced By: Logo
    Etoys is a child-friendly computer environment and object-oriented prototype-based programming language for use in education. Etoys is a media-rich authoring environment with a scripted object model for many different objects that runs on different platforms and is free and open source. Etoys development was inspired and directed by Alan Kay and his work to advance and support constructionist learning. Primary influences include Seymour Papert and the Logo programming language, a dialect of Lisp optimized for educational use; work done at Xerox Palo Alto Research Center, PARC; Smalltalk, HyperCard, and StarLogo (cf. ). The drag and drop tile-based approach is very similar to AgentSheets. Scott Wallace is the main author . Promotion and development of the main Squeak version of Etoys is co-ordinated by the Viewpoints Research Institute, a U.S. educational non-profit. Etoys was a major influence on a similar Squeak-based programming environment known as Scratch. Scratch was designed with Etoys code in the early 21st century by the MIT Media Lab, initially targeted at after-school computer clubs. The Etoys system is based on the idea of programmable virtual entities behaving on the
    0.00
    0 votes
    84

    EuLisp

    • Language Paradigms: Functional programming
    • Influenced: Dylan
    • Influenced By: Common Lisp
    EuLisp is a statically and dynamically scoped Lisp dialect developed by a loose formation of industrial and academic Lisp users and developers from around Europe. The standardizers intended to create a new Lisp "less encumbered by the past" (compared to Common Lisp), and not so minimalistic as Scheme. Another objective was to integrate the Object-oriented programming paradigm well. Language definition process first began in a meeting in 1985 in Paris and took a long time. The complete specification and a first implementation (interpreted-only) was available in 1990. Its primary characteristics are that it is a Lisp-1 (no separate function and variable namespaces), has a CLOS-style (Common Lisp Object System) generic-function type object-oriented system named TELOS (The EuLisp Object System) integrated from the ground up, has a built-in module system, and is defined in layers to promote the use of the Lisp on small, embedded hardware and educational machines. It supports continuations, though not as powerfully as Scheme. It has a simple lightweight process mechanism (threads). An early implementation of EuLisp was FEEL (Free and Eventually Eulisp). The successor to FEEL was Youtoo
    0.00
    0 votes
    85
    Euphoria programming language

    Euphoria programming language

    • Language Paradigms: Imperative programming
    • Influenced By: Ada
    Euphoria is a programming language originally created by Robert Craig of Rapid Deployment Software in Toronto. Initially developed (though not publicly released) on the Atari ST, the first commercial release was for the 16-bit Microsoft MS-DOS platform and was proprietary. In 2006 (with the release of version 3), Euphoria became open source and the openEuphoria Group continues to administer and develop the project. In December 2010, the openEuphoria Group released version 4 of openEuphoria along with a new identity and mascot for the project. OpenEuphoria is currently available for Microsoft Windows, Linux, OS X and three flavors of *BSD. Euphoria is a general-purpose high-level imperative/procedural interpreted language. A translator generates C source code and the GCC and Open Watcom compilers are supported. Alternatively, Euphoria programs may be bound with the interpreter to create stand-alone executables. A number of GUI libraries are supported including Win32lib and wrappers for wxWidgets, GTK+ and IUP. Euphoria has a simple built-in database and wrappers for a variety of other databases. The Euphoria language is a general purpose procedural language that focuses on
    0.00
    0 votes
    86

    F-Script programming language

    • Language Paradigms: Object-oriented programming
    • Influenced By: APL
    F-Script is an object-oriented scripting programming language for Apple's Mac OS X operating system developed by Philippe Mougin. F-Script is tagged as Cocoa developer's best friend, wherein the package provides an integrated set of tools that makes it possible to interactively explore and manipulate Cocoa objects as well as script them using new high-level programming techniques. F-Script is Smalltalk with support for array programming for Cocoa Objects. F-Script is based on a pure object paradigm (every entity manipulated within the language is an object), its base syntax and concepts being identical to those of Smalltalk (the canonical example of the category) with specific extensions to support array programming as in the APL programming language. F-Script provides an interpreted, interactive environment with support for workspaces, which provide a rich set of functionality including object persistence, distributed objects, GUI framework, database access, among other things. Like Smalltalk, F-Script's syntax is very simple, without requiring specific notation for control structures which are provided in a unified manner by the message send operation. Unlike Smalltalk, F-Script
    0.00
    0 votes
    87
    Factor

    Factor

    • Language Paradigms: Concatenative programming language
    • Influenced: Cat
    • Influenced By: Joy
    Factor is a stack-oriented programming language created by Slava Pestov. Factor is dynamically typed and has automatic memory management, as well as powerful metaprogramming features. The language has a single implementation featuring a self-hosted optimizing compiler and an interactive development environment. The Factor distribution includes a large standard library. Slava Pestov created Factor in 2003 as a scripting language for a video game. The initial implementation, now referred to as JFactor, was implemented in Java and ran on the Java Virtual Machine. Though the early language resembled modern Factor superficially in terms of syntax, the modern language is very different in practical terms and the current implementation is much faster. The language has changed significantly over time. Originally, Factor programs centered around manipulating Java objects with Java's reflection capabilities. From the beginning, the design philosophy has been to modify the language to suit programs written in it. As the Factor implementation and standard libraries grew more detailed, the need for certain language features became clear, and they were added. JFactor did not have an object
    0.00
    0 votes
    88
    Flow-based programming

    Flow-based programming

    In computer science, flow-based programming (FBP) is a programming paradigm that defines applications as networks of "black box" processes, which exchange data across predefined connections by message passing, where the connections are specified externally to the processes. These black box processes can be reconnected endlessly to form different applications without having to be changed internally. FBP is thus naturally component-oriented. FBP is a particular form of dataflow programming based on bounded buffers, information packets with defined lifetimes, named ports, and separate definition of connections. The FBP development approach views an application not as a single, sequential, process, which starts at a point in time, and then does one thing at a time until it is finished, but as a network of asynchronous processes communicating by means of streams of structured data chunks, called "information packets" (IPs). In this view, the focus is on the application data and the transformations applied to it to produce the desired outputs. The network is defined externally to the processes, as a list of connections which is interpreted by a piece of software, usually called the
    0.00
    0 votes
    89

    FLOW-MATIC

    • Influenced: COBOL
    FLOW-MATIC, originally known as B-0 (Business Language version 0), was the first English-like data processing language. It was developed for the UNIVAC I at Remington Rand under Grace Hopper. Hopper had found that business data processing customers were uncomfortable with mathematical notation. In late 1953 she proposed that data processing problems should be expressed using English keywords, but Rand management considered the idea unfeasible. In early 1955, she and her team wrote a specification for such a programming language and implemented a prototype. The FLOW-MATIC compiler became publicly available in early 1958 and was substantially complete in 1959. First, FLOW-MATIC was the first programming language to express operations using English-like statements. Second, FLOW-MATIC was the first system to distinctly separate the description of data from the operations on it. Its data definition language, unlike its executable statements, was not English-like; rather, data structures were defined by filling in pre-printed forms. Flow-Matic was a major influence in the design of COBOL, since only it and its direct descendent AIMACO were in actual use at the time. Several elements of
    0.00
    0 votes
    90
    Forth

    Forth

    • Language Paradigms: Stack-oriented programming language
    • Influenced: PostScript
    • Influenced By: APL
    Forth is an imperative stack-based computer programming language and programming environment. Language features include structured programming, reflection (the ability to modify the program structure during program execution), concatenative programming (functions are composed with juxtaposition) and extensibility (the programmer can create new commands). Although not an acronym, the language's name is sometimes spelled with all capital letters as FORTH, following the customary usage during its earlier years. A procedural programming language without type checking, Forth features both interactive execution of commands (making it suitable as a shell for systems that lack a more formal operating system) and the ability to compile sequences of commands for later execution. Some Forth implementations (usually early versions or those written to be extremely portable) compile threaded code, but many implementations today generate optimized machine code like other language compilers. Although not as popular as other programming systems, Forth has enough support to keep several language vendors and contractors in business. Forth is currently used in boot loaders such as Open Firmware, space
    0.00
    0 votes
    91

    Fortran

    • Language Paradigms: Object-oriented programming
    • Influenced: PL/I
    • Influenced By: Modula-2
    Fortran (previously FORTRAN) is a general-purpose, imperative programming language that is especially suited to numeric computation and scientific computing. Originally developed by IBM at their campus in south San Jose, California 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, 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 structured programming and processing of character-based data (FORTRAN 77), array programming, modular programming and generic programming (Fortran 90), high
    0.00
    0 votes
    92

    FoxPro 2

    • Influenced By: dBase
    FoxPro is a text-based procedurally oriented programming language and DBMS, originally published by Fox Software and later by Microsoft, for MS-DOS, MS Windows, Apple Macintosh, and UNIX. Although FoxPro is a Database Management System (DBMS) and it does support relationships between tables, it is not considered a Relational Database Management System (RDBMS), lacking transactional processing. The final published release of FoxPro was 2.6, after which the name was changed to Visual FoxPro. Although no longer sold or supported by Microsoft, there is still an active worldwide community of FoxPro users and programmers. FoxPro 2.6 for UNIX (FPU26) has even been successfully installed on Linux and FreeBSD using the Intel Binary Compatibility Standard (ibcs2) support library. FoxPro 2 included "Rushmore" optimizing engine, which used indices to accelerate data retrieval and updating. Rushmore technology examined every data-related statement, and looked for filter expressions. If one was used, it looked for an index matching the same expression. In addition, FoxPro2 was originally built on WatCOM C++, which had its own memory extensor - at that time state-of-the-art. FoxPro2 could access
    0.00
    0 votes
    93
    G-code

    G-code

    G-code is the common name for the most widely used computer numerical control (CNC) programming language, which has many implementations. Used mainly in automation, it is part of computer-aided engineering. G-code is sometimes called G programming language. In fundamental terms, G-code is a language in which people tell computerized machine tools what to make and how to make it. The "what" and "how" are mostly defined by instructions on where to move to, how fast to move, and through what path to move. The most common situation is that a cutting tool is moved according to these instructions, cutting away excess material to leave only the finished workpiece. Non-cutting tools, such as cold-forming tools, burnishing tools, or measuring probes, are also sometimes involved. The first implementation of numerical control was developed at the MIT Servomechanisms Laboratory in the early 1950s. In the decades since, many implementations have been developed by many (commercial and noncommercial) organizations. G-code has often been used in these implementations. The main standardized version used in the United States was settled by the Electronic Industries Alliance in the early 1960s. A
    0.00
    0 votes
    94

    Gambas

    • Influenced By: Visual Basic
    Gambas is the name of an object-oriented dialect of the BASIC programming language as well as the integrated development environment that accompanies it. Designed to run on Linux and other Unix-like computer operating systems, its name is a recursive acronym for Gambas Almost Means Basic. Gambas is also the word for prawns in the Spanish language, from which the project's logos are derived. Gambas is included in a number of Linux distributions' repositories, such as Debian's, Fedora's, Mandriva Linux's and Ubuntu's. There is a Windows version of Gambas which can run under the Cygwin environment, although this version is significantly less tested than its Linux counterparts and is command line only; coLinux and derivatives have also been used. Gambas from version 3.2 can run on Raspberry Pi. Gambas was developed by the French programmer Benoît Minisini with its first release coming in 1999. Benoît had grown up with the BASIC language, and decided to make a free software development environment that could quickly and easily make programs with user interfaces. The Gambas 1.x versions featured an interface made up of several different separate windows for forms and IDE dialogues in a
    0.00
    0 votes
    95

    Game Oriented Assembly Lisp

    • Language Paradigms: Functional programming
    Game Oriented Assembly Lisp (or GOAL) is a video game programming language developed by Andy Gavin and the Jak and Daxter team at Naughty Dog. It was written using Allegro Common Lisp and used in the development of the entire Jak and Daxter series of games. Syntactically GOAL resembles Scheme, though with many idiosyncratic features such as classes, inheritance, and virtual functions. GOAL encourages an imperative programming style: programs tend to consist of a sequence of events to be executed rather than the functional programming style of functions to be evaluated recursively. This is a diversion from Scheme, which allows such side-effects but does not encourage imperative style. GOAL does not run in an interpreter, but instead is compiled directly into PlayStation 2 machine code for execution. It offers limited facilities for garbage collection, relying extensively on runtime support. It offers dynamic memory allocation primitives designed to make it well-suited to running in constant memory on a video game console. GOAL has extensive support for inlined assembly code using a special rlet form , allowing programmers to freely mix assembly and higher-level constructs within the
    0.00
    0 votes
    96
    Glagol

    Glagol

    Glagol (Russian Глагол, "verb") is a programming language based on the Russian lexicon. It is strongly reminiscent of Oberon and Pascal. The complete distribution includes, along with the compiler, a set of mathematical and system libraries, games and applications with source code attached. The terminology used in Glagol is different from what is used to describe most programming languages. While it is closer to everyday Russian speech, it may confuse those who want to learn Glagol but who already know another programming language. «Hello world»:
    0.00
    0 votes
    97
    GNU Octave

    GNU Octave

    GNU Octave is a high-level language, primarily intended for numerical computations. It provides a convenient command-line interface (CLI) for solving linear and nonlinear problems numerically, and for performing other numerical experiments using a language that is mostly compatible with MATLAB. It may also be used as a batch-oriented language. As part of the GNU Project, it is free software under the terms of the GNU General Public License (GPL). The project was conceived around 1988. At first it was intended to be a companion to a chemical reactor design course. Real development was started by John W. Eaton in 1992. The first alpha release dates back to January 4, 1993 and on February 17, 1994 version 1.0 was released. Version 3.0 was released on December 21, 2007. The program is named after Octave Levenspiel, a former professor of the principal author. Levenspiel is known for his ability to perform quick back-of-the-envelope calculations. In addition to use on desktops for personal scientific computing, Octave is used in academia and industry. For example, Octave was used on a massive parallel computer at Pittsburgh supercomputing center to find vulnerabilities related to
    0.00
    0 votes
    98
    GNU Pascal

    GNU Pascal

    GNU Pascal (GPC) is a Pascal compiler composed of a frontend to GNU Compiler Collection (GCC), similar to the way Fortran and other languages were added to GCC. GNU Pascal is ISO 7185 compatible, and it implements "most" of the ISO 10206 Extended Pascal standard. The major advantage of piggybacking GNU Pascal on the GCC compiler is that it is instantly portable to any platform the GCC compiler supports. In July 2010 a developer publicly asked opinion on the future of GNU Pascal, due to developer shortage and maintenance issues as a GCC port. There was a lively discussion on the maillist where the developers seemed to lean towards reimplementing in C++ with a C code generating backend. The maillist went to sleep again, and as of November 2011 no further releases or announcements had been made.
    0.00
    0 votes
    99
    Go

    Go

    • Language Paradigms: Compiled language
    • Influenced By: Limbo programming language
    Go is a compiled, garbage-collected, concurrent programming language developed by Google Inc. The initial design of Go was started in September 2007 by Robert Griesemer, Rob Pike, and Ken Thompson. Go was officially announced in November 2009. In May 2010, Rob Pike publicly stated that Go was being used "for real stuff" at Google. Go's "gc" compiler targets the Linux, Mac OS X, FreeBSD, OpenBSD, Plan 9, and Microsoft Windows operating systems and the i386, amd64, and ARM processor architectures. Go aims to provide the efficiency of a statically typed compiled language with the ease of programming of a dynamic language. Other goals include: The syntax of Go is broadly similar to that of C: blocks of code are surrounded with curly braces; common control flow structures include for, switch, and if. Unlike C, line-ending semicolons are optional, variable declarations are written differently and are usually optional, type conversions must be made explicit, and new go and select control keywords have been introduced to support concurrent programming. New built-in types include maps, UTF-8 strings (without proper Unicode strings abstraction), array slices, and channels for inter-thread
    0.00
    0 votes
    100
    GOAL Agent Programming Language

    GOAL Agent Programming Language

    GOAL is an agent programming language for programming rational agents. GOAL agents derive their choice of action from their beliefs and goals. The language provides the basic building blocks to design and implement rational agents by means of a set of programming constructs. These programming constructs allow and facilitate the manipulation of an agent's beliefs and goals and to structure its decision-making. The language provides an intuitive programming framework based on common sense or practical reasoning. The main features of GOAL include: A GOAL agent program consists of six different sections, including the knowledge, beliefs, goals, action rules, action specifications, and percept rules, respectively. The knowledge, beliefs and goals are represented in a knowledge representation language such as Prolog, Answer set programming, SQL (or Datalog), or the Planning Domain Definition Language, for example. Below, we illustrate the components of a GOAL agent program using Prolog. The overall structure of a GOAL agent program looks like: The GOAL agent code used to illustrate the structure of a GOAL agent is an agent that is able to solve Blocks world problems. The beliefs of the
    0.00
    0 votes
    101

    Gödel programming language

    • Language Paradigms: Logic programming
    Gödel is a declarative, general-purpose programming language that adheres to the logic programming paradigm. It is a strongly typed language, the type system being based on many-sorted logic with parametric polymorphism. It is named after logician Kurt Gödel. Gödel has a module system, and it supports arbitrary precision integers, arbitrary precision rationals, and also floating-point numbers. It can solve constraints over finite domains of integers and also linear rational constraints. It supports processing of finite sets. It also has a flexible computation rule and a pruning operator which generalises the commit of the concurrent logic programming languages. Gödel's meta-logical facilities provide support for meta-programs that do analysis, transformation, compilation, verification, and debugging, among other tasks. The following Gödel module is a specification of the greatest common divisor (GCD) of two numbers. It is intended to demonstrate the declarative nature of Gödel, not to be particularly efficient. The CommonDivisor predicate says that if i and j are not zero, then d is a common divisor of i and j if it lies between 1 and the smaller of i and j and divides both i and j
    0.00
    0 votes
    102

    Groovy

    • Language Paradigms: Object-oriented programming
    • Influenced By: Ruby
    Groovy is an object-oriented programming language for the Java platform. It is a dynamic language with features similar to those of Python, Ruby, Perl, and Smalltalk. It can be used as a scripting language for the Java Platform, is dynamically compiled to Java Virtual Machine (JVM) bytecode, and interoperates with other Java code and libraries. Groovy uses a Java-like bracket syntax. Most Java code is also syntactically valid Groovy. Groovy 1.0 was released on January 2, 2007, and Groovy 2.0 in July, 2012. Groovy 3.0 is planned for release in 2013, with support for Java 8 features and a new Meta Object Protocol. Since version 2 Groovy can also be compiled statically, offering type inference and performance close to, or even greater than, Java's. Groovy is backed by VMware, after its acquisition of SpringSource, which acquired G2One, the Groovy and Grails company. James Strachan first talked about the development of Groovy in his blog in August 2003. Several versions were released between 2004 and 2006. After the JCP standardization process began, the version numbering was changed and a version called "1.0" was released on January 2, 2007. After various betas and release candidates
    0.00
    0 votes
    103
    Harbour compiler

    Harbour compiler

    • Language Paradigms: Object-oriented programming
    • Influenced: XHarbour
    • Influenced By: dBase
    Harbour is a modern computer programming language, primarily used to create database/business programs. It is a modernized, open sourced and cross-platform version of the older and largely DOS-only Clipper system, which in turn developed from the dBase database market of the 1980s and 90s. Harbour code using the same databases can be compiled under a wide variety of platforms, including DOS, Microsoft Windows, Linux, Unix variants, several BSD descendants, Mac OS X, MINIX 3, Windows CE, Pocket PC, Symbian, iPhone, QNX, VxWorks, OS/2/eComStation, BeOS/Haiku, AIX. The idea of a free software Clipper compiler had been floating around for a long time and the subject has often cropped up in discussion on comp.lang.clipper. Antonio Linares founded the Harbour project and the implementation was started. The name "Harbour" is a play on a Clipper as a type of ship. Harbour is a synonym for port (where ship docks), and Harbour is a port of the Clipper language. On 2009 Harbour was substantially redesigned, mainly by Viktor Szakáts and Przemyslaw Czerpak. Harbour extends the Clipper Replaceable Database Drivers (RDD) approach. It offers multiple RDDs such as DBF, DBFNTX, DBFCDX, DBFDBT and
    0.00
    0 votes
    104

    Hartmann pipeline

    • Influenced By: APL
    A Hartmann pipeline is an extension of the Unix pipeline concept, providing for more complex paths, multiple input/output streams, and other features. It is an example and extension of Pipeline programming. A Hartmann pipe is a non-procedural representation of a solution of a data processing problem as a dataflow. The error-prone step of translating the dataflow to a traditional procedural programming language is eliminated. Hartmann pipelines may thus be considered as an executable specification language. The concept was developed by John Poul Hartmann (born 1946), a Danish engineer with IBM. It is available as a software product CMS/TSO Pipelines for a number of IBM platforms. A somewhat backlevel version is included with every level of VM/ESA and z/VM. A pipeline consists of a collection of stages, joined together by stage separators. Stages can be written in a variety of languages, and are either filters that process data records or device drivers (sources and sinks) that read data into or out of the pipeline. Unlike other implementations of pipeline programming, Hartmann's design has multiple streams in and out of each stage and can interconnect them non-sequentially. Unlike
    0.00
    0 votes
    105
    HaXe

    HaXe

    • Language Paradigms: Multi-paradigm programming language
    • Influenced By: ActionScript
    Haxe is a versatile open-source high-level multiplatform programming language described on its website as a "universal language". It can produce: The code can be produced entirely within the Haxe development environment, sometimes requiring Neko, by using a single and unmodified code-base when compiling from one target to the next. Development of Haxe was started on the October 22, 2005. The first alpha version of Haxe was released on the 14th of November, in the same year. The first beta version was released on the 4th of February, 2006. Haxe 1.0 was released on the 17th of April, in the same year. The current release of Haxe is version 2.10, which was released on July 16, 2012. Haxe is the "successor" to MTASC . Haxe code therefore has much in common with AS3 but with many improvements and output capabilities which puts it in an entirely different category than the Adobe Compilers. Originally its main advantage was the combination of wide platform-independence and a fully developed high-level language. An increasingly noteworthy advantage is its ability to use such a language to target a device-manufacturer who allows only C++ based code, their own IDE, and very little else. The
    0.00
    0 votes
    106
    HTML

    HTML

    • Influenced: Curl programming language
    • Influenced By: XML
    HyperText Markup Language (HTML) is the main markup language for displaying web pages and other information that can be displayed in a web browser. HTML is written in the form of HTML elements consisting of tags enclosed in angle brackets (like ), within the web page content. HTML tags most commonly come in pairs like
    0.00
    0 votes
    107
    Hume

    Hume

    • Language Paradigms: Functional programming
    Hume is a functionally based programming language developed at the University of St Andrews and Heriot-Watt University in Scotland since the year 2000. The language name is both an acronym meaning 'Higher-order Unified Meta-Environment' and an honorific to the 18th Century philosopher David Hume. It targets real-time embedded systems, aiming to produce a design that is both highly abstract, yet which will still allow precise extraction of time and space execution costs. This allows programmers to guarantee the bounded time and space demands of executing programs. Hume is unusual in combining functional programming ideas with ideas from finite state automata. Automata are used to structure communicating programs into a series of "boxes", where each box maps inputs to outputs in a purely functional way using high-level pattern-matching. It is also unusual in being structured as a series of levels, each of which exposes different machine properties. The Hume language design attempts to maintain the essential properties and features required by the embedded systems domain (especially for transparent time and space costing) whilst incorporating as high a level of program abstraction as
    0.00
    0 votes
    108
    IBM 1620

    IBM 1620

    The IBM 1620 was announced by IBM on October 21, 1959, and marketed as an inexpensive "scientific computer". After a total production of about two thousand machines, it was withdrawn on November 19, 1970. Modified versions of the 1620 were used as the CPU of the IBM 1710 and IBM 1720 Industrial Process Control Systems (making it the first digital computer considered reliable enough for real-time process control of factory equipment). Being variable word length decimal, as opposed to fixed-word-length pure binary, made it an especially attractive first computer to learn on — and hundreds of thousands of students had their first experiences with a computer on the IBM 1620. Core memory cycle times were 20 microseconds for the Model I, 10 microseconds for the Model II (about a thousand times slower than typical computer main memory in 2006). Many in the user community recall the 1620 being referred to as CADET, jokingly meaning "Can't Add, Doesn't Even Try", referring to the use of addition tables in memory rather than dedicated addition circuitry. For an explanation of all three known interpretations of the machine's code name see the section on the machine's development history. It
    0.00
    0 votes
    109

    IMP programming language

    This article is about Irons IMP. See also the contemporary and unrelated Edinburgh IMP programming language. IMP was a systems programming language developed by E. T. Irons in the late 1960s through early 1970s. Unlike most other systems programming languages, IMP was an extensible syntax programming language. Even though its designer refers to the language as "being based on ALGOL", IMP excludes many defining features of that language, while supporting a very non-ALGOL-like one: syntax extensibility. A compiler for IMP existed as early as 1965 and was used for programming the CDC 6600 time-sharing system, which was in use at the Institute for Defense Analyses since 1967. Although the compiler is slower than comparable ones for non-extensible languages, it has been used for practical production work. IMP compilers were developed for the CDC-6600, Cray, PDP-10 and PDP-11 computers. Important IMP versions were IMP65, IMP70, and IMP72. Being an extensible syntax programming language, IMP allows the programmer to extend its syntax, although no specific means are provided to add new datatypes or structures to it. To achieve its syntax-extensibility, IMP uses a powerful parse algorithm
    0.00
    0 votes
    110
    INTERCAL

    INTERCAL

    INTERCAL is an esoteric programming language that was created as a parody by Don Woods and James M. Lyon, two Princeton University students, in 1972. It satirizes aspects of the various programming languages at the time, as well as the proliferation of proposed language constructs and notations in the 1960s. There are two currently maintained versions of INTERCAL: C-INTERCAL, formerly maintained by Eric S. Raymond, and CLC-INTERCAL, maintained by Claudio Calvelli. According to the original manual by the authors, The original Princeton implementation used punched cards and the EBCDIC character set. To allow INTERCAL to run on computers using ASCII, substitutions for two characters had to be made: $ substituted for ¢ as the mingle operator, "represent[ing] the increasing cost of software in relation to hardware", and ? was substituted for ∀ as the unary exclusive-or operator to "correctly express the average person's reaction on first encountering exclusive-or". In recent versions of C-INTERCAL, the older operators are supported as alternatives; INTERCAL programs may now be encoded in ASCII, Latin-1, UTF-8, EBCDIC, Hollerith, or Baudot. INTERCAL was intended to be completely
    0.00
    0 votes
    111

    IronPython

    IronPython is an implementation of the Python programming language targeting the .NET Framework and Mono. Jim Hugunin created the project and actively contributed to it up until Version 1.0 which was released on September 5, 2006. Thereafter, it was maintained by a small team at Microsoft until the 2.7 Beta 1 release; Microsoft abandoned IronPython (and its sister project IronRuby) in late 2010, after which event Hugunin left to work at Google. IronPython 2.0 was released on December 10, 2008. IronPython is written entirely in C#, although some of its code is automatically generated by a code generator written in Python. IronPython is implemented on top of the Dynamic Language Runtime (DLR), a library running on top of the Common Language Infrastructure that provides dynamic typing and dynamic method dispatch, among other things, for dynamic languages. The DLR is part of the .NET Framework 4.0 and is also a part of trunk builds of Mono. The DLR can also be used as a library on older CLI implementations. Release 2.0, released on December 10, 2008, and updated as 2.0.3 on October 23, 2009, targets CPython 2.5. IronPython 2.0.3 is only compatible up to .NET Framework 3.5. Release 2.6,
    0.00
    0 votes
    112

    J#

    • Language Paradigms: Object-oriented programming
    • Influenced By: Visual J++
    Visual J# (pronounced 'jay-sharp') programming language is a discontinued transitional language for programmers of Java and Visual J++ languages, so they may use their existing knowledge and applications on .NET Framework. In programming, J# can work with Java bytecode as well as source so it can be used to transition applications that use third-party libraries even if their original source code is unavailable. It was developed by the Hyderabad-based Microsoft India Development Center at HITEC City in India. Java and J# use the same general syntax but there are non-Java conventions in J# to support the .NET environment. For example, to use .NET "properties" with a standard JavaBean class, it is necessary to prefix getXxx and setXxx methods with the Javadoc-like annotation: ...and change the corresponding private variable name to be different from the suffix of the getXxx/setXxx names. J# does not compile Java-language source code to Java bytecode (.class files), and does not support Java applet development or the ability to host applets directly in a web browser, although it does provide a wrapper called Microsoft J# Browser Controls for hosting them as ActiveX objects. Finally,
    0.00
    0 votes
    113

    Janus

    • Influenced: ToonTalk computer programming language
    The name Janus refers to at least two computer programming languages or partial descriptions of possible computer programming languages: Janus is a computer programming language partially described by K. Kahn and Vijay A. Saraswat in "Actors as a special case of concurrent constraint (logic) programming", in SIGPLAN Notices, October 1990. Janus is a concurrent constraint language without backtracking. Janus models concurrency through the use of bag channels. Code that needs to send a message to a process does so by constraining a bag to be the union of another bag and the singleton bag of the message. The other bag is then available to be constrained for sending subsequent messages. The process receives the message by matching the bag to a pattern that says it is the union of some singleton and some other bag. The logic of the bag channels produces a property shared by the actor model, namely that the order of arrival of the messages is not guaranteed. However, unlike actors in the actor model, processes in Janus can pass around their "mailboxes" so to speak, in the form of bags, and can hold more than one. This ability to pass mailboxes around and hold more than one is inherited
    0.00
    0 votes
    114

    JavaScript syntax

    • Influenced By: AWK
    The syntax of JavaScript is the set of rules that define a correctly structured JavaScript program. The examples below make use of the alert function for standard text output. The JavaScript standard library lacks an official standard text output function. However, given that JavaScript is mainly used for client-side scripting within modern web browsers, and that almost all web browsers provide the alert function, alert is used in the examples. Brendan Eich summarized the ancestry of the syntax in the first paragraph of the JavaScript 1.1 specification as follows: JavaScript is case sensitive. It is common to start the name of a constructor with a capitalised letter, and the name of a function or variable with a lower-case letter. Spaces, tabs and newlines used outside of string constants are called whitespace. Unlike C, whitespace in JavaScript source can directly impact semantics. Because of a technique called "semicolon insertion", some statements that are well formed when a newline is parsed will be considered complete (as if a semicolon were inserted just prior to the newline). Programmers are advised to supply statement-terminating semicolons explicitly because it may lessen
    0.00
    0 votes
    115

    JOSS

    • Influenced: BASIC
    JOSS (an acronym for JOHNNIAC Open Shop System) was one of the very first interactive, time sharing programming languages. JOSS I, developed by J. Clifford Shaw at RAND was first implemented, in beta form, on the JOHNNIAC computer in May 1963. The full implementation was deployed in January 1964, supporting 5 terminals and the final version, supporting 10 terminals, was deployed in January 1965. JOSS was written in a symbolic assembly language called EasyFox (E and F in the US military's phonetic alphabet of that time). EasyFox was also developed by Cliff Shaw. JOSS was dubbed "The Helpful Assistant" and is renowned for its conversational user interface. Originally green/black typewriter ribbons were used in its terminals with green being used for user input and black for the computer's response. Any command that was not understood elicited the response "Eh?". JOSS II, was developed by Charles L. Baker, Joseph W. Smith, Irwin D. Greenwald, and G. Edward Bryan for the PDP-6 computer between 1964 and February 1966. Many variants of JOSS were developed and implemented on a variety of platforms. Some of these variants remained very similar to the original: TELCOMP, FOCAL, CAL, CITRAN,
    0.00
    0 votes
    116

    Joule

    • Language Paradigms: Object-oriented programming
    • Influenced: E
    • Influenced By: T
    Joule is a concurrent dataflow programming language, designed for building distributed applications. It is so concurrent that the order of statements within a block is irrelevant to the operation of the block. Statements are executed whenever possible, based on their inputs. Everything in Joule happens by sending messages. There is no control flow. Instead, the programmer describes the flow of data, making it a dataflow programming language. It is considered the precursor to the E programming language. Numerals consist of ASCII digits 0-9. Identifiers are UNICODE sequences of digits, letters, and operator characters that begin with a letter. It is also possible to form identifiers by using UNICODE sequences (including whitespace) enclosed by either straight (' ') or standard (‘ ’) single quotes, where the backslash is the escape character. Keywords have to start with a letter, except the • keyword to send information. Operators consist of UNICODE sequences of digits, letters, and operator characters, beginning with an operator character. Labels are identifiers followed by a colon (':'). At the root, Joule is an imperative language and because of that a statement-based language. It
    0.00
    0 votes
    117

    JScript .NET

    • Language Paradigms: Multi-paradigm programming language
    • Influenced By: ECMAScript
    JScript .NET is a .NET programming language developed by Microsoft as a natural successor to the Active Scripting language JScript, Microsoft's implementation of edition 3 of the ECMAScript standard. Their implementation of edition 5 in Windows 8 is called JavaScript. [sic] The primary differences between JScript and JScript .NET can be summarized as follows: Firstly, JScript is a scripting language, and as such programs (or more suggestively, scripts) can be executed without the need to compile the code first. This is not the case with the JScript .NET command-line compiler, since this next-generation version relies on the .NET Common Language Runtime (CLR) for execution, which requires that the code be compiled to Common Intermediate Language (CIL), formerly called Microsoft Intermediate Language (MSIL), code before it can be run. Nevertheless, JScript .NET still provides full support for interpreting code at runtime (e.g., via the Function constructor or the eval function) and indeed the interpreter can be exposed by custom applications hosting the JScript .NET engine via the VSA interfaces. Secondly, JScript has a strong foundation in Microsoft's ActiveX/COM technologies, and
    0.00
    0 votes
    118

    K

    • Language Paradigms: Functional programming
    • Influenced: Q
    • Influenced By: APL
    K is a proprietary array processing language developed by Arthur Whitney and commercialized by Kx Systems. The language serves as the foundation for kdb, an in-memory, column-based database, and other related financial products. The language, originally developed in 1993, is a variant of APL and contains elements of Scheme. Advocates of the language emphasize its speed, facility in handling arrays, and expressive syntax. Before developing K, Arthur Whitney had worked extensively with APL, first at I. P. Sharp Associates alongside Ken Iverson and Roger Hui, and later at Morgan Stanley developing financial applications. At Morgan Stanley, Whitney helped to develop A+, a variant of APL, to facilitate the migration of APL applications from IBM mainframes to a network of Sun workstations. A+ had a smaller set of primitive functions and was designed for speed and to handle large sets of time series data. In 1993, Whitney left Morgan Stanley and developed the first version of the K language. At the same time he formed Kx Systems to commercialize the product and signed an exclusive contract with Union Bank of Switzerland (UBS). For the next four years he developed various financial and
    0.00
    0 votes
    119

    Karel programming language

    • Language Paradigms: Object-oriented programming
    • Influenced: Karel++
    • Influenced By: Pascal
    Karel is an educational programming language for beginners, created by Richard E. Pattis in his book Karel The Robot: A Gentle Introduction to the Art of Programming. Pattis used the language in his courses at Stanford University, California. The language is named after Karel Čapek, a Czech writer who introduced the word robot. A program in Karel is used to control a simple robot named Karel that lives in an environment consisting of a grid of streets (left-right) and avenues (up-down). Karel understands five basic instructions: move (Karel moves by one square in the direction he is facing), turnleft (Karel turns 90 ° left), putbeeper (Karel puts a beeper on the square he is standing at), pickbeeper (Karel lifts a beeper off the square he is standing at), and turnoff (Karel switches himself off, the program ends). Karel can also perform boolean queries about his immediate environment, asking whether there is a beeper where he is standing, whether there are barriers next to him, and about the direction he is facing. A programmer can create additional instructions by defining them in terms of the five basic instructions, and by using conditional control flow statements if and while
    0.00
    0 votes
    120
    Kids Programming Language

    Kids Programming Language

    Phrogram is a commercial programming language designed by its creators to be understandable and appealing to beginning and intermediate programmers of all ages. Its predecessor, Kids Programming Language (KPL) was first released in August 2005 and its distribution was discontinued in May 2008. Phrogram was first released in October 2006 as v2.0; its current version, v2.5, was released in September 2008. Phrogram comprises a programming language and integrated development environment, or IDE, bearing some similarities to Visual Basic. The language supports a number of scalar and complex data types, including structures, and provides limited support of objects (excluding inheritance and polymorphism). It features two "modes" - one for two-dimensional graphics and one for three-dimensional; these modes cannot be used at the same time. Phrogram targets the Microsoft .NET Framework and provides many runtime functions and methods for interacting with that platform. Because of this, Phrogram as of 2010 operates only on the Microsoft Windows series of operating systems that support the .NET Framework. A Phrogram program consists of a collection of nested code blocks. On the highest level
    0.00
    0 votes
    121

    Laning and Zierler system

    The Laning and Zierler system (sometimes called "George" by its users) was one of the first operating algebraic compilers, that is, a system capable of accepting mathematical formulae in algebraic notation and producing equivalent machine code. It was implemented in 1954 for the MIT WHIRLWIND by J. Halcombe Laning and Neal Zierler. It is preceded by the UNIVAC A-2, IBM Speedcoding and a number of systems that were proposed but never implemented. The literature sometimes refers to the Laning and Zierler system as a compiler. In the 1950s, however, compiler meant what we might today call a linking loader (see Linker and Loader) or an assembler. Laning and Zieler described their work as a "system of automatic coding" and the language is very similar to Tony Brooker's Manchester Autocodes, sitting somewhere between Mercury Autocode and Atlas Autocode in complexity. The remainder of this article will use the word system. The system accepted formulae in a more or less algebraic notation. It respected the standard rules for operator precedence, allowed nested parentheses, and used superscripts to indicate exponents. It was among the first programming systems to allow symbolic variable
    0.00
    0 votes
    122
    Lazarus

    Lazarus

    Lazarus is a free cross-platform IDE which provides a Delphi-like development experience for Pascal and Object Pascal developers. It is developed for, and supported by, the Free Pascal compiler. Since early 2008, Lazarus has been available for Microsoft Windows, several Linux distributions, FreeBSD, and Mac OS X. The earliest versions were created before that, and Lazarus is a front end for the much older Free Pascal. Lazarus uses Free Pascal as its back-end compiler. Therefore Lazarus can, theoretically, be used to develop applications for all platforms supported by Free Pascal. Similar to Free Pascal’s run-time library, Lazarus provides a cross-platform application framework called the Lazarus Component Library (LCL), which provides a single, unified interface for programmers, with different platform-specific implementations. Using LCL, one can create applications in a write once, compile anywhere manner, unless system-dependent features are used explicitly. As Free Pascal supports cross-compiling, Lazarus applications can be cross-compiled from Windows to Linux and FreeBSD, and vice versa. Compiling from Mac OS X to Windows, Linux and FreeBSD is possible. Cross-compiling to Mac
    0.00
    0 votes
    123

    Lexico

    • Language Paradigms: Object-oriented programming
    Lexico is a Spanish language object-oriented educational programming language based on the .NET Framework. Created to facilitate the programming education, specifically object-oriented programming techniques, Lexico has been shown to be successful in introducing Spanish-speaking students to the design of algorithms and data structures. Lexico was created by Pretends and other researchers, who verified that it does indeed help students learn faster and keeps them motivated. They hypothesize that this is because students can experiment with algorithm design from the start of their journey in the programming world. Being an educational language, Lexico's structure is simple: simplicity was chosen before performance. It's sufficiently simple to allow a person to learn the basic concepts of logic, algorithms, data structures. Object-oriented concepts have been simplified by the authors making students' introduction to OO paradigms easier. Lexico's blocks are delimited by { ... } like C#, but conditional execution is done with the keyword es? ([it] is [true]?) and iteration with the loop mientras (while). Lexico's two fundamental types are numbers and strings, but it also supports the
    0.00
    0 votes
    124
    Liberty BASIC

    Liberty BASIC

    • Language Paradigms: Procedural programming
    • Influenced: Beginners Programming Language
    • Influenced By: Smalltalk
    Liberty BASIC (LB) is a commercial computer programming language and integrated development environment (IDE). It has an interpreter developed in Smalltalk, which recognizes its own dialect of the BASIC programming language. It runs on 16- and 32-bit Windows and OS/2. Liberty BASIC was written by Carl Gundel and published in its first release by his company, Shoptalk Systems, in 1992. It has progressed steadily since then. The last published update to the software was in 2006. The current version is v4.04. Liberty BASIC has been used in examples of code for various guides and references about programming in Windows, including "Beginning Programming For Dummies", by Wallace Wang. Though Liberty BASIC has its share of limitations in its design for advanced programming, it makes a credible and very usable introductory integrated development environment, IDE, for moderate to advanced users of Windows and OS/2. DLLs are available with functions allowing users to overcome most of the limitations in Liberty BASIC. The OS/2 version is very old, but free. A new version that will run on Windows, Macintosh and Linux is in active development. The Liberty BASIC dialect, and IDE, have developed
    0.00
    0 votes
    125
    Logo

    Logo

    • Language Paradigms: Functional programming
    • Influenced: Smalltalk
    • Influenced By: Lisp
    Logo is a multi-paradigm computer programming language used in education. It is an adaptation and dialect of the Lisp language; some have called it Lisp without the parentheses. It was originally conceived and written as a functional programming language, and drove a mechanical turtle as an output device. It also has significant facilities for handling lists, files, I/O, and recursion. Today it is remembered mainly for its turtle graphics, though for tertiary level teaching it has been superseded by Scheme, and scripting languages. Logo was created in 1967 for educational use, more so for constructivist teaching, by Daniel G. Bobrow, Wally Feurzeig, Seymour Papert and Cynthia Solomon. The name is derived from the Greek logos meaning word, emphasising the contrast between itself and other existing programming languages that processed numbers. It can be used to teach most computer science concepts, as UC Berkeley lecturer Brian Harvey does in his Computer Science Logo Style trilogy. Logo was created in 1967 at Bolt, Beranek and Newman (BBN), a Cambridge, Massachusetts research firm, by Wally Feurzeig and Seymour Papert. Its intellectual roots are in artificial intelligence,
    0.00
    0 votes
    126

    LPC

    • Language Paradigms: Prototype-based programming
    • Influenced: Pike
    • Influenced By: C
    LPC (short for Lars Pensjö C) is an object-oriented programming language derived from C and developed originally by Lars Pensjö to facilitate MUD building on LPMuds. Though designed for game development, its flexibility has led to it being used for a variety of purposes, and to its evolution into the language Pike. LPC syntax places it in the family of C-like languages, with C and C++ its strongest influences. Almost everything in LPC is an object. However, LPC does not precisely use the concept of a class (MudOS has something called a class, but it is really a struct). Instead, LPC objects are blueprint objects and clones of blueprint objects, in a prototype-based programming model. One can treat a blueprint object much as a class in other object-oriented languages. Each object has variables (attributes) and functions (methods). The variables store the object's state; the functions are executable routines that can be called in the object. An object is uniquely defined by the name of the file in which it comes from, plus, if a clone, a numeric identifier. In a typical implementation, a clone of the file /lib/weapon.c which is the third clone created in the current run session will
    0.00
    0 votes
    127
    Lua

    Lua

    • Language Paradigms: Imperative programming
    • Influenced: Io
    • Influenced By: Scheme
    Lua ( /ˈluːə/ LOO-ə, from Portuguese: lua meaning "moon"; explicitly not "LUA") is a lightweight multi-paradigm programming language designed as a scripting language with "extensible semantics" as a primary goal. Lua is cross-platform since it is written in ISO C. Lua has a relatively simple C API compared to other scripting languages. Lua was created in 1993 by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, and Waldemar Celes, members of the Computer Graphics Technology Group (Tecgraf) at the Pontifical Catholic University of Rio de Janeiro, in Brazil. From 1977 until 1992, Brazil had a policy of strong trade barriers (called a market reserve) for computer hardware and software. In that atmosphere, Tecgraf's clients could not afford, either politically or financially, to buy customized software from abroad. Those reasons led Tecgraf to implement from scratch the basic tools it needed. Lua's historical "father and mother" were data-description/configuration languages SOL (Simple Object Language) and DEL (data-entry language). They had been independently developed at Tecgraf in 1992–1993 to add some flexibility into two different projects (both were interactive graphical
    0.00
    0 votes
    128

    Lush programming language

    Lush is an object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications. Lush is designed to be used in situations where one would want to combine the flexibility of a high-level, weakly-typed interpreted language, with the efficiency of a strongly-typed, natively-compiled language, and with the easy integration of code written in C, C++, or other languages. Lush is Free Software (under the GPL license) and runs on GNU/Linux, Solaris, Irix, and Windows under Cygwin. Lush can be used advantageously for projects where one would otherwise use a combination of an interpreted language like Matlab, Python, Perl, S+, or even (gasp!) BASIC, and a compiled language like C. Lush brings the best of both worlds by wrapping three languages into one: (1) a weakly-typed, garbage-collected, dynamically scoped, interpreted language with a simple Lisp-like syntax, (2) a strongly-typed, lexically-scoped compiled language that uses the same Lisp-like syntax, and (3) the C language, which can be freely mixed with Lush code within a single program, even within a single function. Lush is designed to be very simple
    0.00
    0 votes
    129

    Maclisp

    • Influenced: Common Lisp
    MACLISP (or Maclisp) is a dialect of the Lisp programming language. It originated at MIT's Project MAC (from which it derived its prefix) in the late 1960s and was based on Lisp 1.5. Richard Greenblatt was the main developer of the original codebase for the PDP-6; Jonl White was responsible for its later maintenance and development. The name 'Maclisp' started being used in the early 1970s to distinguish it from other forks of PDP-6 Lisp, notably BBN Lisp. Maclisp ran on DEC PDP-6/10 computers, initially only on ITS, but later under all the other PDP-10 operating systems. Its original implementation was in PDP-10 assembly language. It was later implemented on Multics using PL/I. Maclisp developed considerably in its lifetime, adding major features along the way which in other language systems would typically correspond to major release numbers. Maclisp was used to implement the Macsyma symbolic algebra program; Macsyma's development also drove a number of features in Maclisp. The SHRDLU blocks-world program was written in Maclisp, and so the language was in widespread use in the artificial intelligence research community through the early 1980s. It was also used to implement other
    0.00
    0 votes
    130
    MAD programming language

    MAD programming language

    • Language Paradigms: Imperative programming
    • Influenced By: ALGOL 58
    MAD (Michigan Algorithm Decoder) is a programming language and compiler for the IBM 704 and later the IBM 709, IBM 7090, IBM 7040, UNIVAC 1107, UNIVAC 1108, Philco 210-211, and eventually the IBM S/370 mainframe computers. Developed in 1959 at the University of Michigan by Bernard Galler, Bruce Arden and Robert M. Graham, MAD is a variant of the International Algebraic Language (IAL). It was widely used to teach programming at colleges and universities during the 1960s and played a minor role in the development of CTSS, Multics, and the Michigan Terminal System computer operating systems. The archives at the Bentley Historical Library of the University of Michigan contain reference materials on the development of MAD and MAD/I, including three linear feet of printouts with hand-written notations and original printed manuals. There are three MAD compilers: MAD is a variant of the International Algebraic Language (IAL). IAL is the original name for what eventually became ALGOL 58. While MAD was motivated by ALGOL 58, it does not resemble ALGOL 58 in any significant way. Programs written in MAD included MAIL, RUNOFF, one of the first text processing systems, and several other
    0.00
    0 votes
    131

    Magik programming language

    Magik is an object-oriented programming language that supports multiple inheritance, polymorphism and is dynamically typed. It is provided by GE Energy as part of its Smallworld technology platform and was designed from the outset to implement complex applications for enterprise utilities such as power distribution and telecommunications. Magik (Inspirational Magik) was originally introduced in 1990 and has been improved and updated over the years. Its current version is 4.0 or Magik SF (Small Footprint). Magik itself shares some similarities with Smalltalk in terms of its language features and its architecture: the Magik language is compiled into byte codes interpreted by the Magik virtual machine. The Magik virtual machine is available on several platforms including Microsoft Windows, various flavours of Unix and Linux. Magik is console based and code can be modified on the fly even when an application is running. The console can also be used to execute Magik code and to see the results. Compiled code is stored in a single file called an image file. Each image file holds the compiled byte-codes and the state of the session (for example variable values) when the image was last
    0.00
    0 votes
    132

    Mary programming language

    • Language Paradigms: Imperative programming
    • Influenced By: ALGOL 68
    Mary was a programming language designed and implemented by RUNIT at Trondheim, Norway in the 1970s. It borrowed many features from ALGOL 68 but was designed for machine-oriented programming. An unusual feature of its syntax was that expressions were constructed using the conventional infix operators, but all of them had the same precedence and evaluation went from left to right unless there were brackets. Assignment had the destination on the right and assignment was considered just another operator. Similar to C, several language features appear to have existed to allow programmers to produce reasonably well optimised code, despite a quite primitive code generator in the compiler. These included operators similar to the += et alter in C and explicit register declarations for variables. Notable features: A book describing Mary was printed in 1974 (Fourth and last edition in 1979): Mary Textbook by Reidar Conradi & Per Holager. Compilers were made for Kongsberg Våpenfabrikk's SM-4 and Norsk Data Nord-10/ND-100 mini-computers. The original Mary compiler was written in NU ALGOL, ran on the Univac-1100 series and was used to bootstrap a native compiler for ND-100/SINTRAN-III. RUNIT
    0.00
    0 votes
    133
    MATLAB

    MATLAB

    • Language Paradigms: Imperative programming
    MATLAB (matrix laboratory) is a numerical computing environment and fourth-generation programming language. Developed by MathWorks, MATLAB allows matrix manipulations, plotting of functions and data, implementation of algorithms, creation of user interfaces, and interfacing with programs written in other languages, including C, C++, Java, and Fortran. Although MATLAB is intended primarily for numerical computing, an optional toolbox uses the MuPAD symbolic engine, allowing access to symbolic computing capabilities. An additional package, Simulink, adds graphical multi-domain simulation and Model-Based Design for dynamic and embedded systems. In 2004, MATLAB had around one million users across industry and academia. MATLAB users come from various backgrounds of engineering, science, and economics. MATLAB is widely used in academic and research institutions as well as industrial enterprises. Cleve Moler, the chairman of the computer-science department at the University of New Mexico, started developing MATLAB in the late 1970s. He designed it to give his students access to LINPACK and EISPACK without them having to learn Fortran. It soon spread to other universities and found a
    0.00
    0 votes
    134

    Mesa

    • Language Paradigms: Modular Programming
    • Influenced: Modula-2
    • Influenced By: ALGOL
    Mesa was an innovative programming language developed in the late 1970s at the Xerox Palo Alto Research Center in Palo Alto, California, United States. The language was named after the mesas of the American Southwest, referring to its design intent to be a "high-level" programming language. Mesa is an ALGOL-like language with strong support for modular programming. Every library module has at least two source files: a definitions file specifying the library's interface plus one or more program files specifying the implementation of the procedures in the interface. To use a library, a program or higher-level library must "import" the definitions. The Mesa compiler type-checks all uses of imported entities; this combination of separate compilation with type-checking was unusual at the time. Mesa introduced several other innovations in language design and implementation, notably in the handling of software exceptions, thread synchronization, incremental compilation, and more. Mesa was developed on the Xerox Alto, one of the first personal computers with a graphical user interface, however most of the Alto's system software was written in BCPL. Mesa was the system programming language
    0.00
    0 votes
    135
    METAFONT

    METAFONT

    • Influenced: MetaPost
    Metafont is a description language used to define vector fonts. It is also the name of the interpreter that executes Metafont code, generating the bitmap fonts that can be embedded into e.g. PostScript. Metafont was devised by Donald Knuth as counterpart to his TeX typesetting system. One of the characteristics of Metafont is that all of the shapes of the glyphs are defined with geometrical equations. In particular, one can define a given point to be the intersection of a line segment and a Bézier cubic. Unlike more common outline font formats (such as TrueType or PostScript Type 1), a Metafont font is primarily made up of strokes with finite-width "pens", along with filled regions. Thus, rather than describing the outline of the glyph directly, a Metafont file describes the pen paths. Some simpler Metafont fonts, such as the calligraphic mathematics fonts in the Computer Modern family, use a single pen stroke with a relatively large pen to define each visual "stroke" of the glyphs. More complex fonts such as the Roman text fonts in the Computer Modern family use a small pen to trace around the outline of the visual "strokes", which are then filled; the result is much like an
    0.00
    0 votes
    136
    MetaPost

    MetaPost

    • Language Paradigms: Imperative programming
    • Influenced: Asymptote
    • Influenced By: METAFONT
    MetaPost refers to both a programming language and the interpreter of the MetaPost programming language. Both are derived from Donald Knuth's Metafont language and interpreter. MetaPost excels at producing diagrams in the PostScript programming language from a geometric/algebraic description. The language shares Metafont's elegant declarative syntax for manipulating lines, curves, points and geometric transformations. However, Many of the limitations of MetaPost derive from features of Metafont. For instance, numbers have a low-precision fixed-point representation, sufficient for representing the coordinates of points in a glyph, but this can be restrictive when working with figures in a larger coordinate space. Moreover, MetaPost does not support all features of PostScript. Most notably, paths can have only one segment (so that regions are simply connected), and regions can be filled only with uniform colours. PostScript level 1 supports tiled patterns and PostScript 3 supports Gouraud shading. To this end, the Asymptote graphics language has been developed to address these shortcomings. MetaPost is distributed with many current distributions of the TeX and Metafont framework. In
    0.00
    0 votes
    137
    MIDletPascal

    MIDletPascal

    MIDletPascal is an Pascal compiler and IDE specifically designed to create software for mobiles. It generates Java bytecode that runs on any Java ME device. In September 2009, Niksa Orlic, who wrote MIDlet pascal, transmitted the source code to the Russian Boolean.name development community for feature development. MIDlet Pascal is now open-source, and hosted at SourceForge. In June 2010 MIDletPascal 3.0 Final released. Because it runs on mobiles that don't have a console, the hello world of MIDletPascal is quite different from a normal Pascal hello world. Current versions of certain anti-virus (Norton, McAfee, ...) see any class file generated by MidletPascal as being a virus, "Trojan. Redbrowser.A", and automatically quarantine the suspected file. This may be a false positive, because the RedBrowser trojan was written using the MidletPascal tool (see Notes from McAfee). It seems antiviruses look for some specific class into the jar package. Using an obfuscator as JShrink the midlet won't match with the AV dictionary. This problem has been fixed in MIDletPascal 3.0 BETA.
    0.00
    0 votes
    138

    MIMIC

    This article is about the programming language. For the vaccine development tool, see MIMIC (Immunology). MIMIC, known in capitalized form only, is a former simulation computer language developed 1964 by H. E. Petersen, F. J. Sansom and L. M. Warshawsky of Systems Engineering Group within the Air Force Materiel Command at the Wright-Patterson AFB in Dayton, Ohio, USA. It is an expression-oriented continuous block simulation language, but capable of incorporating blocks of FORTRAN-like algebra. MIMIC is a further development from MIDAS (Modified Integration Digital Analog Simulator), which represented analog computer design. Written completely in FORTRAN but one routine in COMPASS, and ran on Control Data supercomputers, MIMIC is capable of solving much larger simulation models. With MIMIC, ordinary differential equations describing mathematical models in several scientific disciplines as in engineering, physics, chemistry, biology, economics and as well as in social sciences can easily be solved by numerical integration and the results of the analysis are listed or drawn in diagrams. It also enables the analysis of nonlinear dynamic conditions. The MIMIC software package, written
    0.00
    0 votes
    139
    MiniD

    MiniD

    • Language Paradigms: Multi-paradigm programming language
    • Influenced By: Lua
    The MiniD programming language is a small, lightweight, extension language in the vein of Lua or Squirrel, but designed to be used mainly with the D programming language. It supports both object-oriented and imperative programming paradigms, as well as some simple functional aspects. Distributed under the licence of zlib/libpng, MiniD is free software. MiniD began in June 2006 as an idea for a statically-typed language, much like a stripped-down version of the D programming language. This is the reason for the name "MiniD". After work began on the compiler, the creator, Jarrett Billingsley, realized just how large a project this language was becoming, and decided to recast the language into something simpler to implement. The result was a Lua-like language with a C-style syntax. Over the next several months, MiniD acquired features from various languages, such as Squirrel-like classes, a D-like module system, and Lua-like collaborative multithreading. On August 1, 2007, after more than thirteen months of planning and programming, version 1.0 of the reference implementation was released. The version 1.0 language specification is frozen. As of June 15, 2009, version 2 of MiniD has
    0.00
    0 votes
    140

    Miranda

    • Language Paradigms: Functional programming
    • Influenced: Haskell
    • Influenced By: Kent Recursive Calculator
    Miranda is a non-strict purely functional programming language designed by David Turner as a successor to his earlier programming languages SASL and KRC, using some concepts from ML and Hope. It was produced by Research Software Ltd. of England (which holds a trademark on the name Miranda) and was the first purely functional language to be commercially supported. Miranda was first released in 1985, as a fast interpreter in C for Unix-flavour operating systems, with subsequent releases in 1987 and 1989. The later Haskell programming language is similar in many ways to Miranda. Miranda is a lazy, purely functional programming language. That is, it lacks side effects and imperative programming features. A Miranda program (called a script) is a set of equations that define various mathematical functions and algebraic data types. The word set is important here: the order of the equations is, in general, irrelevant, and there is no need to define an entity prior to its use. Since the parsing algorithm makes intelligent use of layout (indentation), there is rarely a need for bracketing statements and no statement terminators are required. This feature, inspired by ISWIM is also used in
    0.00
    0 votes
    141

    ML

    • Language Paradigms: Functional programming
    • Influenced: Caml
    • Influenced By: ISWIM
    ML is a general-purpose functional programming language developed by Robin Milner and others in the early 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 encapsulates 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
    0.00
    0 votes
    142

    Modula-2

    • Language Paradigms: Modular Programming
    • Influenced: Zonnon
    • Influenced By: Pascal
    Modula-2 is a computer programming language designed and developed between 1977 and 1980 by Niklaus Wirth at ETH Zurich as a revision of Pascal to serve as the sole programming language for the operating system and application software for the personal workstation Lilith. The principal concepts were: Modula-2 was understood by Niklaus Wirth as a successor to his earlier programming language Pascal. The language design was also influenced by the Mesa programming language and the new programming possibilities of the early personal computer Xerox Alto, both from Xerox, that Wirth saw during his 1976 sabbatical year at Xerox PARC. Modula-2 is a general purpose procedural language, sufficiently flexible to do systems programming, but with much broader application. In particular, it was designed to support separate compilation and data abstraction in a straightforward way. Much of the syntax is based on Wirth's earlier and better-known language, Pascal. Modula-2 was designed to be broadly similar to Pascal, with some elements and syntactic ambiguities removed and the important addition of the module concept, and direct language support for multiprogramming. Here is an example of the
    0.00
    0 votes
    143

    Modula-3

    • Language Paradigms: Object-oriented programming
    • Influenced: Python
    • Influenced By: Modula-2
    In computer science, Modula-3 is a programming language conceived as a successor to an upgraded version of Modula-2 known as Modula-2+. While it has been influential in research circles (influencing the designs of languages such as Java, C#, and Python) it has not been adopted widely in industry. It was designed by Luca Cardelli, James Donahue, Lucille Glassman, Mick Jordan (before at the Olivetti Software Technology Laboratory), Bill Kalsow and Greg Nelson at the Digital Equipment Corporation (DEC) Systems Research Center (SRC) and the Olivetti Research Center (ORC) in the late 1980s. Modula-3's main features are simplicity and safety while preserving the power of a systems-programming language. Modula-3 aimed to continue the Pascal tradition of type safety, while introducing new constructs for practical real-world programming. In particular Modula-3 added support for generic programming (similar to templates), multithreading, exception handling, garbage collection, object-oriented programming, partial revelation and explicit mark of unsafe code. The design goal of Modula-3 was a language that implements the most important features of modern imperative languages in quite basic
    0.00
    0 votes
    144

    MySQL

    MySQL ( /maɪ ˌɛskjuːˈɛl/ "My S-Q-L", officially, but also called /maɪ ˈsiːkwəl/ "My Sequel") is the world's most used open source relational database management system (RDBMS) as of 2008 that runs as a server providing multi-user access to a number of databases. It is named after co-founder Michael Widenius' daughter, My. The SQL phrase stands for Structured Query Language. The MySQL development project has made its source code available under the terms of the GNU General Public License, as well as under a variety of proprietary agreements. MySQL was owned and sponsored by a single for-profit firm, the Swedish company MySQL AB, now owned by Oracle Corporation. MySQL is a popular choice of database for use in web applications, and is a central component of the widely used LAMP open source web application software stack (and other 'AMP' stacks) . LAMP is an acronym for "Linux, Apache, MySQL, Perl/PHP/Python." Free-software-open source projects that require a full-featured database management system often use MySQL. For commercial use, several paid editions are available, and offer additional functionality. Applications which use MySQL databases include: TYPO3, Joomla, WordPress,
    0.00
    0 votes
    145
    Neko

    Neko

    • Language Paradigms: Object-oriented programming
    Neko is a high-level dynamically typed programming language developed by Nicolas Cannasse as part of R&D efforts at Motion-Twin. Neko has a compiler and a virtual machine with garbage collection. The compiler converts a source .neko file into a bytecode .n file that can be executed with the virtual machine. Since Neko is dynamically typed with no fixed classes, a developer only has to find the proper runtime mapping (as opposed to type mapping) so that code executes correctly. As the Neko FAQ puts it: "...it is easier to write a new or existing language on the NekoVM than it is for the CLR / JVM, since you don’t have to deal with a highlevel type system. Also, this means that languages can interoperate more easily since they only need to share the same data structures and not always the same types." Neko requires compilation before execution, like other scripting languages such as Groovy. Since Neko doesn't need to be interpreted at runtime, it executes faster. The haXe programming language compiles to Neko code, among other targets. Neko includes a mod_neko module for the Apache server. As such, it can process user input using GET and POST requests:
    0.00
    0 votes
    146

    NELIAC

    The Navy Electronics Laboratory International ALGOL Compiler or NELIAC is a dialect and compiler implementation of the ALGOL 58 programming language developed by the Naval Electronics Laboratory in 1958. It was designed for numeric and logical computations and was the first language to provide a bootstrap implementation. NELIAC was the brainchild of Harry Huskey — then Chairman of the ACM and a well known computer scientist, and supported by Maury Halstead, the head of the computational center at NEL. The earliest version was implemented on the prototype USQ-17 computer (called "the Countess") at the laboratory. It was the world's first self-compiling compiler. This means that the compiler was first coded in simplified form in assembly language "the bootstrap", and then re-written in its own language, compiled by this "bootstrap" compiler, and re-compiled by itself, making the "bootstrap" obsolete. It is called a variant of ALGOL 58 because of similarities to that language, but, shortly after the ALGOL committee produced other versions of ALGOL, and NELIAC and ALGOL parted ways. The compiler was used on the Countess to produce a version for the CDC 1604, and later self-compiled on
    0.00
    0 votes
    147

    NetRexx

    • Language Paradigms: Object-oriented programming
    • Influenced By: PL/I
    NetRexx is an open source, originally IBM's, variant of the REXX programming language to run on the Java virtual machine. It supports a classic REXX syntax, with no reserved keywords, along with considerable additions to support object-oriented programming in a manner compatible with Java's object model, yet can be used as both a compiled and an interpreted language, with an option of using only data types native to the JVM or the NetRexx runtime package. The latter offers the standard Rexx data type that combines string processing with unlimited precision decimal arithmetic. Integration with the JVM platform is tight, and all existing Java class libraries can be used unchanged and without special setup; at the same time, a Java programmer can opt to just use the Rexx class from the runtime package for improved string handling in Java syntax source programs. The syntax and object model of NetRexx differ from Object REXX, another IBM object-oriented variant of REXX which has been released as open source software. NetRexx is free to download from the Rexx Language Association. IBM announced the transfer of NetRexx 3.00 source code to the Rexx Language Association (RexxLA) on June 8,
    0.00
    0 votes
    148

    NEWP

    NEWP (or the New Executive Programming Language) is a high-level programming language used on the Unisys MCP systems. The language is used to write the operating system and other system utilities, although it can also be used to write user software as well. Several constructs separate it from extended ALGOL on which it is based. Language operators such as MEMORY which allows direct memory access are strictly used by programs running as the MCP. NEWP is a block-structured language very similar to Extended ALGOL. It includes several features borrowed from other programming languages which help in proper software engineering. These include modules (and later, super-modules) which group together functions and their data, with defined import and export interfaces. This allows for data encapsulation and module integrity. Since NEWP is designed for use as an operating system language, it permits the use of several unsafe constructs. Each block of code can have specific unsafe elements permitted. Unsafe elements are those only permitted within the operating system. These include access to the tag of each word, access to arbitrary memory elements, low-level machine interfaces, etc. If a
    0.00
    0 votes
    149

    NewtonScript

    • Language Paradigms: Prototype-based programming
    • Influenced: Io
    • Influenced By: Self
    NewtonScript is a prototype-based programming language created to write programs for the Newton platform. It is heavily influenced by the Self programming language, but modified to be more suited to needs of mobile and embedded devices. Traditional computers, at least in the desktop role, have two modes; "on" and "off". When moving from one mode to the other the state of the machine is lost from memory, and requires a sometimes lengthy "boot" process to return the machine to the "on" state. This does not suffice for a PDA type device where the user expects the machine to be available almost instantly for taking down quick notes. Yet a machine cannot be left "on" for any length of time either, as this would drain the battery too much to make it useful for carrying around. In the Newton platform, the system had two states that were more like "on" and "sleeping". When moving to the sleeping state the memory was not lost and instead the system simply stopped working on the contents of memory, which allowed for many of the chips inside to be turned off. This greatly extended battery life, yet still allowed the machine to turn back on almost instantly. With the main memory always being
    0.00
    0 votes
    150

    Oberon

    • Language Paradigms: Reflective programming
    • Influenced: Oberon-2
    • Influenced By: Modula-2
    Oberon is a programming language created in 1986 by Professor Niklaus Wirth (creator of the Pascal, Modula, and Modula-2 programming languages) and his associates at ETH Zurich in Switzerland. It was developed as part of the implementation of the Oberon operating system. The original intention was to use Modula-2 as the implementation language but it lacked the required safe type-extension facilities. Also, it was planned to eventually publish the full details of the operating system and compiler so that they could be studied and understood. These factors led to the decision to design a new language which concentrated on just the essential features necessary for the task in hand. The name is from the moon of Uranus, Oberon. Oberon is very much like Modula-2 in its syntax, but is considerably smaller. Oberon's feature simplicity leads to considerable space and coding efficiency for its compilers. The full language can be specified in a page of EBNF. The Oberon report is, at 16 pages, about a third of the size of the Modula-2 report, and one of the early full compilers was only about 4000 lines long. Unlike Modula-2, it has garbage collection. Oberon was designed for Oberon operating
    0.00
    0 votes
    151
    Object Pascal

    Object Pascal

    • Language Paradigms: Object-oriented programming
    • Influenced: C#
    • Influenced By: Pascal
    Object Pascal refers to a branch of object-oriented derivatives of Pascal, mostly known as the primary programming language of Embarcadero Delphi. Object Pascal is an extension of the Pascal language that was developed at Apple Computer by a team led by Larry Tesler in consultation with Niklaus Wirth, the inventor of Pascal. It is descended from an earlier object-oriented version of Pascal called Clascal, which was available on the Lisa computer. Object Pascal was needed in order to support MacApp, an expandable Macintosh application framework that would now be called a class library. Object Pascal extensions and MacApp itself were developed by Barry Haynes, Ken Doyle, and Larry Rosenstein, and were tested by Dan Allen. Larry Tesler oversaw the project, which began very early in 1985 and became a product in 1986. An Object Pascal extension was also implemented in the Think Pascal IDE. The IDE includes the compiler and an editor with Syntax highlighting and checking, a powerful debugger and a class library. Many developers preferred Think Pascal over Apple's implementation of Object Pascal because Think Pascal offered a tight integration of its tools. The development stopped after
    0.00
    0 votes
    152

    Objective Modula-2

    • Influenced By: Modula-2
    Objective Modula-2 (or ObjM2) is an extension to Modula-2 which follows the Objective-C object model and retains the bracketed Smalltalk message passing syntax introduced in Objective-C. Like Objective-C, Objective Modula-2 is a reflective, object oriented programming language with both static and dynamic typing. It is intended as a safer alternative to Objective-C for Cocoa and GNUstep software development. It retains most of Modula-2's features, most importantly data encapsulation with nested modules, explicit import and export lists and strict type checking. Objective Modula-2 can therefore be considered a much safer programming language than is Objective-C, yet it has all the capabilities of Objective-C. Classes written in Objective Modula-2 can be used within Objective-C and vice versa. Objective Modula-2 is a "thin" layer on top of Modula-2. It is a superset of the Modula-2 base language. Objective Modula-2 borrows its syntax from both Modula-2 and Objective-C. Most of the syntax, including conventional function calls, is inherited from Modula-2, while the syntax for object-oriented features, including message-passing, is borrowed from Objective-C, which itself derived
    0.00
    0 votes
    153

    Occam

    • Language Paradigms: Parallel computing
    • Influenced: Ease programming language
    • Influenced By: Communicating sequential processes
    occam is a concurrent programming language that builds on the Communicating Sequential Processes (CSP) process algebra, and shares many of its features. It is named after William of Ockham of Occam's Razor fame. occam is an imperative procedural language (such as Pascal). It was developed by David May and others at INMOS, advised by Tony Hoare, as the native programming language for their transputer microprocessors, but implementations for other platforms are available. The most widely known version is occam 2; its programming manual was written by Steven Ericsson-Zenith and others at INMOS. In the following examples indentation and formatting are critical for parsing the code: expressions are terminated by the end of the line, lists of expressions need to be on the same level of indentation. This feature, named the off-side rule, is also found in other languages such as Haskell and Python. Communication between processes work through named channels. One process outputs data to a channel via "!" while another one inputs data with "?". Input and output will block until the other end is ready to accept or offer data. Examples (c is a variable): SEQ introduces a list of expressions
    0.00
    0 votes
    154

    Open programming language

    • Language Paradigms: Structured programming
    The Open Programming Language (OPL) is an embedded programming language for portable devices that run the Symbian Operating System, which can be found on e.g. the Nokia 9200, 9300 and 9500 Communicator series mobile telephone/personal digital assistant (PDA) and the Sony Ericsson P800, P900, P910 series. On classic Psion PDAs such as the Series 3, 5/5mx, Series 7, and netBook/netPad, as well as the MC218, OPL is part of the standard application suite. OPL is also included in Psion Teklogix industrial handhelds such as the Workabout mx. OPL is an interpreted language similar to BASIC. A fully Visual Basic-compatible language OVAL has been also developed. The language was originally called Organiser Programming Language developed by Psion Ltd for the Psion Organiser. The first implementation (without graphics) was for the original Psion Organiser (now referred to as the Psion Organiser I, 1984) and came bundled with the Science, Finance and Math datapaks. It became truly accessible as built in software in the Psion Organiser II (1986) and the language went on to be used in the Psion Series 3 and later. After Psion retired from the PDA market, the project was parked until 2003 when
    0.00
    0 votes
    155
    OpenMusic

    OpenMusic

    OpenMusic (OM) is an object-oriented visual programming environment for musical composition based on Common Lisp. It may also be used as an all-purpose visual interface to Lisp programming. OpenMusic is a descendant of PatchWork, a computer-assisted composition environment for the Macintosh first developed at IRCAM in the early 1990s. PatchWork was developed primarily by Mikael Laurson, and OpenMusic owes much of its design indirectly to him. Versions of OpenMusic are currently available for Mac OS X (PowerPC and Intel), Windows. The source code has been released under the GNU Lesser General Public License (LGPL). Programs in OpenMusic are created by connecting together (a process known as 'patching') either pre-defined or user-defined modules, in a similar manner to graphical signal-processing environments such as Max/MSP or Pd. Unlike such environments, however, the result of an OpenMusic computation will typically be displayed in conventional music notation, which can then be directly manipulated, if so required, via an editor. A substantial body of specialized libraries has been contributed by users, which extends OpenMusic's functionality into such areas as constraint
    0.00
    0 votes
    156
    Oxygene

    Oxygene

    • Language Paradigms: Object-oriented programming
    • Influenced By: Pascal
    Oxygene (formerly known as Chrome) is a programming language developed by RemObjects Software for Microsoft's Common Language Infrastructure and the Java Platform. Oxygene is Object Pascal-based, but also has influences from C#, Eiffel, Java, F# and other languages. Compared to the now deprecated Delphi.NET, Oxygene does not emphasize total backward compatibility, but is designed to be a "reinvention" of the language, be a good citizen on the managed development platforms, and leverage all the features and technologies provided by the .NET and Java runtimes. Oxygene offers full integration into Visual Studio 2010 and 2012 as a commercial product, and a freely available command line compiler. Starting 2008, RemObjects Software has licensed its compiler and IDE technology to Embarcadero to be used in their Embarcadero Prism product.. Starting in the Fall of 2011, Oxygene is available in two separate editions, with the second edition adding support for the Java and Android runtimes. The Oxygene language has its origins in Object Pascal in general and Delphi in particular, but was designed to reflect the guidelines of .NET programming and to create fully CLR-compliant assemblies.
    0.00
    0 votes
    157

    Oz

    • Language Paradigms: Multi-paradigm programming language
    • Influenced: Alice ML
    • Influenced By: Prolog
    Oz is a multiparadigm programming language, developed in the Programming Systems Lab at Université catholique de Louvain, for programming language education. It has a canonical textbook: Concepts, Techniques, and Models of Computer Programming. Oz was first designed by Gert Smolka and his students in 1991. In 1996 the development of Oz continued in cooperation with the research group of Seif Haridi and Peter Van Roy at the Swedish Institute of Computer Science. Since 1999, Oz has been continually developed by an international group, the Mozart Consortium, which originally consisted of Saarland University, the Swedish Institute of Computer Science, and the Université catholique de Louvain. In 2005, the responsibility for managing Mozart development was transferred to a core group, the Mozart Board, with the express purpose of opening Mozart development to a larger community. The Mozart Programming System is the primary implementation of Oz. It is released with an open source license by the Mozart Consortium. Mozart has been ported to different flavors of Unix, FreeBSD, Linux, Microsoft Windows, and Mac OS X. Oz contains most of the concepts of the major programming paradigms,
    0.00
    0 votes
    158
    Parsing

    Parsing

    In computer science and linguistics, parsing, or, more formally, syntactic analysis, is the process of analyzing a text, made of a sequence of tokens (for example, words), to determine its grammatical structure with respect to a given (more or less) formal grammar. Parsing can also be used as a linguistic term, for instance when discussing how phrases are divided up in garden path sentences. Parsing is also an earlier term for the diagramming of sentences of natural languages, and is still used for the diagramming of inflected languages, such as the Romance languages or Latin. The term parsing comes from Latin pars (ōrātiōnis), meaning part (of speech). Parsing is a common term used in psycholinguistics when describing language comprehension. In this context, parsing refers to the way that human beings, rather than computers, analyze a sentence or phrase (in spoken language or text) "in terms of grammatical constituents, identifying the parts of speech, syntactic relations, etc." This term is especially common when discussing what linguistic cues help speakers to parse garden-path sentences. In computing, a parser is one of the components in an interpreter or compiler that checks
    0.00
    0 votes
    159
    Pascal

    Pascal

    • Language Paradigms: Structured programming
    • Influenced: Modula
    • Influenced By: ALGOL
    Pascal is an influential imperative and procedural programming language, designed in 1968–1969 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. A derivative known as Object Pascal designed for object-oriented programming was developed in 1985. Pascal, named in honor of the French mathematician and philosopher Blaise Pascal, was developed by Niklaus Wirth. Before his work on Pascal, Wirth had developed Euler and ALGOL W and later went on to develop the Pascal-like languages Modula-2 and Oberon. Initially, Pascal was largely, but not exclusively, intended to teach students structured programming. A generation of students used Pascal as an introductory language in undergraduate courses. Variants of Pascal have also frequently been used for everything from research projects to PC games and embedded systems. Newer Pascal compilers exist which are widely used. Pascal was the primary high-level language used for development in the Apple Lisa, and in the early years of the Macintosh. Parts of the original Macintosh operating system were hand-translated into Motorola
    0.00
    0 votes
    160
    Pascal/mt

    Pascal/mt

    Pascal/MT+ was an ISO 7185 compatible Pascal compiler written in 1980 by Michael Lehman, founder of MT MicroSYSTEMS of Solana Beach, California. The company was acquired by Digital Research in 1981 which subsequently distributed versions that ran on the 8080/Z80 processor under the CP/M operating system. Later versions ran on the 68000 CPU under CP/M-68k, and the 8086 CPU under CP/M-86 and MS-DOS. Pascal/MT+, for the 8086, was available for CP/M-86, PC/MS-DOS as well as RMX-86 (a proprietary OS from Intel). Pascal/MT+86 still runs today on even the latest version of Microsoft Windows and DR DOS.
    0.00
    0 votes
    161
    Petriscript

    Petriscript

    PetriScript is a modelling language for Petri nets, designed by Alexandre Hamez and Xavier Renault. The CPN-AMI platform provides many tools to work on Petri nets, such as verifying or model-checking tools. It was easily possible to graphically design simple Petri nets with Macao, but various works made internally at LIP6 reveal that it was needed to automate such task. Therefore PetriScript has been designed to provide some facilities in modelling places-transition and coloured Petri nets within the CPN-AMI platform. Its main purpose is to automate modelling operations on Petri nets such as merging, creating, and connecting nodes. Thus, it supports almost everything needed like macros, loops control, lists, string and arithmetic expressions, and avoids to the maximum the intervention of the user. Its syntax is more or less Ada-like. For example, the following script produces a FIFO with three sections: Which produces the following graph: Here is another example that shows the power of PetriScript: Which produces the following graph: A full documentation is available here
    0.00
    0 votes
    162
    PGF/TikZ

    PGF/TikZ

    PGF/TikZ is a tandem of languages for producing vector graphics from a geometric/algebraic description. PGF is a lower-level language, while TikZ is a set of higher-level macros that use PGF. The top-level PGF and TikZ commands are invoked as TeX macros, but in contrast with PSTricks, the PGF/TikZ graphics themselves are described in a language that resembles MetaPost. Till Tantau is the designer of these languages, and he is also the main developer of the only known interpreter for PGF and TikZ, which is written in TeX. PGF is an acronym for Portable Graphics Format. TikZ was introduced in version 1.10 of PGF, and it is a recursive acronym for "TikZ ist kein Zeichenprogramm" ("TikZ is not a drawing program"). The PGF/TikZ interpreter can be used from the popular LaTeX and ConTeXt macro packages, but also directly from the original TeX. Since TeX itself is not concerned with graphics, the interpreter supports multiple TeX output backends: dvips, dvipdfm/dvipdfmx/xdvipdfmx, TeX4ht, and pdftex's internal PDF output driver. Unlike PStricks, PGF can thus directly produce either PostScript or PDF output, but it cannot use some of the more advanced PostScript programming features that
    0.00
    0 votes
    163

    Pico programming language

    • Language Paradigms: Procedural programming
    Pico is a programming language developed at the Software Languages Lab at Vrije Universiteit Brussel. The language was created to introduce the essentials of programming to non-computer science students. Pico can be seen as an effort to generate a palatable and enjoyable language for people who do not want to study hard for the elegance and power of a language. They have done it by adapting Scheme's semantics. While designing Pico, the Software Languages Lab was inspired by the Abelson and Sussman's book "Structure and Interpretation of Computer Programs". Furthermore, they were influenced by the teaching of programming at high school or academic level. Pico should be interpreted as 'small', the idea was to create a small language for educational purposes. Comments are surrounded by backquotes ("`"). Variables are dynamically typed; Pico uses static scope. Functions are first-class objects in Pico. They can be assigned to variables. For example a function with two parameters param1 and param2 can be defined as: Functions can be called with the following syntax: Operators can be used as prefix or infix in Pico: Pico has the following types: string, integer, real and tables. It does
    0.00
    0 votes
    164
    Piet

    Piet

    Piet is an esoteric programming language designed by David Morgan-Mar, whose programs are bitmaps that look like abstract art. The compilation is guided by a "pointer" that moves around the image, from one continuous coloured region to the next. Procedures are carried through when the pointer exits a region. There are 20 colours for which behaviour is specified: 18 "colourful" colours, which are ordered by a 6-step hue cycle and a 3-step brightness cycle; and black and white which are not ordered. When exiting a "colourful" colour and entering another one, the performed procedure is determined by the number of steps of change in hue and brightness. Black cannot be entered; when the pointer tries to enter a black region, the rules of choosing the next block are changed instead. If all possible rules are tried, the program terminates. Regions outside the borders of the image are also treated as black. White does not perform operations, but allows the pointer to "pass through". The behaviour of colours other than the 20 specified is left to the compiler. Variables are stored in memory as signed integers in a single stack. Most specified procedures deal with operations on that stack,
    0.00
    0 votes
    165
    Pike

    Pike

    • Language Paradigms: Interpreted language
    • Influenced By: Lisp
    Pike is an interpreted, object-oriented, dynamic programming language with a syntax similar to C. It includes a powerful modules system that, for instance, has image manipulation, database connectivity and advanced cryptography. It is simple to learn, does not require long compilation passes and has powerful built-in data types allowing simple and fast data manipulation.
    0.00
    0 votes
    166

    Pike programming language

    • Language Paradigms: Functional programming
    • Influenced By: C
    Pike is an interpreted, general-purpose, high-level, cross-platform, dynamic programming language, with a syntax similar to that of C. Unlike many other dynamic languages, Pike is both statically and dynamically typed, and requires explicit type definitions. It features a flexible type system that allows the rapid development and flexible code of dynamically typed languages, while still providing some of the benefits of a statically typed language. Pike features garbage collection, advanced data types, and first-class anonymous functions, with support for many programming paradigms, including object-oriented, functional and imperative programming. Pike is free software, released under the GPL, LGPL and MPL licenses. Pike has its roots in LPC, which was a language developed for MUDs. Programmers at Lysator in Linköping, Sweden, most notably Fredrik Hübinette and Per Hedbor, separated the language and virtual machine from the rest of the MUD driver, and used it as a rapid prototyping language for various applications, calling it LPC4. LPC's license did not allow use for commercial purposes, and so a new GPL implementation was written in 1994, called µLPC (micro LPC). In 1996, µLPC
    0.00
    0 votes
    167

    PL/0

    At least two programming languages are known as PL/0. One is a subset of IBM's general-purpose programming language PL/I. The other PL/0, covered here, is similar to but much simpler than the general-purpose programming language Pascal, intended as an educational programming language. It serves as an example of how to construct a compiler. It was originally introduced in the book, Algorithms + Data Structures = Programs, by Niklaus Wirth in 1975. It features quite limited language constructs: there are no real numbers, very few basic arithmetic operations and no control-flow constructs other than "if" and "while" blocks. While these limitations make writing real applications in this language impractical, it helps the compiler remain compact and simple. The following is the syntax rules of the model language defined in EBNF: It is rather easy for students to write a recursive descent parser for such a simple syntax. Therefore, the PL/0 compiler is still widely used in courses on compiler construction throughout the world. Due to the lack of features in the original specification, students usually spend most of their time with extending the language and their compiler. They usually
    0.00
    0 votes
    168

    PL/C

    • Language Paradigms: Imperative programming
    PL/C is a computer programming language developed at Cornell University with the specific goal of being used for teaching programming. It is based on IBM's PL/I language, and was designed in the early 1970s. Cornell also developed a compiler for the language that was based on its earlier CUPL compiler, and it was widely used in college-level programming courses. The two researchers and academic teachers who designed PL/C were Richard W. Conway and Thomas R. Wilcox. They submitted the famous article "Design and implementation of a diagnostic compiler for PL/I" published in the Communications of ACM in March 1973, pages 169-179. PL/C eliminated some of the more complex features of PL/I, and added extensive debugging and error recovery facilities. PL/C is a subset of PL/I. A program that runs without error under the PL/C compiler should run under PL/I and produce the same results, unless certain incompatible diagnostic features, such as a macro section (begun by a $MACRO statement and finished by a $MEND statement), were used. The PL/C compiler had the unusual capability of never failing to compile any program, through the use of extensive automatic correction of many syntax errors
    0.00
    0 votes
    169

    PL/I

    • Language Paradigms: Imperative programming
    • Influenced: C
    • Influenced By: Fortran
    PL/I ("Programming Language One", pronounced "pee-el-one") is a procedural, imperative computer programming language designed for scientific, engineering, business and systems programming applications. It has been used by various academic, commercial and industrial organizations since it was introduced in the 1960s, and continues to be actively used as of 2011. PL/I's principal domains are data processing, numerical computation, scientific computing, and systems programming; it supports recursion, structured programming, linked data structure handling, fixed-point, floating-point, complex, character string handling, and bit string handling. The language syntax is English-like and suited for describing complex data formats, with a wide set of functions available to verify and manipulate them. In the 1950s and early 1960s business and scientific users programmed for different computer hardware using different programming languages. Business users were moving from Autocoders via COMTRAN to COBOL, while scientific users programmed in General Interpretive Programme (GIP), Fortran, ALGOL, GEORGE, and others. The IBM System/360 (announced in 1964 but not delivered until 1966) was designed
    0.00
    0 votes
    170

    PL/M

    • Influenced By: XPL
    The PL/M programming language (an acronym of Programming Language for Microcomputers) is a high-level language developed by Gary Kildall in 1972 for Intel for its microprocessors. The language incorporated ideas from PL/I, ALGOL and XPL, and had an integrated macro processor. Unlike other contemporary languages such as Pascal, C or BASIC, PL/M had no standard input or output routines. It included features targeted at the low-level hardware specific to the target microprocessors, and as such, it could support direct access to any location in memory, I/O ports and the processor interrupt flags in a very efficient manner. PL/M was the first higher level programming language for microprocessor based computers and the original implementation language for the CP/M operating system. Also the firmware of the Service Processor component of CISC AS/400 was written in PL/M. PL/M compilers have been made for the following processors/controllers: Intel 4004, 8008, 8080, 8085, 8051, 8052, 8096, 80196, 8086/8088, 80186/80188, 286, and 386. While some PL/M compilers were "native", meaning that they ran on systems using that same microprocessor, e.g. for the Intel ISIS operating system, there were
    0.00
    0 votes
    171

    PL/S

    PL/S, short for Programming Language/Systems, is a "machine-oriented" programming language based on PL/I. It was developed by IBM in the late 1960s, under the name Basic Systems Language (BSL), as a replacement for assembly language on internal software projects; it included support for inline assembly and explicit control over register usage. Early projects using PL/S were the batch utility, IEHMOVE, and the Time Sharing Option of MVT, TSO. By the 1970s, IBM was rewriting its flagship operating system in PL/S. Although users frequently asked IBM to release PL/S for their use, IBM refused saying that the product was proprietary. Their concern was that open PL/S would give competitors, Amdahl, Itel (National Advanced Systems), Storage Technology Corporation, Trilogy Systems, Magnuson Computer Systems, Fujitsu, Hitachi, and other PCM vendors a marketing advantage. However, even though they refused to make available a compiler, they shipped the PL/S source code to large parts of the OS to customers, many of whom thus became familiar with reading it. Closed PL/S meant that only IBM could modify and enhance the operating system. In the mid-1970s, a single programmer at RAND Corporation,
    0.00
    0 votes
    172

    Poplog

    • Language Paradigms: Stack-oriented programming language
    Poplog is a reflective, incrementally compiled software development environment for the programming languages POP-11, Common Lisp, Prolog, and Standard ML, originally created in the UK for teaching and research in artificial intelligence at the University of Sussex. After an incremental compiler for Prolog had been added to an implementation of POP-11, the name Poplog was adopted, to reflect the fact that it supported programming in both languages. The name was retained, as a trade mark of the University of Sussex, when the system was later extended as incremental compilers were added for Lisp and Standard ML. For some time after 1983, Poplog was sold and supported internationally as a commercial product, by Systems Designers Ltd, whose name changed as ownership changed. (The company is now owned by EDS.) In 1989, it was called SD-Scicon. At that time a management buy-out produced a spin-off company Integral Solutions Ltd (ISL), to sell and support Poplog in collaboration with Sussex University, who retained the rights to the name 'Poplog' and were responsible for most of the software development while it was a commercial product. ISL and its clients used Poplog for a number of
    0.00
    0 votes
    173
    PostScript

    PostScript

    • Language Paradigms: Stack-oriented programming language
    • Influenced: Processing
    • Influenced By: Forth
    PostScript (PS) is a dynamically typed concatenative programming language created by John Warnock and Charles Geschke in 1982. It is best known for its use as a page description language in the electronic and desktop publishing areas. The concepts of the PostScript language were seeded in 1976 when John Warnock was working at Evans & Sutherland, a computer graphics company. At that time John Warnock was developing an interpreter for a large three-dimensional graphics database of New York harbor. Warnock conceived the Design System language to process the graphics. Concurrently, researchers at Xerox PARC had developed the first laser printer and had recognized the need for a standard means of defining page images. In 1975-76 Bob Sproull and William Newman developed the Press format, which was eventually used in the Xerox Star system to drive laser printers. But Press, a data format rather than a language, lacked flexibility, and PARC mounted the InterPress effort to create a successor. In 1978 Evans and Sutherland asked Warnock to move from the San Francisco Bay Area to their main headquarters in Utah, but he was not interested in moving. He then joined Xerox PARC to work with
    0.00
    0 votes
    174
    Prograph

    Prograph

    • Language Paradigms: Object-oriented programming
    Prograph is a visual, object-oriented, dataflow, multiparadigm programming language that uses iconic symbols to represent actions to be taken on data. Commercial Prograph software development environments such as Prograph Classic and Prograph CPX were available for the Apple Macintosh and Windows platforms for many years but were eventually withdrawn from the market in the late 1990s. Support for the Prograph language on Mac OS X has recently reappeared with the release of the Marten software development environment. Research on Prograph started at Acadia University in 1982 as a general investigation into dataflow languages, stimulated by a seminar on functional languages conducted by Michael Levin. Diagrams were used to clarify the discussion, leading to the insight: "since the diagrams are clearer than the code, why not make the diagrams themselves executable!" Thus Prograph - Programming in Graphics - was born as a visual dataflow language. This work was led by Dr. Tomasz Pietrzykowski, with Stan Matwin and Thomas Muldner co-authoring early papers. From 1983 to 1985, research prototypes were built on a Three Rivers PERQ graphics workstation (in Pascal, with the data visualized
    0.00
    0 votes
    175

    Prolog

    • Language Paradigms: Logic programming
    • Influenced: Visual Prolog
    • Influenced By: CLACL
    Prolog is a general purpose logic programming language associated with artificial intelligence and computational linguistics. Prolog has its roots in first-order logic, a 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. A computation is initiated by running a query 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 Colmerauer with Philippe Roussel. Prolog was one of the first logic programming languages, and remains the most popular among 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 creating graphical user interfaces, as well as administrative and networked applications. In Prolog, program logic is expressed in terms of relations, and a
    0.00
    0 votes
    176
    Prospero Pascal

    Prospero Pascal

    Prospero Pascal is an ISO 10206-compatible Pascal compiler, produced by Prospero Software of England. The current compiler is for Extended Pascal under Windows. It is the only compiler in existence that fully implements the ISO 10206 standard for Extended Pascal. This is the ISO extension of standard Pascal, which was standardized as ISO 7185.
    0.00
    0 votes
    177

    Python 3

    Python 3, an interpreted programming language, is currently being developed by Guido van Rossum. It will be fully dynamically typed and use automatic memory management, as the current version. It is thus similar to Perl, Ruby, Scheme, Smalltalk, and Tcl. Python is developed as an open source project, managed by the non-profit Python Software Foundation. Python 3 is being developed with the same philosophy as in prior versions, so any reference to Python philosophy will apply to Python 3 as well. However, as Python has accumulated new and redundant ways to program the same task, Python 3 has an emphasis on removing duplicative constructs and modules, in keeping with "There should be one¬タヤand preferably only one¬タヤobvious way to do it". Nonetheless, Python 3 will remain a multi-paradigm language. Coders will still have options among object orientation, structured programming, functional programming, and aspect-oriented programming and other paradigms; but within such broad choices, the details are intended to be more obvious in Python 3 than they have become in Python 2.x. Python 3 (or more formally, for the initial release, Python 3.0), Python 3000, and Py3K are all names for
    0.00
    0 votes
    178
    Python for S60

    Python for S60

    • Language Paradigms: Functional programming
    The Python for S60 also called PyS60 (Unix name), is Nokia’s port of the general Python programming language to its S60 software platform, originally based on Python 2.2.2 from 2002. The latest final version, PyS60-2.0.0, released on 11 February 2010 updates the python core to version 2.5.4. First released in 2005, it featured a relatively small set of modules and functions. Version 1.2, the last non-opensource release and the second version of PyS60, brought many improvements and was made available on 21 October 2005 on Forum Nokia. After becoming open source, PyS60 had the advantage of a strong and dedicated community that could actively contribute to improving it. The milestone release was Version 1.3.11. The final version to support S60 2nd Edition platform, 1.4.5, was released on 3 December 2008. On 24 December 2008, a developer version, 1.9.0, was released. It featured several improvements, the main of which was a new core based on Python 2.5.1. The latest final version, 2.0.0, was released on 11 February 2010. Its core is based on Python 2.5.4.
    0.00
    0 votes
    179

    QBasic

    • Influenced: PowerBASIC
    • Influenced By: GW-BASIC
    QBasic is an IDE and interpreter for a variant of the BASIC programming language which is based on QuickBASIC. Code entered into the IDE is compiled to an intermediate form, and this intermediate form is immediately interpreted on demand within the IDE. It can run under nearly all versions of DOS and Windows, or through DOSBox/DOSEMU, on Linux and FreeBSD. For its time, QBasic provided a state-of-the-art IDE, including a debugger with features such as on-the-fly expression evaluation and code modification. Like QuickBASIC, but unlike earlier versions of Microsoft BASIC, QBasic is a structured programming language, supporting constructs such as subroutines and while loops. Line numbers, a concept often associated with BASIC, are supported for compatibility, but are not considered good form, having been replaced by descriptive line labels. QBasic has limited support for user-defined data types (structures), and several primitive types used to contain strings of text or numeric data. QBasic was intended as a replacement for GW-BASIC. It was based on the earlier QuickBASIC 4.5 compiler but without QuickBASIC's compiler and linker elements. Version 1.0 was shipped together with MS-DOS
    0.00
    0 votes
    180
    Qi

    Qi

    • Language Paradigms: Functional programming
    • Influenced By: Lisp
    Qi is a functional programming language developed by Dr Mark Tarver and introduced in April 2005. A new version was reimplemented and issued as Qi II in November 2008. The first version was free software, licensed under GPL. But, as GPL was perceived as unfriendly to commercial use, Qi II is available via two proprietary licenses: one for personal and educational use, and another for producing closed source software. Qi is written in Lisp. It includes most of the features common to modern functional programming languages such as pattern-matching, currying, partial applications, guards and (optional) static type checking. Qi was developed as part of the L21 project, which aims to modernise Lisp to meet the challenges of twenty-first century computing. In his lecture, Tarver outlined a series of current challenges to Lisp which he argued were damaging to the wider use of the language. Specifically he identified Common Lisp's lack of pattern-matching, inconsistency with respect to lambda calculus theory (partial applications being missing), procedural contamination and lack of static typing. These deficiencies, Tarver argued, had led to a general abandonment of Lisp as a teaching
    0.00
    0 votes
    181
    Quartz Composer

    Quartz Composer

    Quartz Composer is a node-based visual programming language provided as part of the Xcode development environment in Mac OS X for processing and rendering graphical data. Quartz Composer uses OpenGL (including GLSL), OpenCL (only in Mac OS X 10.6 and later), Core Image, Core Video, JavaScript, and other technologies to build an API and a developer tool around a simple visual programming paradigm. Apple has embedded Quartz technologies deeply into the operating system. Compositions created in Quartz Composer can be played standalone in any QuickTime-aware application (although only on Mac OS X 10.4 and later), as a system Screen Saver, as an iTunes Visualizer, from inside the Quartz Composer application, or can be embedded into a Cocoa or Carbon application via supplied user interface widgets. Because Quartz Composer makes extensive use of hardware acceleration and pixel shaders, it is recommended to have a graphics card with at least 32 MB of VRAM. While Quartz Composer is included with the iPhone SDK, there is currently no way of running Quartz Compositions on iOS devices. Quartz programming through Quartz Composer works by implementing and connecting patches. Similar to routines
    0.00
    0 votes
    182
    Query by Example

    Query by Example

    Query by Example (QBE) is a database query language for relational databases. It was devised by Moshé M. Zloof at IBM Research during the mid 1970s, in parallel to the development of SQL. It is the first graphical query language, using visual tables where the user would enter commands, example elements and conditions. Many graphical front-ends for databases use the ideas from QBE today. Originally limited only for the purpose of retrieving data, QBE was later extended to allow other operations, such as inserts, deletes and updates, as well as creation of temporary tables. The motivation behind QBE is that a parser can convert the user's actions into statements expressed in a database manipulation language, such as SQL. Behind the scenes, it is this statement that is actually executed. A suitably comprehensive front-end can minimize the burden on the user to remember the finer details of SQL, and it is easier and more productive for end-users (and even programmers) to select tables and columns by selecting them rather than typing in their names, In the context of information retrieval, QBE has a somewhat different meaning. The user can submit a document, or several documents, and
    0.00
    0 votes
    183
    QVT

    QVT

    QVT (Query/View/Transformation) is a standard set of languages for model transformation defined by the Object Management Group . Model transformation is a key technique used in model-driven architecture. As the name QVT indicates, the OMG standard covers transformations, views and queries together. Model queries and model views can be seen as special kinds of model transformation, provided that we use a suitably broad definition of model transformation: a model transformation is a program which operates on models. The QVT standard defines three model transformation languages. All of them operate on models which conform to MOF 2.0 metamodels; the transformation states which metamodels are used. A transformation in any of the three QVT languages can itself be regarded as a model, conforming to one of the metamodels specified in the standard. The QVT standard integrates the OCL 2.0 standard and also extends it with imperative features. Finally there is a mechanism called QVT-BlackBox for invoking transformation facilities expressed in other languages (for example XSLT or XQuery). Although QVT has a broad scope, it does not cover everything that has been considered as a model
    0.00
    0 votes
    184

    REALbasic

    • Language Paradigms: Object-oriented programming
    • Influenced By: BASIC
    Realbasic (RB) is the object-oriented dialect of the BASIC programming language used in Real Studio, a programming environment, developed and commercially marketed by Real Software, Inc of Austin, Texas for Mac OS X, Microsoft Windows, 32-bit x86 Linux and the web. REALbasic was created by Andrew Barry. It was originally called CrossBasic due to its ability to compile the same programming code for Mac OS and Java (although the integrated development environment was Mac only). In 1997 CrossBasic was purchased by FYI Software which renamed it REALbasic as well as renaming the company REAL Software. At this time they dropped the Java target, later replacing it with a Windows target and database support. This was promised for version 1.0 and was eventually pushed back to version 2.0, although it contained many bugs when finally released. The IDE is now available for Microsoft Windows, Mac OS X, and 32-bit x86 Linux and can compile applications for Windows (Windows 2000 and higher), Mac OS X (PowerPC, Intel, and Universal Binary) and 32-bit x86 Linux. With 2010 Release 1, the IDE was renamed REAL Studio. The programming language itself remained under the name REALbasic. On August 31,
    0.00
    0 votes
    185
    REBOL

    REBOL

    • Language Paradigms: Functional programming
    • Influenced: Syp Script
    • Influenced By: Lisp
    REBOL ( /ˈrɛbəl/ REB-əl; Relative Expression Based Object Language) is a cross-platform data exchange language and a multi-paradigm dynamic programming language originally designed by Carl Sassenrath for network communications and distributed computing. The language and its official implementation, which is proprietary freely redistributable software, are developed by REBOL Technologies. REBOL Technologies also claims the name REBOL as a trademark. Douglas Crockford of JavaScript fame has described REBOL as "a more modern language, but with some very similar ideas to Lisp, in that it's all built upon a representation of data which is then executable as programs" and as one of JSON's influences. REBOL introduces the concept of dialecting: small, optimized, domain-specific languages for code and data, which is also the most notable property of the language according to its designer: REBOL has been used to program Internet applications (both client- and server-side), database applications, utilities, and multimedia applications. First released in 1997, REBOL was designed over a 20 year period by Carl Sassenrath, the architect and primary developer of AmigaOS, based on his study of
    0.00
    0 votes
    186

    REXX

    • Language Paradigms: Object-oriented programming
    • Influenced: NetRexx
    • Influenced By: BASIC
    REXX (REstructured eXtended eXecutor) is an interpreted programming language developed at IBM by Mike Cowlishaw. It is a structured, high-level programming language designed for ease of learning and reading. Proprietary and open source REXX interpreters exist for a wide range of computing platforms; compilers exist for IBM mainframe computers. Rexx is widely used as a glue language, macro language, and is often used for processing data and text and generating reports; these similarities with Perl mean that Rexx works well in Common Gateway Interface (CGI) programming and it is indeed used for this purpose. Rexx is the primary scripting language in some operating systems, e.g. OS/2, MVS, VM, AmigaOS, and is also used as an internal macro language in some other software, e.g., KEDIT, THE, the ZOC terminal emulator. Additionally, the Rexx language can be used for scripting and macros in any program that uses Windows Scripting Host ActiveX scripting engines languages (e.g. VBScript and JScript) if one of the Rexx engines (see below) are installed. Rexx is supplied with VM/SP on up, TSO/E Version 2 on up, OS/2 (1.3 on up), AmigaOS Version 2 on up, PC DOS (7.0 or 2000), and Windows NT
    0.00
    0 votes
    187
    Roadsend PHP

    Roadsend PHP

    Roadsend PHP is an alternative implementation of the PHP programming language. It includes an interpreter, native compiler, and step debugger. Roadsend Compiler can be used to build online web applications with FastCGI, offline web applications with an embedded web server (using the included "MicroServer"), desktop GUI applications with PHP-GTK, libraries, and console applications. Roadsend PHP compiler is unique among PHP implementations because rather than compiling and interpreting PHP byte code, it compiles PHP source code to native machine code. Roadsend PHP builds on Linux, Microsoft Windows (using MinGW), Mac OS X, and FreeBSD. The Windows release includes the Roadsend Studio IDE. Originally developed by Roadsend Inc., it has been in development since 2002 and was released under the terms of the GNU General Public License in 2007, making it free software. The Roadsend PHP runtime environment and extension libraries are available under the terms of the GNU Lesser General Public License. Roadsend PHP is a completely independent implementation of the PHP language and runtime environment, and is not based on the original implementation (using the Zend Engine). "Zend PHP" is not
    0.00
    0 votes
    188
    RTML

    RTML

    RTML is a proprietary programming language used exclusively by Yahoo!'s Yahoo! Store and Yahoo! Site web hosting services. The language originated at Viaweb, a company founded in 1995 by Paul Graham and Robert T. Morris, as the template language for their e-commerce platform. RTML stands for "Robert T. Morris Language". The RTML editor was offered as an option for customers (usually small businesses) who wanted to customize their online stores more than the built-in templates allowed. The built-in templates were also written in RTML, and provided the starting point for most people who used the language. In 1998, Yahoo! bought Viaweb for $49.6 million and renamed the service Yahoo! Store. Yahoo! later offered the RTML-based content management system in a hosting platform without a shopping cart, under the name Yahoo! Site. In 2003, Yahoo! renamed the Yahoo! Store service Yahoo! Merchant Solutions (part of Yahoo! Small Business), and at the same time began offering new customers the choice of a more standard PHP/MySQL web hosting environment instead of the RTML-based Store Editor. As of 2006, many new Yahoo! Merchant Solutions sites and legacy Yahoo! Stores continue to be built using
    0.00
    0 votes
    189

    Runtime Revolution

    • Influenced By: SuperTalk
    Runtime Revolution Ltd. makes the LiveCode cross-platform development environment (formerly the Revolution programming language) for creating applications that run on iOS, Microsoft Windows, Linux, Mac OS X and Solaris. LiveCode began as an expert IDE for MetaCard, a development environment and GUI toolkit originally developed for UNIX development and later ported to support Microsoft Windows and Mac OS compilation. Runtime Revolution Ltd acquired MetaCard in July 2003 and released subsequent versions under the Revolution brand. MetaCard built on the success of its predecessor HyperCard. Both HyperCard and MetaCard utilized an English-like language that arguably was easier to learn than BASIC. The language has been known by several names including Transcript, RevTalk and as of November 2010 "LiveCode". The entire product including the IDE is now officially referred to as LiveCode. The iOS version is available as of December 2010, with the Android and Server Versions under development. The LiveCode environment consists of a powerful and easy to use programming language, formerly called Transcript, an IDE framework, and an engine, which are all used together as a Rapid Application
    0.00
    0 votes
    190
    SAC programming language

    SAC programming language

    • Language Paradigms: Array programming
    • Influenced By: SISAL
    SAC (Single Assignment C) is a strict purely functional programming language which design is focused on the needs of numerical applications. Emphasis is laid on efficient support for array processing. Efficiency concerns are essentially twofold. On the one hand, efficiency in program development is to be improved by the opportunity to specify array operations on a high level of abstraction. On the other hand, efficiency in program execution, i.e. the runtime performance of programs, in time and memory consumption, is still to be achieved by sophisticated compilation schemes. Only as far as the latter succeeds, the high-level style of specifications can actually be called useful. To facilitate compiling to efficiently executable code, certain functional language features which are not considered essential for numerical applications, e.g. higher-order functions, polymorphism, or lazy evaluation, are not (yet) supported by SAC. These may be found in general-purpose functional languages, e.g. Haskell, Clean, Miranda, or ML. To overcome the acceptance problems encountered by other functional or array based languages intended for numerical / array intensive applications, e.g. SISAL,
    0.00
    0 votes
    191

    SAIL programming language

    SAIL, the Stanford Artificial Intelligence Language, was developed by Dan Swinehart and Bob Sproull of the Stanford AI Lab in 1970. It was originally a large ALGOL 60-like language for the PDP-10 and DECSYSTEM-20. SAIL's main feature is a symbolic data system based upon an associative store (based on the LEAP system of Jerry Feldman and Paul Rovner). Items may be stored as unordered sets or as associations (triples). Other features include processes, events and interrupts, contexts, backtracking and record garbage collection. It also has block-structured macros, a coroutining facility and some new data types intended for building search trees and association lists. A number of interesting software systems were coded in SAIL, including some early versions of FTP and TeX, a document formatting system called PUB, and the first general purpose, interactive spreadsheet program called BRIGHT. In 1978, there were half a dozen different operating systems for the PDP-10: ITS (MIT), WAITS (Stanford), TOPS-10 (DEC), CMU TOPS-10 (Carnegie Mellon), TENEX (BBN), and TOPS-20 (DEC, based on TENEX). SAIL was ported from WAITS to ITS so that MIT researchers could make use of software developed at
    0.00
    0 votes
    192

    Sather

    • Language Paradigms: Functional programming
    • Influenced: Cool
    • Influenced By: Eiffel
    Sather is an object-oriented programming language. It originated circa 1990 at the International Computer Science Institute (ICSI) at the University of California, Berkeley, developed by an international team led by Steve Omohundro. It supports garbage collection and generics by subtypes. Originally, it was based on Eiffel, but it has diverged, and now includes several functional programming features. It is probably best to view it as an object-oriented language, with many ideas borrowed from Eiffel. Even the name is inspired by Eiffel; the Sather Tower is a recognizable landmark at Berkeley, named after Peder Sather who donated large sums to the foundation of the university. Sather also takes inspiration from other programming languages and paradigms: iterators, design by contract, abstract classes, multiple inheritance, anonymous functions, operator overloading, contravariant type system. Some of these features are normally only found in functional programming languages. The original Berkeley implementation (last stable version 1.1 was released in 1995, no longer maintained ) has been adopted by the Free Software Foundation therefore becoming GNU Sather. Last stable GNU version
    0.00
    0 votes
    193

    SCAR

    SCAR is a Pascal interpreter written in Delphi. The program was originally designed to be a macroing tool for well known MMORPG RuneScape. However, the program can be used to macro on most games (given that they aren't protected against it). SCAR stands for "Shite Compared to AutoRune" SCAR was originally developed by Aivars Irmejs, (commonly referred to in the cheating community as Kaitnieks) in 2003 as an effort to revive the then dead RuneScape cheating scene. Since then, he constantly developed it until he left the cheating community in early 2006. Irmejs has recently appointed a new programmer in December 2006, Frᅢᄅdᅢᄅric Hannes (Freddy1990), to resume the production of SCAR. On the 10th of April 2007, Frᅢᄅdᅢᄅric released the first new version of SCAR, codenamed "Divi," or two in Irmejs' native language, Latvian. Before creating SCAR, Aivars Irmejs created a cheating program for RuneScape called AutoRune. Eventually, AutoRune became obsolete, due to Jagex updates. At that point, SCAR, a more scalable and therefore survivable cheating option, was created to "keep the autoing community busy so that they don't scam and flame," and to "educate them." SCAR is now not only used
    0.00
    0 votes
    194

    SCOOP

    SCOOP (Simple Concurrent Object Oriented Programming) is a concurrency model designed for the Eiffel programming language, conceived by Eiffel's creator and designer, Bertrand Meyer. SCOOP defines a way for an object oriented program to be written without the concept of threads, locks, or other typical multiprogramming methods. This allows the compiler or runtime environment to optimize the amount of concurrency as well as eliminate typical design flaws such as deadlock. The model was first designed in the early 1990s and published in 1993 in the Communications of the ACM An updated version was described in chapter 30 of the book Object-Oriented Software Construction. A prototype implementation was developed in 1995 by Eiffel Software. An article by Compton and Walker provides an overview of SCOOP and describes another early implementation. Nienaltowski, Arslan and Meyer have published a description of the model as of 2003. Work on SCOOP proceeded at the Chair of Software Engineering at ETH Zurich. SCOOP became available as a standard part of EiffelStudio early in 2011. SCOOP works by allowing references to certain objects to be declared as separate. In the code below, an entity
    0.00
    0 votes
    195
    Scratch

    Scratch

    • Language Paradigms: Object-oriented programming
    • Influenced By: Logo
    Scratch is a programming language learning environment enabling beginners to get results without having to learn syntactically correct writing first. Created by the MIT Media Lab, it is intended to motivate for further learning through playfully experimenting and creating projects, such as interactive animations, games, etc. The name Scratch derived from the turntablism's technique of scratching(Mixing Sounds) and stresses the similarity of the process of programming to the process of mixing/scratching instead of its similarity to the processes of writing (i.e. scripting). Scratch is available for Windows, Mac OS X, and Linux. The source code is made available under GPLv2 license and Scratch Source Code License. The first version of Scratch was developed in 2006 by the Lifelong Kindergarten group, led by Mitchel Resnick, at the MIT Media Lab. Scratch allows for constructing and testing through mostly tactile process because the creators' first priority was to make it as easily learned by children as possible. The tactile and visual GUI of Scratch allows children to explore by dragging-and-dropping blocks of conditions (with parameters) and of consequences ("actions") onto selected
    0.00
    0 votes
    196

    Sed

    • Influenced: Perl
    sed (stream editor) is a Unix utility that parses text and implements a programming language which can apply transformations to such text. It reads input line by line (sequentially), applying the operation which has been specified via the command line (or a sed script), and then outputs the line. It was developed from 1973 to 1974 as a Unix utility by Lee E. McMahon of Bell Labs, and is available today for most operating systems. sed is one of the very early Unix commands built for command line processing of data files. It evolved as the natural successor to the popular grep command. Cousin to the later AWK, sed allows powerful and interesting data processing to be done by shell scripts. sed and AWK are often cited as the progenitors and inspiration for Perl. The s / / / syntax shown below is part of Perl's syntax and originated with ed, the precursor to sed. sed's language does not have variables and has only primitive GOTO and branching functionality; nevertheless, the language is Turing-complete. GNU sed added several new features. The best-known is in-place editing of files (i.e., replace the original file with the result of applying the sed program), which was later included
    0.00
    0 votes
    197
    Self

    Self

    • Language Paradigms: Prototype-based programming
    • Influenced: JavaScript
    • Influenced By: Smalltalk
    Self is an object-oriented programming language based on the concept of prototypes. Self was a dialect of Smalltalk, being untyped and using Just-in-time compilation as well as the prototype-based approach to objects: it was first used as an experimental test system for language design in the 1980s and 1990s. In 2006, Self was still being developed as part of the Klein project, which was a Self virtual machine written fully in Self. The latest version is 4.4, released in July 2010. Several just-in-time compilation (JIT) techniques were pioneered and improved in Self research as they were required to allow a very high level object oriented language to perform at up to half the speed of optimized C. Much of the development of Self took place at Sun Microsystems, and the techniques they developed were later deployed for Java's HotSpot virtual machine. At one point a version of Smalltalk was implemented in Self. Because it was able to use the JIT this also gave extremely good performance. Self was designed mostly by David Ungar and Randall Smith in 1986 while working at Xerox PARC. Their objective was to push forward the state of the art in object-oriented programming language
    0.00
    0 votes
    198
    SenseTalk

    SenseTalk

    SenseTalk is an English-like scripting language derived from the HyperTalk language used in HyperCard. SenseTalk was originally developed as the scripting language within the HyperSense multimedia authoring application on the NeXTStep and OpenStep platforms. SenseTalk resurfaced in 2002 as the scripting language in eggPlant, the first commercial Mac OS X and cross-platform GUI testing application. SenseTalk is a very English-like scripting language in the xTalk family (derived from HyperTalk) with more advanced programming language extensions. There are a number of features that distinguish SenseTalk from other xTalk languages. One of these is the inclusion of both lists and property lists as first class data structures. Another is the inclusion of objects. SenseTalk treats any script or property list as an object, encapsulating both properties and behaviors. SenseTalk does not include the concept of object classes, but instead treats every object equally. Any object can inherit behavior from any other object or objects (multiple inheritance is supported).
    0.00
    0 votes
    199
    Simgua

    Simgua

    Simgua is a cross-platform system dynamics modeling application. It takes a dynamic stock and flow approach to modeling in which stocks act as reservoirs that store a material and flows transfer materials between stocks. An emphasis on communication and understandability is placed on the models developed by Simgua. Simgua models are constructed from a variety of ten basic objects known as 'primitives' (of which stocks and flows are two). Primitives are assigned properties such as the rate of flow for flow primitives. Equations may be entered using elementary mathematics or Visual Basic code. In addition to primitives, Simgua supports what it calls 'components.' Components are redistributable collections of primitives and Visual Basic code that can be used to model standardized processes and then be shared amongst users. Simgua comes with a set of components design to model Wastewater Treatment Plants. The results of a Simgua simulation is a time-based series of data containing the changing state of the model over the course of the simulation. The first version of Simgua was released for the Macintosh in May 2008. Version 2.0 was released in January 2009 and included enhanced
    0.00
    0 votes
    200
    SimPy

    SimPy

    SimPy is a free process-based, object-oriented discrete-event simulation language in Python. It provides the modeller with components for building a simulation model including Processes, for active entities like customers, messages, and vehicles, and Resources, for passive components that form limited capacity congestion points like servers, checkout counters, and tunnels. There are two varieties of Buffer classes, Levels to hold stored quantities and Stores to hold sets of objects. It has commands to aid interaction between entities. It provides Monitor and Tally objects to aid in gathering statistics and uses the standard Python random module to generate random variates. It is implemented in standard Python, 2.x and 3.x and is released as open source software under the GNU Lesser General Public License (LGPL). SimPy is platform-independent. It simulates parallel processes by an efficient implementation of coroutines using Python's generators capability. It is based on ideas from Simula and SIMSCRIPT II.5. The first version was released in December 2002.
    0.00
    0 votes
    201

    Simula

    • Language Paradigms: Object-oriented programming
    • Influenced: Smalltalk
    • Influenced By: ALGOL
    Simula is a name for two simulation 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. The influence of Simula is often understated, and Simula-type objects are reimplemented in C++, Java and C#. 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
    0.00
    0 votes
    202

    SISAL

    • Language Paradigms: Dataflow language
    • Influenced: Haskell
    • Influenced By: C
    SISAL (Streams and Iteration in a Single Assignment Language) is a general-purpose single assignment functional programming language with strict semantics, implicit parallelism, and efficient array handling. SISAL outputs a dataflow graph in Intermediary Form 1 (IF1). It was derived from VAL (Value-oriented Algorithmic Language, designed by Jack Dennis), and adds recursion and finite streams. It has a Pascal-like syntax and was designed to be a common high-level language for numerical programs on a variety of multiprocessors. SISAL was defined in 1983 by James McGraw et al., at the University of Manchester, LLNL, Colorado State University and DEC. It was revised in 1985, and the first compiled implementation was made in 1986. Its performance is superior to C and rivals Fortran, according to some sources, combined with efficient and automatic parallelization. SISAL's name came from grepping "sal" for "Single Assignment Language" from the Unix dictionary /usr/dict/words. Versions exist for the Cray X-MP, Y-MP, 2; Sequent, Encore Alliant, DEC VAX-11/784, dataflow architectures, KSR1, Transputers and systolic arrays. SISAL saw a brief resurgence in 2010 when a group of undergraduates
    0.00
    0 votes
    203

    SKED

    Designed by Arthur Snapper at Western University of Michigan in the early 1970's, SKED is a state notation, quasi-parallel programming language for the real-time control of experimental apparatus.  Originally exchanged between cooperating laboratories on paper tape (and later on DEC Tape), through the SKED Users Group (SKUG).

    SKED was a standard method for the control of experimental apparatus in Operant Conditioning laboratories from the early-1970's through the early 90's.  It was implemented on Digital Equipment Corporation PDP-8 and PDP-11 (released by State Systems, Inc.) and adapted for Intel 80286 PCs by Med Associates, Inc. as a Pascal precompiler.

    The language consists of numbered States Sets (designated "S.S.n,") which contain numbered states ("Sn"), where n is a numeric identifier.

    States define entry conditions and transition rules for changing to other States within the State Set.  State Sets can be synchronized by sending global "Z pulse" messages to all State Sets.

    The langage includes syntax for reading/writing the binary state of control lines to the apparatus, assigning numeric array variables ("counters") and performing simple branch conditionals.

    Sample PDP-8 SKED Listing:


    //////////////////////////////////////// / / / FIXED RATIO 60 / / TIME-SHARE SUPER SKED / / / //////////////////////////////////////// /FR60S.SK FIXED RATIO 60 EXAMPLE /**SKED PROGRAM TO COLLECT EVERY IRT /AND APPEND IT TO A CODE NUMBER /2=LIGHT ABOVE LEVER 3=FEEDER 4=STEPPER 5=REPORT 6=MOTOR 1=RESET /Z1=COUNT OF REINFORCEMENTS /Z2=CUMULATIVE RECORDER /CODE: 0=IRT / 1=REINFORCED IRT / 7=END OF SESSION / 2=RESPONSES DURING REINFORCEMENT / 3=END OF REINFORCEMENT CYCLE S.S.1,/RATIO S1, R12:ON2,4,5,6,1;OPEN;IF B=0[SET B=60];SET B(1)=B--->S2 /DEFAULT RATIO SIZE=60 S2, B(1) R1:RECORD 1;SET B(1)=B;ON3;OFF2,5,6;Z2;Z1--->S3 /FEED ON,LIGHT & MOTOR /OFF,REPORT,CODE=1 R1:OFF4;Z2;;RECORD0--->SX /STEP RECORDER,INC COUNTER & CODE=0 S3, R1:RECORD 2;--->SX /NO CUM RECORD,INC COUNTER & CODE=2 4":OFF3;ON6,2;RECORD 3;--->S2 /OFF FEED,ON LIGHT & MOTOR /INC COUNTER & CODE=3 S.S.2,/CUMULATIVE RECORDERS S1, Z2--->S2 S2, .02":ON4,5--->S1 /STEP AND/OR REPORT S.S.3,/END OF SESSION S1, R12--->S2 S2, 60'+100Z1+R13:RECORD 7--->S3 /CODE=7 /END SESSION FROM KEYBOARD S3, .01":CLOSE--->STOP /HIT LAST DUMP 'TILL WE HAVE TIME $ //////////////////////////////////////// / / / VARIABLE INTERVAL / /****FOR SUPER SKED*** / / / //////////////////////////////////////// /VI WITH CODED IRTS AND DUMPS /VINTER.SK /CONTAINS LIST FOR ONE AND TWO MINUTE VI-SELECT WITH "/" /TIMES MAY BE SELECTED RANDOMLY OR SEQUENTIALY -- USE "/" / TO COMMENT OUT RAND OR LIST FUNCTION IN S1 & S2 OF S.S.1 CTRS=1 /3 = FEEDER /2 = LIGHT /1 = RESET /4 = STEPPER /5 = REPORT /6 = MOTOR /CODE :0=IRT / 1=REINFORCED IRT / 7=END OF SESSION / 2=RESPONSES DURING REINFORCEMENT / 3=END OF REINFORCEMENT CYCLE / 4=END OF INTERVAL / /VARIABLES: A=LIST OF INTERVALS / B=POINTER TO NEXT ELEMENT--B MAY BE SET BEFORE SESSION STARTS / Z=CURRENT INTERVAL / /TWO MINUTE VI /LIST A=6",12.32",18.98",26.04",33.54",41.54",50.11",59.34",69.34",80.25", /92.25",105.59",120.59",137.73",157.73",181.70",211.73",251.73",311.73",431.73" / /ONE MINUTE VI LIST A=15",40",80",3",110",50",118",20",105",115",5",100",30",10",60",90",70",17" / / S.S.1,/ IRT CODING S1, / R12:LIST Z=A(B);ON2,1,4,5,6;OPEN-->S2 R12:RAND Z=A;ON1,2,4,5,6;OPEN---->S2 /RANDOM FROM LIST A S2, / Z T:LIST Z=A(B);RECORD 4--->S3 Z T:RAND Z=A;RECORD 4--->S3 /RAND WITHOUT REPLACEMENT R1:RECORD 0;OFF4;Z3-->SX S3, R1:ON3;OFF2,5,6;Z3;RECORD 1-->S4/START RF S4, 4":OFF3;ON2,6;RECORD 3-->S2/END RF & START OF NEXT INTERVAL R1:RECORD 2-->SX/ RESPONSES DURING RF COUNTED S.S.4,/ CUMMULATIVE RECORDERS S1, Z3-->S2 S2, .02":ON4,5-->S1 S.S.5,/ END SESSION AND FINAL DUMP S1, R12-->S2 S2, 60':RECORD 7-->S3 R13:RECORD 7-->S3 S3, .01":CLOSE-->STOP/ FINAL DUMP $ //////////////////////////////////////// / / / FI FR (STRIPPED DOWN VERSION) / /FOR SUPER SKED! / / / //////////////////////////////////////// COUNTERS=8 / EVERY IRT IS COLLECTED / RATIO SIZE IS 20 AND INTERVAL SIZE IS 7' / 1-RESET 2-SD LIGHT AND TONE 3-FEEDER AND REPORT (RECORDS REIN.) / 4-STEPPER (RESPONSES) 5-MOTOR AND EVENT MARKER (RECORDS CHANGE / IN SCHEDULE) 6-HOUSELIGHT / / Z1-STARTS FR AFTER T.O. Z2-CUMULATIVE RECORDER OPERATION / Z4-STARTS FI AFTER T.O. Z5-STARTS T. O. Z7- SD OPERATION FOR FR / Z8-STOPS SD DURING REIN. IN FI. Z9-COUNTS COMPLETE CYCLES. / SESSION ENDS AFTER 6 CYCLES OR 60' / / IRT CODES / 0- IRT 1-REINFORCED IRT 2- RESPONSES DURING REINFORCEMENT / 3- END OF REINFORCEMENT CYCLE 4-END OF LIMITED HOLD / 5- END OF TIME OUT 6- END OF TIME OUT / 7- END OF SESSION / /MONITOR COUNTERS FOR DURING SESSION. NOT DUMPED AUTOMATICALLY /COUNTER: /1-RESPONSES DURING FR /2-FR REINFORCEMENTS /3-RESPONSES DURING FI /4-REINFORCEMENTS DURING FI /5-NUMBER OF FR REINFORCEMENTS MISSED BECAUSE OF LIMITED HOLD /6-NUMBER OF TIMES FI REINFORCEMENT IS MISSED BECAUSE OF LIMITED HOLD /7-RESPONSES DURING FR TIME OUT /8-RESPONSES DURING FI TIME OUT / S.S.1, /FIXED RATIO S1, R12:OPEN;ON1,2,5,6;Z7;SET S=1--->S2 S2, 20 R1:RECORD 1;ADD 1;ON3;OFF2,5;Z8--->S3 /CODE=1 R1:RECORD 0;OFF4;Z2;ADD 1--->SX /STEP & RECORD IRT 5':RECORD 4;ADD 5;Z5,8--->S4 /EXPIRATION OF LH IN RATIO S3, R1:OFF4;RECORD 2;Z2--->SX / CUM REC. CODE=2 4":OFF3;RECORD 3;Z5;ADD 2--->S4 /OFF FEED, EVENT MARKS END OF RF.,STARTS /T.O. CODE=3 S4, Z1:SET S=1;ON1,2,5,6;Z7--->S2 /STARTS FR AFTER T.O. /VALUE OF S INDICATES THAT NEXT /TIME OUT IS A RATIO TIMEOUT / S.S.2, /FI7' S1, Z4:SET S=2;ON2,5,6--->S2 /Z4 FROM FR T.O. STARTS INTERVAL. S2, R1: RECORD 0;OFF4;Z2;ADD 3--->SX /CODE=0, R ARE COUNTED. 7':RECORD 6--->S3 /END OF FI INTERVAL. CODE=6 S3, R1:RECORD 1;ON3;OFF2,5;ADD 4--->S4 /REIN. R. CODE=1 1':RECORD 4;OFF5;Z5;ADD 6--->S1 / LIMITED HOLD. STARTS FI T.O. S4, 4":OFF3;RECORD 3;Z5--->S1 /END REIN. CODE=3 /STARTS FI T.O. R1:RECORD 2--->SX /COUNTS R DURING REIN. CODE=2 / S.S.3, / FR DISC. STIMULI OPERATION S1, Z7--->S2 / STARTS OF FR STARTS THIS S.S. SD ARE ON. S2, .04":OFF2--->S3 /SD IS ON .O4" /RESTART BY BEGINNING OF FI. Z8:OFF2--->S1 /TURNS OFF SD DURING REINFORCEMENT S3, .15":ON2--->S2 / AFTER .15" OFF, TURNS ON Z8--->S1 / FR LIMITED HOLD HAS EXPIRED OR REINFORCEMENT HAS / OCCURRED. WAIT FOR START OF NEXT RATIO / S.S.4, /TIME OUT S1, Z5:OFF2,6--->S2 /STARTS T.O.,OFF HL,REPORT /REPORT-MOTOR OFF. Z2 TURNS ON /AFTER .O2" IN S.S.2 S2, R1:RECORD 0;Z2;OFF4 --->SX /COUNT R DURING T.O. 25"--->S3 /R DURING 1ST. 25" HAVE NO EFFECT S3, R1:RECORD 0;Z2;OFF4;IF S=2; ADD 8--->S3 /R RESETS CLOCK TO 5" :ADD 7--->S3 5":RECORD 5;IF S=2;OFF1;Z1,2,9--->S1 :Z4,2--->S1 /IF S=2, THIS MEANS THAT LAST SCHEDULE WAS AN INTERVAL, SO /START RATIO,RESET CUMULATIVE RECORDER, AND COUNT COMPLETE / CYCLE (Z1,9). IF S IS NOT /EQUAL TO 2 THEN LAST SCHEDULE WAS A RATIO SO INTERVAL /IS STARTED BY GOING TO NEXT (DEFAULT) LINE. /CODE 5 IS END OF TIME OUT. / S.S.5, /CUMULATIVE RECORDER OPERATION FOR ALL STATE SETS. S1, Z2--->S2 S2, .02":ON1,4--->S1 /RESET,STEPPER,REPORT / S.S.6, / ENDING SESSION S1, R12--->S2 S2, R13 + 6Z9 + 60' :RECORD 7--->S3 /RECORDS TIME BETWEEN LAST RESPONSE AND END OF SESSION /SESSION ENDS AFTER 6 CYCLES OR 60 MINUTES S3, .01":CLOSE--->STOP /END OF SESSION DUMP //////////////////////////////////////// / / /FIXED RATIO 45 / /12 HOUR SESSION / / / //////////////////////////////////////// CTRS=38 /NEWFR45.SK /1=RESPONSES /2=RESPONSES DURING THE REINFORCEMENT /3=POSTREINFORCEMENT PAUSES /4=RATIO DURATION /CF=HISTOGRAM OF RF FREQUENCY /2=LIGHT--3=FEEDER--4=REPORT /R1=LEVER /E(1)=CURRENT RATIO SIZE /E(0)=RATIO SIZE /X=STARTING TIME /Y=ENDING TIME /L=LENGTH OF SESSION IN HALF HOURS AND IS AN INTEGER /A=THE NUMBER OF UNUSED SPACES FOR DATA /Z1=START OF REINFORCEMENT /Z2=END OF REINFORCEMENT /Z3=RECORDER S.S.1,/RATIO S1, / DEFAULT RATIO SIZE IS 45 , SET E TO CHANGE RATIO SIZE R12:ON2;OPEN;IF E=0[SET E=45]; SET E(1)=E;TIME X;WRITE E,16; IF L=0[SET L=22]--->S2 / L MAX=22 S2, R1:ADD 1--->SX / AFTER ONE RATIO FEEDER AND REPORT ON,LIGHT OFF,RESET E(1) TO 45 E(1) R1:ON3,4;OFF2;Z1;SET E(1)=E--->S3 S3, R1:ADD 2--->SX / THE FEEDER IS UP FOR 4 SECONDS 4":OFF3,4;ON2;Z2--->S2 S.S.2,/END S1, R12--->S2 S2, / EVERY 30 MINUTES PRINT THE FIRST FOUR COUNTERS UNTIL 22 HOURS ARE UP 30':ADD A;FOR I=1,1,4;WRITE C(I),16;SET C(I)=0;NEXT;IF ASX :--->S3 R13:SET L=A--->S3 S3, / 96=24*4, THAT IS 12 HOURS TIMES THE FIRST FOUR COUNTERS+8 DUMMYS, 1":TIME Y;SET A=A*4;SET A=96-A; FOR I=1,1,A;WRITE 0,16--->S4 / PRINT ZEROES WHERE THERE IS NO DATA S4, / PRINT THE FREQUENCY HISTOGRAM WHICH HAS 34 COUNTERS / THEN PRINT THE TIME STARTED AND THE TIME FINISHED 1":FOR I=5,1,38;WRITE C(I),16;NEXT;WRITE X,16;WRITE Y,16;WRITE Z,16; WRITE L,16--->S5 S5, .01":CLOSE--->STOP S.S.3,/PAUSES AND RATIO TIMES S1, R12--->S2 S2, .01":ADD Z--->SX R1--->S4 S3, .01":ADD 3--->SX R1--->S4 S4, .01":ADD 4--->SX Z1--->S5 S5, Z2--->S3 S.S.4,/HISTOGRAM OF RF FREQUENCY S1, R12:SET F=5--->S2 S2, 12":ADD F;Z4--->SX Z1:ADD CF;SET F=5--->S2 10Z4:--->S3 S3, 120":ADD F;Z4--->SX Z1:ADD CF;SET F=5--->S2 20Z4--->S4 S4, Z1:ADD CF;SET F=5--->S2 40':ADD F;Z4--->SX 3Z4:--->S5 S5, Z1:ADD CF;SET F=5--->S2 $ //////////////////////////////////////// / / / DURATION DISCRIMINATION / / FOR SUPER SKED / / / //////////////////////////////////////// /DURATION DISCRIMINATION PROGRAM /LATEST REVISION AS OF SEPT. 16,1977 /STIMULI / 1=SONALERT OR CLICKER / 2=FEEDER OPERATE / 3=FEEDER LIGHT / 4=HOUSELIGHT / 5=CUM RECORDER STEP / 6=CUM RECORDER PIP / 7=RIGHT KEY LIGHT RED / 8=CUM RECORDER EVENT PEN / 9=LEFT KEY LIGHT RED / 10=LEFT KEY LIGHT GREEN / 11=RIGHT KEY LIGHT GREEN / 12=CUM RECORDER MOTOR START /RESPONSES / R1=LEFT KEY / R2=RIGHT KEY / R3=DOOR SWITCH /COUNTERS / C1-SHORT DURATION STIMULUS, RIGHT KEY RED / C2=SHORT DURATION STIMULUS, RIGHT KEY (CORRECT ) RESPONSE / C3=SHORT DURATION STIMULUS, LEFT KEY GREEN / C4=SHORT DURATION STIMULUS, LEFT KEY (INCORRECT) RESPONSE / C5=SHORT DURATION STIMULUS, RIGHT KEY GREEN / C6=SHORT DURATION STIMULUS, RIGHT KEY (INCORRECT) RESPONSE / C7=SHORT DURATION STIMULUS, LEFT KEY RED / C8=SHORT DURATION STIMULUS, LEFT KEY (CORRECT) RESPONSE C9=LONG DURATION STIMULUS, RIGHT KEY RED / C10=LONG DURATION STIMULUS, RIGHT KEY (INCORRECT)RSPONSE / C11=LONG DURATION STIMULUS, LEFT KEY GREEN / C12=LONG DURATION STIMULUS, LEFT KEY (CORRECT) RESPONSE / C13=LONG DURATION STIMULUS, RIGHT KEY GREEN / C14=LONG DURATION STIMULUS, RIGHT KEY (CORRECT) RESPONSE / C15=LONG DURATION STIMULUS, LEFT KEY RED / C16=LONG DURATION STIMULUS, LEFT KEY (INCORRECT) RESPONSE / C17= TOTAL NUMBER OF CORRECT RESPONSES / C18=TOTAL NUMBER OF CORRECT RESPONSES TO SHORT DURATION STIMULI / C19=TOTAL NUMBER OF CORRECT RESPONSES TO LONG DURATION STIMULI / C20=TOTAL NUMBER OF RESPONSES / C21=TOTAL NUMBER OF REINFORCERS / C22= TOTAL SESSION LENGTH IN MINUTES /FOR SHORT DURATION STIMULI (1-5"), RED IS THE CORRECT RESPONSE /FOR LONG DURATION STIMULI (6-10"), GREEN IS THE CORRECT RESPONSE /Z PULSES / Z1=RESPONSE PRODUCED CLICK / Z2=CUM RECORDER CONTROL / Z3=CONTROLS SESSION TERMINATION CTRS=30 LIST A = 1",10" S.S.1, /DURATION DISCRIMINATION S1, R12:OPEN; ON 12; RAND B = A;IF V=0 [SET V=4] --->S2 S2, 8":SET B(1)=B;ON 1,4 --->S3 R1:ADD 23---->S2 R2:ADD 24 --->S2 S3, B T: OFF 1;RAND B=A; IF B(1)S5 :ON 9,11; ADD 5;ADD 7;WRITE B(1),1 ---->S6 S5, R2:ADD X;OFF 7,10;ON 1,3,5;Z1;Z2;ADD 2;ADD 17;ADD 18; ADD 20;IF X=V ;ON 2,6 ---->S11 : --->S10 R1:OFF 4,7,10;ON 1,8;ADD 4;ADD 20;Z1;Z2 --->S12 S6, R1:ADD X;OFF 9,11;ON 1,3,5;Z1;Z2;ADD 8;ADD 17;ADD 18; ADD 20;IF X=V;ON 2,6 --->S11 : --->S10 R2:OFF 4,9,11;ON 1,8;ADD 6;ADD 20;Z1;Z2 --->S12 S7, .01":Z10;WITH P=500; ON 7,10;ADD 9;ADD 11;WRITE B(1),1 --->S8 :ON 11,9;ADD 13;ADD 15;WRITE B(1),2 --->S9 S8, R1:ADD X;OFF 7,10;ON 1,3,5;Z1;Z2;ADD 12;ADD 17;ADD 19; ADD 20;IF X=V;ON2,6 ---->S11 : --->S10 R2:OFF 4,7,10;ON 1,8;Z1;Z2;ADD 10;ADD 20 ---->S12 S9, R2:ADD X;OFF 9,11; ON 1,3,5;Z1;Z2;ADD 14;ADD 17;ADD 19; ADD 20;IF X=V; ON 2,6 ---->S11 : --->S10 R1:OFF 4,9,11;ON 1,8;Z1;Z2;ADD 16;ADD 20 --->S12 S10, 1.0": OFF 3,4 ---->S2 S11, 3":OFF 2,3,4; SET X=0;Z3;ADD 21 ---->S2 S12, 8":ON 1,4;SET B(3)=B(1);ADD 29 --->S13 R1:ADD 27 --->S12 R2:ADD 28 --->S12 S13, B(3) T:OFF 1;IF B(1)S2 S.S.4, /CUM RECORDER FUNCTIONS S1, R12: ---->S2 S2, Z2: ---->S3 S3, .10":OFF 5,6,8 ---->S2 S.S.5, /SESSION TERMINATION S1, R12: ---->S2 S2, 40Z3 +150': OFF 12;WRITE C(23),6;WRITE C(24),6; WRITE C(27),6;WRITE C(28),6; WRITE 0,7 ---->S3 S3, .01":CLOSE --->STOP S.S.6, /SESSION LENGTH S1, R12: ---->S2 S2, 1': ADD 22 ---->S2 S.S.7, S1, Z10: --->S2 S2, R1:SET D=C25 +C26;WRITE D,5;IF X=V;WRITE L,11 --->S1 :WRITE L,1 --->S1 R2:SET D=C25 + C26;WRITE D,5;IF X=V;WRITE L,12 --->S1 :WRITE L,2 --->S1 .01":ADD L --->SX //////////////////////////////////////// / / /RESPONSE DURATION SHAPING / /TOLUENE SELF ADMINSTRATION / / / //////////////////////////////////////// / /TOL2.SK / /DATE: 5 SEPT 77 / / / / / / CTRS=12 / /R1 BEAM BROKEN /R2 BEAM UNBROKEN /R3 LICKOMETER IN HELMET /R4 FOOD LEVER /R5 CHAMBER H2O SPOUT CONTACT / VARIABLE CONTENTS / A=X00 SESSION START TIME (DEFAULT 1100) / B=X00 SESSION STOP TIME (DEFAULT 1500) / D=X00 STOP WATER AVAILABILITY AFTER B / V=DURATION REQUIREMENT (DEFAULT 15") /R12 START,AFTER /R13 TO SET DEFAULTS, OR / ENTER VALUES AND R13 TO SET FROM KBD /R14 FORCE SESSION START REGARDLESS OF TIME OF DAY /R15 FORCE SESSION TERMINATION REGARDLESS OF TIME OF DAY /R20 TERMINATE / /STIMULI /1 HOUSELIGHT /2 JUICE /3 FOOD /4 INHALANT /5 STEP /6 SLASH /7 EVENT /8 RESET /9 JUICE IN HELMET /10 INHALANT AVAILABLE LIGHT / / / COUNTERS ARE DOUBLE PRECISION /0 BEAM BROKEN OR INHALANT DELIVERIES /1 LICKS IN HELMET /2 LIQUID REINFORCER DELIVERIES IN HELMET /3 PELLET DELIVERIES /4 TRAY RESPONSES /5 LIQUID DELIVERIES ON FR1--R5 /6 TOTAL INHALANT DELIVERY DURATION / / PANEL ASSIGNMENTS / 1-10 OUTPUTS / 18-22 INPUTS / 32 GND / 31 +24VDC / 13 +5VDC / 11 SHIELDS / / /UNINTERRUPTED RESPONSE DURATION SHAPING PROGRAM /INCREMENTS DURATION REQUIREMENT WITH EACH REINFORCEMENT /REINFORCER DELIVERY CONTINGENT UPON A SECOND RESPONSE / S.S.1, S1, R12:ON1--->SX R13: IF V=0 [SET V=15"];SET V(1)=V; IF A=0 [SET A=1100]; IF B=0 [SET B=1500]; IF D=0 [SET D=1530];--->SX R14:ON10--->S2 R2:OFF4,7--->SX Z3:IF Y=A;ON10--->S2 S2, Z3:IF Y=B;OFF10--->S6 R15:OFF10--->S1 R1:SET V(1)=V;ON4,7;ADD 0--->S3 /EVENT PEN ON R2:OFF4,7--->SX R20:OFF1,2,3,4,5,6,7,8,9,10--->S1 S3, Z3:IF Y=B;OFF10--->S6 R15:OFF10--->S1 V(1) T--->S4 /DURATION REQUIREMENT SATISFIED R2:OFF4,7--->S2 /DURATION INTERRUPTED,EVENT PEN OFF R3:Z6;ON5;Z1--->SX /STEP ON LICK R20:OFF1,2,3,4,5,6,7,8,9,10--->S1 S4, Z3:IF Y=B;OFF10--->S6 R15:OFF10--->S1 R2:OFF4,7--->S2 /EVENT PEN OFF R20:OFF1,2,3,4,5,6,7,8,9,10--->S1 R3:Z6;ADD 2;ON9,6,5;Z1--->S5 /JUICE ON,RECORDER SLASH,STEP S5, Z3:IF Y=B;OFF6,9,10--->S6 R15:OFF10--->S1 R20:OFF1,2,3,4,5,6,7,8,9,10--->S1 R2:OFF4,7--->SX 1":OFF9,6;IF VS2 /TERMINATE JUICE,INCREMENT DURATION / /REMOVE THESE TWO STATES FOR 24 HR AVAILABILITY /AND THE Z3 TRANSITION LINES IN S.S.1; /INSURE TRANSITION TO STATE 2 / S6, Z3:IF Y=A;ON10--->S2 R14:ON10--->S2 R1:ADD 0--->S7 R20:OFF1,2,3,4,5,6,7,8,9,10--->S1 S7, Z3:IF Y=A;ON10--->S2 R14:ON10--->S2 R2:--->S6 R3:Z6--->SX R20:OFF1,2,3,4,5,6,7,8,9,10--->S1 / / S.S.2, S1, Z1--->S2 S2, .04":OFF5,8--->S1 /TURN OFF STEP AND RESET AFTER ONE SHOT / / / GATING AND Z PULSE EVENTS WITHOUT STATE TRANSITIONS / / S.S.3, S1, / TURN ON SESSION LIGHT AT 5 AM Z3:IF Y=500;ON1--->SX / COUNT LICKS IN HELMET Z6:ADD 1--->SX //ACCUMULATE INHALANT DURATION .01" :&S.S.1=3;ADD 6--->SX :&S.S.1=4:ADD 6--->SX :&S.S.1=7:ADD 6--->SX / / / /CRF FOR LICKS (R5) / AVAILABLE FROM B TO D (TIME OF DAY) / TO CHANGE TO 24 HR OPERATION, REPLACE 1ST Z3 WITH R12,AND / DELETE 2ND Z3 CHECK / S.S.4, S1, / R12:--->S2 //24 HR AVAILABILITY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Z3: IF Y=B;ON2;--->S3 S2, Z3: IF Y=D--->S1 R5:ADD 5;ON2,5;Z1--->S3 /JUICE ON,RECORDER STEP R20:OFF1,2,3,4,5,6,7,8,9,10--->S1 S3, 1":OFF2,6--->S2 R20:OFF1,2,3,4,5,6,7,8,9,10--->S1 / /PELLET DELIVERIES CONTINGENT ON TRAY PULLS / 9/16/77 1700 LEVER NOT REINFORCED WHEN HEAD IN HELMET / S.S.7, S1, R12:--->S2 S2, R4:ADD 4--->SX 10R4:&S.S.1=1:ADD 3;ON3--->S3 /29 SEPT DAMN!!! 10R4:&S.S.1=2:ADD 3;ON3--->S3 / GATE FOR HEAD OUT 10R4:&S.S.1=6:ADD 3;ON3--->S3 S3, .10":OFF3--->S4 S4, 5":--->S2 / / / / / /RECORD /SIMULATES PRINTOUT COUNTER /30 MINUTE INTERVAL /11 COUNTERS (0-10), AND TIME OF DAY IN COUNTER 12 (11) / / S.S.8, S1, R12:OPEN--->S2 S2, 1":TIME Y; IF Y(2)=30 ;Z3--->S3 :IF Y(2)=0 ;Z3--->S3 S3, 30':TIME Y;SET C(11)=Y;ON8;Z3;Z1; FOR I=0,1,11;WRITE C(I),16;SET C(I)=0;NEXT; IF Y(1)=21;OFF1;--->SX R20:WRITE 0,7--->S4 S4, .01":CLOSE--->S1 / $
    0.00
    0 votes
    204

    Sleep programming language

    • Language Paradigms: Procedural programming
    • Influenced By: Objective-C
    Sleep (as of Simple Language for Environment Extension Purposes) is a procedural scripting language inspired by Perl and Objective-C. The only known implementation of the language is written in Java and is intended for embedding into existing Java applications to provide scripting services. The Sleep Java API allows the language to be extended with new constructs, operators, functions, and variable containers, making it easy to integrate it into applications. Sleep is currently utilized in the IRC client jIRCii and the IRC bot SleepyBot. Sleep first version appeared in a week-end of coding in April 2002. Since then Sleep has been developed in parallel with a Java IRC Client which heavily uses its features called jIRCii. The current stable 2.1 version is available since July 2008. Sleep is very easy to learn in its basic form, and anyone familiar with Perl or PHP will feel right at home. In addition to being embeddable, Sleep can also be used stand-alone on the command line or using an interactive shell. Sleep has native support for three widely different data types: scalars, arrays, and hashes. Scalars are prefixed with a dollar sign ($), arrays with 'at'-signs (@) and hashes with
    0.00
    0 votes
    205
    Smalltalk

    Smalltalk

    • Language Paradigms: Object-oriented programming
    • Influenced: Ruby
    • Influenced By: Lisp
    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 "human–computer symbiosis." It was designed and created in part for educational use, more so for constructionist learning, at the Learning Research Group (LRG) 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. 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. There are a large number of Smalltalk variants. The unqualified word Smalltalk is often used to indicate the Smalltalk-80 language, the first version to be made publicly available and created in 1980. Smalltalk was the product of research led by Alan Kay at Xerox Palo Alto Research Center (PARC); Alan Kay designed most of the early Smalltalk versions, which Dan Ingalls implemented. The first version, known as Smalltalk-71, was created by Ingalls in a few mornings on a bet that
    0.00
    0 votes
    206

    SNOBOL

    • Language Paradigms: Functional programming
    • Influenced: AWK
    • Influenced By: COMIT
    SNOBOL (StriNg Oriented and symBOlic Language) is a series of computer programming languages developed between 1962 and 1967 at AT&T Bell Laboratories by David J. Farber, Ralph E. Griswold and Ivan P. Polonsky, culminating in SNOBOL4. It was one of a number of text-string-oriented languages developed during the 1950s and 1960s; others included COMIT and TRAC. SNOBOL4 stands apart from most programming languages by having patterns as a first-class data type (i.e. a data type whose values can be manipulated in all ways permitted to any other data type in the programming language) and by providing operators for pattern concatenation and alternation. Strings generated during execution can be treated as programs and executed. SNOBOL4 was quite widely taught in larger US universities in the late 1960s and early 1970s and was widely used in the 1970s and 1980s as a text manipulation language in the humanities. In recent years its use has faded as newer languages such as AWK and Perl have made string manipulation by means of regular expressions fashionable. SNOBOL4 patterns subsume BNF grammars, which are equivalent to context-free grammars and more powerful than regular expressions. The
    0.00
    0 votes
    207

    SP/k

    • Language Paradigms: Structured programming
    • Influenced: Turing programming language
    • Influenced By: PL/I
    SP/k is a programming language developed circa 1974 by R.C. Holt, D.B. Wortman, D.T. Barnard and J.R. Cordy as a subset of the PL/I programming language designed for teaching programming. It was used for about a decade at over 40 universities, schools, and research laboratories in Canada and the United States. SP/k was one of the first languages specifically designed to encourage structured programming. The features of SP/k were chosen to encourage structured problem solving by computers, to make the language easy to learn and use, to eliminate confusing and redundant constructs, and to make the language easy to compile.The resulting language was suitable for introducing programming concepts used in various applications, including business data processing, scientific calculations and non-numeric computation. SP/k is actually a sequence of language subsets called SP/1, SP/2, … SP/8. Each subset introduces new programming language constructs while retaining all the constructs of preceding subsets, forming a stepwise system for teaching computer programming. Each subset is precisely defined and self-contained, and can be learned or implemented without the following subsets. This
    0.00
    0 votes
    208

    SPARK programming language

    • Language Paradigms: Multi-paradigm programming language
    • Influenced By: Ada
    SPARK is a formally-defined computer programming language based on the Ada programming language, intended to be secure and to support the development of high integrity software used in applications and systems where predictable and highly reliable operation is essential either for reasons of safety (e.g., avionics in aircraft/spacecraft, or medical systems and process control software in nuclear powerplants) or for business integrity (for example financial software for banking and insurance companies). There are two versions of the SPARK language; one based on Ada 83, and the other on Ada 95. The SPARK language consists of a highly restricted, well-defined subset of the Ada language that uses annotated meta information (in the form of Ada comments) that describe desired component behavior and individual runtime requirements, thereby optionally facilitating mandatory use of Design by Contract principles to accurately formalize and validate expected runtime behavior. Because the annotations are in commentary, SPARK programs are generally also valid Ada programs and can be compiled by an appropriate Ada compiler. The most recent revision of the implementation, RavenSPARK, includes the
    0.00
    0 votes
    209
    Spin

    Spin

    Spin is a multitasking object-oriented high level computer programming language created by Parallax's Chip Gracey, (Who also designed the Propeller microcontroller it runs on) for their line of Propeller microcontrollers. Spin code is written on "the propeller tool". A GUI oriented software development platform which is written for Windows XP. This compiler converts the Spin code into bytecodes that can be loaded, (with the same tool) into the main 32KB RAM, (and optionally into the serial boot FLASH EEPROM) of the Propeller chip. After booting the propeller a bytecode interpreter is copied from the built in ROM into the 2K RAM of the primary COG. And then this COG will start interpreting the bytecodes in the main 32KB RAM. More than one copy of the bytecode interpreter can run in other COGs, so several Spin code threads can run simultaneously. Within a the general Spin code program assembler code program(s) can be "inline" inserted. These assembler program(s) will then run on their own COG's. Just like Python Spin uses indentation/whitespace, rather than curly braces or keywords, to delimit statement blocks. The syntax of Spin can be broken down into blocks. The blocks are as
    0.00
    0 votes
    210
    SQL

    SQL

    • Language Paradigms: Multi-paradigm programming language
    • Influenced: Windows PowerShell
    • Influenced By: Datalog
    SQL ( /ˈɛs kjuː ˈɛl/ "S-Q-L"; or "sequel"; or Structured Query Language) is a special-purpose programming language designed for managing data in relational database management systems (RDBMS). Originally based upon relational algebra and tuple relational calculus, its scope includes data insert, query, update and delete, schema creation and modification, and data access control. SQL was one of the first commercial languages for Edgar F. Codd's relational model, as described in his influential 1970 paper, "A Relational Model of Data for Large Shared Data Banks". Despite not adhering to the relational model as described by Codd, it became the most widely used database language. Although SQL is often described as, and to a great extent is, a declarative language, it also includes procedural elements. SQL became a standard of the American National Standards Institute (ANSI) in 1986, and of the International Organization for Standards (ISO) in 1987. Since then, the standard has been enhanced several times with added features. However, issues of SQL code portability between major RDBMS products still exist due to lack of full compliance with, or different interpretations of, the
    0.00
    0 votes
    211
    Squeak

    Squeak

    • Language Paradigms: Object-oriented programming
    • Influenced: EToys
    • Influenced By: Smalltalk-80
    The Squeak programming language is a dialect of Smalltalk. It is object-oriented, class-based and reflective. It was derived directly from Smalltalk-80 by a group at Apple Computer that included some of the original Smalltalk-80 developers. Its development was continued by the same group at Walt Disney Imagineering, where it was intended for use in internal Disney projects. Squeak is available for many platforms, and programs produced on one platform run bit-identical on all other platforms. The Squeak system includes code for generating a new version of the virtual machine (VM) on which it runs. It also includes a VM simulator written in Squeak itself. For this reason, it is easily ported. Dan Ingalls, an important contributor to the Squeak project, wrote the paper upon which Squeak is built and constructed the architecture for five generations of the Smalltalk language. Squeak incorporates many of the elements Alan Kay proposed in the Dynabook concept, which he formulated in the 1960s. Kay is an important contributor to the Squeak project. Squeak includes a number of user interface frameworks: Many Squeak contributors collaborate on Open Cobalt, a free and open source virtual
    0.00
    0 votes
    212

    StarLogo

    • Language Paradigms: Multi-agent system
    • Influenced: EToys
    • Influenced By: Logo
    StarLogo is an agent-based simulation language developed by Mitchel Resnick, Eric Klopfer, and others at MIT Media Lab and MIT Teacher Education Program in Massachusetts. It is an extension of the Logo programming language, a dialect of Lisp. Designed for education, StarLogo can be used by students to model the behavior of decentralized systems. The first StarLogo ran on a Connection Machine 2 parallel computer. A subsequent version ran on Macintosh computers; this version became known later as MacStarLogo (and now is called MacStarLogo Classic). The current StarLogo is written in Java and works on most computers. StarLogo is also available in a version called OpenStarLogo. The source code for OpenStarLogo is available online, although the license under which it is released is not an open source license according to the Open Source Definition, because of restrictions on the commercial use of the code. StarLogo TNG (The Next Generation) version 1.0 was released in July 2008. It provides a 3D world using OpenGL graphics and a block-based graphical language to increase ease of use and learnability. It is written in C and Java. StarLogo TNG uses "blocks" to put together like puzzle
    0.00
    0 votes
    213
    StepTalk

    StepTalk

    StepTalk is the official GNUstep scripting framework that represents separate scriptable servers or applications as a single object environment. It is meant to be independent of the programming language used; its default language is Smalltalk on top of the Objective-C runtime. StepTalk was ported to Mac OS X. The goal of StepTalk is to provide an environment for gluing applications together and to provide a framework for communication between users and objects in the applications. Other major goals are: The default scripting language in StepTalk is Smalltalk. This is because Smalltalk is a very simple language and is easy to learn. There are just a few basic principles that the user has to know to be able to use the language and it is close to the natural language. Smalltalk uses a similar approach to that of Objective-C, the language used in GNUstep itself. StepTalk works on any platform that GNUstep works on. Ports to native Mac OS X Cocoa framework are being developed by various contributors.
    0.00
    0 votes
    214

    Strongtalk

    • Influenced: Slate programming language
    Strongtalk is a Smalltalk environment with optional static typing support. Strongtalk can make some compile time checks, and offer "stronger" type-safety guarantees; this is the source of its name. It is non-commercial, though it was originally a commercial project developed by a small start-up company called LongView Technologies (trading as Animorphic Systems). Dave Griswold wanted to use Smalltalk more extensively, but the existing implementations weren't sufficient for his needs. He wanted to improve the performance, add type-checking, and use native UI widgets. His efforts resulted in the 1993 paper he co-authored with Gilad Bracha. This version was based on adding type-checking to the ParcPlace Systems implementation of Smalltalk; an implementation that started from scratch would gain a better typing system. He became interested in the improvements that the Self team had achieved, and envisioned the same techniques used to improve Smalltalk. Urs Hölzle, who worked on the powerful Self compiler, spoke with Griswold about implementing the same "type feedback" in a Smalltalk compiler. Griswold, Hölzle, Lars Bak and others formed a small company (LongView Technologies, doing
    0.00
    0 votes
    215

    Subtext

    • Language Paradigms: Example Centric Programming
    Subtext is a moderately visual programming language and environment, for writing application software. It is an experimental, research attempt to develop a new programming model, called Example Centric Programming, by treating copied blocks as first class prototypes, for program structure. It uses live text, similar to what occurs in spreadsheets as users update cells, for frequent feedback. It is intended to eventually be developed enough to become a practical language for daily use. It is planned to be open software; the license is not yet determined. Subtext was created by Jonathan Edwards who submitted a paper on the language to OOPSLA. It was accepted as part of the 2005 conference. Early video previews of the Subtext environment were released circa 2006, which demonstrated the semantics of Subtext programs, and the close integration with the Subtex environment and runtime. Subtext programs are declared and manipulated (or mutated) by adding and linking elements of various types to a syntax tree, and entering in values or names as necessary, as opposed to typing out textual programs. Due to the design of the Subtext language and environment, there is no distinction between a
    0.00
    0 votes
    216

    SuperCollider programming language

    • Language Paradigms: Object-oriented programming
    • Influenced By: J
    SuperCollider is an environment and programming language originally released in 1996 by James McCartney for real-time audio synthesis and algorithmic composition. Since then it has been evolving into a system used and further developed by both scientists and artists working with sound. It is an efficient and expressive dynamic programming language providing a framework for acoustic research, algorithmic music, and interactive programming. Released under the terms of the GNU General Public License in 2002, SuperCollider is free software. The most recent major release (3.5) was released in March 2012. Starting with version 3, the SuperCollider environment has been split into two components: a server, scsynth; and a client, sclang. These components communicate using OSC (Open Sound Control). SC Language combines the object oriented structure of Smalltalk and features from functional programming languages with a C family syntax. The SC Server application supports a simple C plugin API making it easy to write efficient sound algorithms (unit generators), which can then be combined into graphs of calculations. Because all external control in the server happens via OSC, it is possible to
    0.00
    0 votes
    217
    SuperTalk

    SuperTalk

    • Language Paradigms: Event driven programming language
    • Influenced: Runtime Revolution
    • Influenced By: HyperTalk
    SuperTalk is the scripting language used in SuperCard. SuperTalk is a descendant of HyperTalk. One of the most powerful features SuperCard adds to the HyperTalk language is user properties. Where HyperTalk had a fixed set of properties on its objects, SuperCard scripters can use the define property propName command to add new properties to buttons and fields. These properties can contain arbitrary text (including numbers and object references, which are also represented using text in xTalks), and even dumps of entire files. SuperTalk provides several variations on HyperTalk's answer and answer file commands, which let one choose several items from a list, choose an icon from all available icons, pick a MIDI instrument to play sound with, or choose a file of a supported image format (including a preview), or disks and folders. Different from HyperTalk's dialogs, SuperTalk answer and ask dialogs do not all resize dynamically to hold more text. However, since SuperCard allows having cards (i.e. "pages") in windows of arbitrary types, one can easily build one's own dialog that is large enough. SuperTalk also has an alert command that displays standard system alert windows and sheets,
    0.00
    0 votes
    218

    Tcl

    • Language Paradigms: Functional programming
    • Influenced: Windows PowerShell
    • Influenced By: AWK
    Tcl (originally from Tool Command Language, but conventionally spelled "Tcl" rather than "TCL"; pronounced as "tickle" or "tee-see-ell") is a scripting language created by John Ousterhout. Originally "born out of frustration", according to the author, with programmers devising their own languages intended to be embedded into applications, Tcl gained acceptance on its own. It is commonly used for rapid prototyping, scripted applications, GUIs and testing. Tcl is used on embedded systems platforms, both in its full form and in several other small-footprint versions. The combination of Tcl and the Tk GUI toolkit is referred to as Tcl/Tk. The Tcl programming language was created in the spring of 1988 by John Ousterhout while working at the University of California, Berkeley. Tcl conferences and workshops are held in both the United States and Europe. Tcl's features include Tcl did not originally have object oriented (OO) syntax (8.6 provides an OO system in Tcl core), so OO functionality was provided by extension packages, such as incr Tcl and XOTcl. Even purely scripted OO packages exist, such as Snit and STOOOP (simple tcl-only object-oriented programming). Safe-Tcl is a subset of
    0.00
    0 votes
    219

    TELCOMP

    • Influenced: MUMPS
    • Influenced By: JOSS
    TELCOMP was a programming language developed at Bolt, Beranek and Newman (BBN) in about 1965 and in use until at least 1974. It was an interactive, conversational language based on JOSS, developed by BBN after Cliff Shaw from RAND visited the labs in 1964 as part of the NIH survey. It was first implemented on the PDP-1 and was used to provide a commercial time sharing service by BBN in the Boston area and later by Time Sharing Ltd. in the United Kingdom. In 1996, Leo Beranek said "We even developed a programming language called TELCOMP that to this day, some say was better than the programming language that the industry adopted, namely BASIC." There were at least three versions: TELCOMP I, TELCOMP II, and TELCOMP III. TELCOMP II was implemented on the PDP-7 and TELCOMP III on the PDP-10, running on DEC 's TOPS-10 operating system or on BBN's own TENEX operating system. TELCOMP programs were normally input via a paper tape reader on a Teletype Model 33, which would be connected to a PDP via a modem and acoustic telephone line. Data could be read from the paper tape reader or from the Teletype keyboard. Output was either printed to the Teletype or sent to the paper tape punch. Early
    0.00
    0 votes
    220
    TeX

    TeX

    • Influenced: Curl programming language
    TeX ( /ˈtɛx/ as in Greek, but often pronounced /ˈtɛk/ in English) is a typesetting system designed and mostly written by Donald Knuth and released in 1978. Within the typesetting system, its name is formatted as TeX. Together with the Metafont language for font description and the Computer Modern family of typefaces, TeX was designed with two main goals in mind: to allow anybody to produce high-quality books using a reasonable amount of effort, and to provide a system that would give exactly the same results on all computers, now and in the future. TeX is a popular means by which to typeset complex mathematical formulae; it has been noted as one of the most sophisticated digital typographical systems in the world. TeX is popular in academia, especially in mathematics, computer science, economics, engineering, physics, statistics, and quantitative psychology. It has largely displaced Unix troff, the other favored formatter, in many Unix installations, which use both for different purposes. It is now also being used for many other typesetting tasks, especially in the form of LaTeX and other template packages. The widely used MIME type for TeX is application/x-tex. TeX is free
    0.00
    0 votes
    221

    ToonTalk computer programming language

    • Influenced By: Janus
    ToonTalk is a computer programming system intended to be programmed by children. The "Toon" part stands for cartoon. The system's presentation is in the form of animated characters, including robots that can be trained by example. It is one of the few successful implementations outside academia of the concurrent constraint logic programming paradigm. It was created by Kenneth M. Kahn in 1995, and implemented as part of the ToonTalk IDE, a software package distributed worldwide between 1996 and 2009. Since 2009, its specification is scholarly published and its implementation is freely available. Beyond its life as a commercial product, ToonTalk evolved via significant academic use in various research projects, notably at the London Knowledge Lab and the Institute of Education - projects Playground and WebLabs, which involved research partners from Cambridge (Logotron), Portugal (Cnotinfor and the University of Lisbon), Sweden (Royal Institute of Technology), Slovakia (Comenius University), Bulgaria (Sofia University), Cyprus (University of Cyprus), and Italy (Institute for Educational Technology of the Consiglio Nazionale delle Ricerche). It was also source of academic interest in
    0.00
    0 votes
    222

    True BASIC

    True BASIC is a variant of the BASIC programming language descended from Dartmouth BASIC — the original BASIC — invented by college professors John G. Kemeny and Thomas E. Kurtz. When True BASIC appeared on the market in 1985, the BASIC language was widely used on home computers, but with little standardization. Each manufacturer implemented extensions to the language to support features of their hardware. Initially based on Dartmouth BASIC 7 — otherwise known as ANSI BASIC — TrueBASIC implemented a number of new features over GW-BASIC, and allowed the user a redefinable 16-color, 640×480 pixel backdrop for program editing. True BASIC introduced new functions for graphics primitives like plot, plot area, flood, etc. It also was the first to provide a method for saving a portion of the screen and blitting it elsewhere, but had no proper buffering implementation. Being a structured programming implementation of the language, it dispensed with the need for line numbers and GOTO statements, although these earlier features can still be used. Use of LET for value assignment became optional. It also allowed for descriptive variable names longer than a single letter plus a single digit.
    0.00
    0 votes
    223

    Turbo Pascal

    • Language Paradigms: Object-oriented programming
    Turbo Pascal is a software development system that includes a compiler and an integrated development environment (IDE) for the Pascal programming language running on CP/M, CP/M-86, and DOS, developed by Borland under Philippe Kahn's leadership. From version 6 both a lower-priced Turbo Pascal and more expensive Borland Pascal were produced; Borland Pascal had more libraries and standard library source code. The name Borland Pascal is also used more generically for Borland's dialect of Pascal. Borland has released three old versions of Turbo Pascal free of charge because of their historical interest: the original Turbo Pascal (now known as 1.0), and versions 3.02 and 5.5 for DOS. Philippe Kahn first saw an opportunity for Borland, his newly formed software company, in the field of programming tools. Historically, the vast majority of programmers saw their workflow in terms of the edit/compile/link cycle, with separate tools dedicated to each task. Programmers wrote source code and entered it using a text editor, a compiler then created object code from source (often requiring multiple passes), and a linker combined object code with runtime libraries to produce an executable program.
    0.00
    0 votes
    224

    Turing programming language

    • Language Paradigms: Object-oriented programming
    • Influenced: Object-Oriented Turing
    • Influenced By: Pascal
    Turing is a Pascal-like programming language developed in 1982 by Ric Holt and James Cordy, then of University of Toronto, Canada. Turing is a descendant of Euclid, Pascal and SP/k that features a clean syntax and precise machine-independent semantics. Named after British computer scientist Alan Turing, Turing is used primarily as a teaching language at the high school and university level. Two other versions exist, Object-Oriented Turing and Turing Plus, a systems programming variant. In September 2001, "Object Oriented Turing" was renamed "Turing" and the original Turing was renamed "Classic Turing". Turing is no longer supported by Holt Software Associates in Toronto. Currently, Microsoft Windows is the only supported platform. Turing is widely used in high schools in Ontario as an introduction to programming. On November 28, 2007, Turing, which was previously a commercial programming language, became freeware, available to download from the developer's website free of charge for personal, commercial, and educational use. The makers of Turing, Holt Software Associates, have since ceased operations. It is unclear whether Turing is still in development, but there have been no new
    0.00
    0 votes
    225

    TUTOR programming language

    • Language Paradigms: Imperative programming
    TUTOR (also known as PLATO Author Language) is a programming language developed for use on the PLATO system at the University of Illinois at Urbana-Champaign around 1965. TUTOR was initially designed by Paul Tenczar for use in computer assisted instruction (CAI) and computer managed instruction (CMI) (in computer programs called "lessons") and has many features for that purpose. For example, TUTOR has powerful answer-parsing and answer-judging commands, graphics, and features to simplify handling student records and statistics by instructors. TUTOR's flexibility, in combination with PLATO's computational power (running on what was considered a supercomputer in 1972), also made it suitable for the creation of many non-educational lessons—that is, games—including flight simulators, war games, dungeon style multiplayer role-playing games, card games, word games, and Medical lesson games such as Bugs and Drugs (BND). TUTOR was originally developed as a special purpose authoring language for designing instructional lessons, and its evolution into a general purpose programming language was unplanned. The name TUTOR was first applied to the authoring language of the PLATO system in the
    0.00
    0 votes
    226

    UCSD Pascal

    • Influenced: Java
    • Influenced By: Pascal
    UCSD Pascal was a Pascal programming language system that ran on the UCSD p-System, a portable, highly machine-independent operating system. UCSD Pascal was first released in 1978. It was developed at the University of California, San Diego (UCSD). UCSD Pascal was developed at The University of California, San Diego Institute for Information Systems in 1978 to provide students with a common operating system that could run on any of the then available microcomputers as well as campus DEC PDP-11 minicomputers. UCSD p-System (Version IV, supplied by SofTech) was one of three operating systems (along with PC-DOS and CP/M-86) that IBM offered for its original IBM PC; but the p-System never sold very well for the IBM PC, mainly because of a lack of applications and because it was more expensive than the other choices. Previously, IBM had offered the UCSD p-System as an option for Displaywriter, an 8086-based dedicated word processing machine (not to be confused with IBM's DisplayWrite word processing software.) (The Displaywriter's native operating system had been developed completely internally and was not opened for end-user programming.) Notable extensions to standard Pascal include
    0.00
    0 votes
    227
    Unified Modeling Language

    Unified Modeling Language

    Unified Modeling Language (UML) is a standardized general-purpose modeling language in the field of object-oriented software engineering. The standard is managed, and was created, by the Object Management Group. It was first added to the list of OMG adopted technologies in 1997, and has since become the industry standard for modeling software-intensive systems. UML includes a set of graphic notation techniques to create visual models of object-oriented software-intensive systems. UML is used to specify, visualize, modify, construct and document the artifacts of an object-oriented software-intensive system under development. UML offers a standard way to visualize a system's architectural blueprints, including elements such as: UML combines techniques from data modeling (entity relationship diagrams), business modeling (work flows), object modeling, and component modeling. It can be used with all processes, throughout the software development life cycle, and across different implementation technologies. UML has synthesized the notations of the Booch method, the Object-modeling technique (OMT) and Object-oriented software engineering (OOSE) by fusing them into a single, common and
    0.00
    0 votes
    228
    Universal Systems Language

    Universal Systems Language

    Unlike traditional languages, the Universal Systems Language (USL) is based on a preventative instead of a curative paradigm. Based on systems theory, to a great extent derived from lessons learned from the Apollo onboard flight software effort, USL has evolved over several decades (originally called 001AXES) and taken on multiple dimensions as a Systems Engineering approach. USL is a completely different way to think about systems: instead of object-oriented and model-driven systems, the designer thinks in terms of system-oriented objects (SOOs) and system-driven models. Much of what seems counterintuitive with traditional approaches, which tend to be software-centric, becomes intuitive with this systems-centric approach. USL was created for designing systems with significantly increased reliability, higher productivity, and lower risk. It was designed with the following objectives in mind: USL together with its automation, can address these objectives because of the systems theory that forms its foundations. It also takes roots from other sources–other real-world systems and formal linguistics, methods, and object technologies. USL had as its origin its creators' study of the
    0.00
    0 votes
    229

    VBScript

    • Language Paradigms: Interpreted language
    • Influenced: Windows PowerShell
    • Influenced By: Visual Basic
    VBScript (Visual Basic Scripting Edition) is an Active Scripting language developed by Microsoft that is modeled on Visual Basic. It is designed as a “lightweight” language with a fast interpreter for use in a wide variety of Microsoft environments. VBScript uses the Component Object Model to access elements of the environment within which it is running; for example, the FileSystemObject (FSO) is used to create, read, update and delete files. VBScript has been installed by default in every desktop release of Microsoft Windows since Windows 98; in Windows Server since Windows NT 4.0 Option Pack; and optionally with Windows CE (depending on the device it is installed on). A VBScript script must be executed within a host environment, of which there are several provided with Microsoft Windows, including: Windows Script Host (WSH), Internet Explorer (IE), and Internet Information Services (IIS). Additionally, the VBScript hosting environment is embeddable in other programs, through technologies such as the Microsoft Script Control (msscript.ocx). VBScript began as part of the Microsoft Windows Script Technologies, launched in 1996. This technology (which also included JScript) was
    0.00
    0 votes
    230
    VHSIC Hardware Description Language

    VHSIC Hardware Description Language

    • Influenced By: Ada
    VHDL (VHSIC hardware description language) is a hardware description language used in electronic design automation to describe digital and mixed-signal systems such as field-programmable gate arrays and integrated circuits. VHDL was originally developed at the behest of the U.S Department of Defense in order to document the behavior of the ASICs that supplier companies were including in equipment. That is to say, VHDL was developed as an alternative to huge, complex manuals which were subject to implementation-specific details. The idea of being able to simulate this documentation was so obviously attractive that logic simulators were developed that could read the VHDL files. The next step was the development of logic synthesis tools that read the VHDL, and output a definition of the physical implementation of the circuit. Due to the Department of Defense requiring as much of the syntax as possible to be based on Ada, in order to avoid re-inventing concepts that had already been thoroughly tested in the development of Ada, VHDL borrows heavily from the Ada programming language in both concepts and syntax. The initial version of VHDL, designed to IEEE standard 1076-1987, included a
    0.00
    0 votes
    231

    Visual Basic

    • Language Paradigms: Object-oriented programming
    • Influenced: Gambas
    • Influenced By: BASIC
    Visual Basic (VB) is a third-generation event-driven programming language and integrated development environment (IDE) from Microsoft for its COM programming model first released in 1991. Visual Basic is designed to be relatively easy to learn and use. Visual Basic was derived from BASIC and enables the rapid application development (RAD) of graphical user interface (GUI) applications, access to databases using Data Access Objects, Remote Data Objects, or ActiveX Data Objects, and creation of ActiveX controls and objects. Scripting languages such as VBA and VBScript are syntactically similar to Visual Basic, but perform differently. A programmer can put together an application using the components provided with Visual Basic itself. Programs written in Visual Basic can also use the Windows API, but doing so requires external function declarations. Though the program has received criticism for its perceived faults, from version 3 Visual Basic was a runaway commercial success, and many companies offered third party controls greatly extending its functionality. The final release was version 6 in 1998. Microsoft's extended support ended in March 2008 and the designated successor was
    0.00
    0 votes
    232

    Visual Basic .NET

    • Language Paradigms: Object-oriented programming
    • Influenced By: BASIC
    Visual Basic .NET (VB.NET), is an object-oriented computer programming language that can be viewed as an evolution of the classic Visual Basic (VB), which is implemented on the .NET Framework. Microsoft currently supplies two main editions of IDEs for developing in Visual Basic: Microsoft Visual Studio 2010, which is commercial software and Visual Basic Express Edition 2010, which is free of charge. The command-line compiler, VBC.EXE, is installed as part of the freeware .NET Framework SDK. Mono also includes a command-line VB.NET compiler. There are 5 versions of Visual Basic .NET implemented by the Visual Basic team. The first version of Visual Basic .NET, which runs on .NET framework 1.0. The most important feature is Managed code, which contrasts with Visual Basic 6.0 and before. Visual Basic .NET 2003 was released with version 1.1 of the .NET Framework. New features included support for the .NET Compact Framework and a better VB upgrade wizard. Improvements were also made to the performance and reliability of the .NET IDE (particularly the background compiler) and runtime. In addition, Visual Basic .NET 2003 was available in the Visual Studio.NET Academic Edition (VS03AE).
    0.00
    0 votes
    233

    Visual FoxPro

    • Language Paradigms: Object-oriented programming
    • Influenced By: dBase
    Visual FoxPro is a data-centric object-oriented and procedural programming language produced by Microsoft. It is derived from FoxPro (originally known as FoxBASE) which was developed by Fox Software beginning in 1984. Fox Technologies merged with Microsoft in 1992, after which the software acquired further features and the prefix "Visual". The last version of FoxPro (2.6) worked under Mac OS, DOS, Windows, and Unix: Visual FoxPro 3.0, the first "Visual" version, reduced platform support to only Mac and Windows, and later versions were Windows-only. The current version of Visual FoxPro is COM-based and Microsoft has stated that they do not intend to create a Microsoft .NET version. FoxPro originated as a member of the class of languages commonly referred to as "xBase" languages, which have syntax based on the dBase programming language. Other members of the xBase language family include Clipper and Recital. (A history of the early years of xBase can be found in the dBase article.) Visual FoxPro, commonly abbreviated as VFP, is tightly integrated with its own relational database engine, which extends FoxPro's xBase capabilities to support SQL query and data manipulation. Unlike most
    0.00
    0 votes
    234
    Visual Prolog

    Visual Prolog

    • Language Paradigms: Object-oriented programming
    • Influenced By: Prolog
    Visual Prolog, also formerly known as PDC Prolog and Turbo Prolog, is a strongly typed object-oriented extension of Prolog. As Turbo Prolog it was marketed by Borland, but it is now developed and marketed by the Danish firm Prolog Development Center (PDC) that originally developed it. Visual Prolog can build Microsoft Windows GUI-applications, console applications, DLLs (dynamic link libraries), and CGI-programs. It can also link to COM components and to databases by means of ODBC. Visual Prolog is compiled rather than interpreted, as is traditional for logic languages. This provides the important improvement of converting traditional Prolog-typical run-time errors to compiler warnings, which ensures a better robustness of the finished applications. The core of Visual Prolog are Horn clauses, pattern matching and controlled non-determinism like in traditional Prolog, but unlike traditional Prolog, Visual Prolog has always been strongly and statically typed. Since version 6.0 the language has been fully object-oriented. Version 7.0 introduced parametric polymorphism. Version 7.2 introduced anonymous predicates (a logical pendant to anonymous functions) and namespaces (see also New
    0.00
    0 votes
    235

    Water programming language

    • Language Paradigms: Object-oriented programming
    Water is a computer programming language which is object-oriented, and prototype-based. It is intended for rapid prototyping of XML Web services and applications. It uses a variant of XML syntax termed ConciseXML. Generally, common practice in creating Web services is to use multiple languages, of two main types: (1) markup languages, such as HTML, CSS, XML, etc., and (2) more general programming languages such as JavaScript, Java, PHP, ASP, etc. Water can combine the functions of all of these, and more, in one lower cost, and easier to maintain language. Water's main design goal is to be powerful while remaining simple, by reducing the number of languages, protocols, interfaces, and translations needed to run web services; to eliminate multiple code-generating layers of programs, and the need for many special-purpose languages. It runs within a Java Virtual Machine, and thus can use Java libraries. It also runs within a run time environment called "Steam Engine", and is developed with an integrated development environment named "Steam IDE". Presently, Water is interpreted. It supports the novel "execution kinds" concept, aiding metaprogramming. The designers claim that Water is as
    0.00
    0 votes
    236
    Whitespace

    Whitespace

    Whitespace is a programming language developed by Edwin Brady and Chris Morris at the University of Durham (also developers of the Kaya programming language). It was released on 1 April 2003 (April Fool's Day). Its name is a reference to whitespace characters. Unlike most programming languages, which ignore or assign little meaning to most whitespace characters, the Whitespace interpreter ignores any non-whitespace characters. Only spaces, tabs and linefeeds have meaning. An interesting consequence of this property is that a Whitespace program can easily be contained within the whitespace characters of a program written in another language, except possibly in languages which depend on spaces for syntax validity such as Python, making the text a polyglot. The language itself is an imperative stack-based language. The virtual machine on which the programs run has a stack and a heap. The programmer is free to push arbitrary-width integers onto the stack (currently there is no implementation of floating point numbers) and can also access the heap as a permanent store for variables and data structures. Whitespace was created by Edwin Brady and Chris Morris in 2002. Slashdot gave a
    0.00
    0 votes
    237
    Whizbase

    Whizbase

    WBSP, (WhizBase Server Pages) is a general-purpose scripting tool (hypertext preprocessor) for Web development and can be embedded into HTML, XHTML, XML, RTF, ASCII, JavaScript, VBScript and any other text based file format. Its syntax is different from any programming language like C, Java, Perl, VB, and also form other hypertext preprocessors like PHP or ASP. It is easy to learn, and has very short learning curve before one can produce useful results. It was developed by Faik and Tarik Djikic, owners of the web and software development company, Djikic Ltd.. It's main goal is to allow web developers to write dynamically generated web pages quickly and easily with no limits in terms of contents, database formats, graphic layout design, embedded technologies, etc. Operation of WhizBase can be compared to mail merge function of any text processor. When deploying mail merge, user must create a standard letter with spaces left where mail-merge function will put contents of database fields. In such a fashion - user can create thousands of personalised letters, each one created by merging contents of database fields and specially prepared text document. WhizBase works very much like
    0.00
    0 votes
    238

    Windows PowerShell

    • Language Paradigms: Object-oriented programming
    • Influenced By: Korn shell
    Windows PowerShell is Microsoft's task automation framework, consisting of a command-line shell and associated scripting language built on top of, and integrated with the .NET Framework. PowerShell provides full access to COM and WMI, enabling administrators to perform administrative tasks on both local and remote Windows systems. In PowerShell, administrative tasks are generally performed by cmdlets (pronounced command-lets), specialized .NET classes implementing a particular operation. Sets of cmdlets may be combined together in scripts, executables (which are standalone applications), or by instantiating regular .NET classes (or WMI/COM Objects). These work by accessing data in different data stores, like the filesystem or registry, which are made available to the PowerShell runtime via Windows PowerShell providers. Windows PowerShell also provides a hosting mechanism with which the Windows PowerShell runtime can be embedded inside other applications. These applications then leverage Windows PowerShell functionality to implement certain operations, including those exposed via the graphical interface. This capability has been used by Microsoft Exchange Server 2007 to expose its
    0.00
    0 votes
    239
    WxWidgets

    WxWidgets

    wxWidgets (formerly wxWindows) is a widget toolkit and tools library for creating graphical user interfaces (GUIs) for cross-platform applications. wxWidgets enables a program's GUI code to compile and run on several computer platforms with minimal or no code changes. It covers systems such as Microsoft Windows, OS X (Carbon and Cocoa), iOS (Cocoa Touch), Linux/Unix (X11, Motif, and GTK+), OpenVMS, OS/2 and AmigaOS. A version for embedded systems is under development. wxWidgets is used across many industry sectors, most notably by Xerox, Advanced Micro Devices (AMD), Lockheed Martin, NASA and the Center for Naval Analyses. It is also used in the public sector and education by, for example, Dartmouth Medical School, National Human Genome Research Institute, National Center for Biotechnology Information, and many others. wxWidgets is used in many open source projects, and by individual developers. A wide choice of compilers and other tools to use with wxWidgets, allows development of highly sophisticated applications on a tight budget. It is free and open source software, distributed under the terms of the wxWidgets License, which satisfies those who wish to produce for GPL and
    0.00
    0 votes
    240
    XBase++

    XBase++

    Xbase++ is an object oriented programming language which has multiple inheritance and polymorphism. It is based on the XBase language dialect and conventions. It is 100% Clipper compatible language supporting multiple inheritance, polymorphism, object oriented programming. It supports the xBase data types, including Codeblocks. With Xbase++ it is possible to generate applications for Windows NT, 95, 98, Me, 2000, XP, VISTA and Windows 7. XBase++ supports the old commands @SAY/GET to define data entry forms as well as a graphic editor to create data entry forms similar to Visual FoxPro. It also has a visual development environment, support for OEM files (DOS format) and ANSI (Windows), an integrated debugger and a resource compiler to add icons and graphics to the application. It can generate EXE or DLL files. Xbase++ supports the Replaceable Database Drivers (RDD, which provide access to multiple database formats) of Clipper through the DatabaseEngines (DBEs). The basic package includes support for DBF, FOX, NTX, CDX, SDF and DEL(delimited). It also supports CORBA 2.0, Visual FoxPro 3.0 to 5.0 database formats, and access to SQL servers. XBase++ was born after the decision of
    0.00
    0 votes
    241

    XHarbour

    • Influenced By: Harbour compiler
    xHarbour is a free multi-platform extended Clipper compiler, offering multiple graphic terminals (GTs), including console drivers, GUIs, and hybrid console/GUIs. xHarbour is backward-compatible with Clipper and supports many language syntax extensions, greatly extended run-time libraries, and extensive third party support. Like most dynamic languages, xHarbour is also available as a scripting language (standalone application, linkable library, MS ActiveScript engine [Windows Script Host, HTML, ASP]) utilizing an interpreter written in the xHarbour language. The xHarbour Usenet newsgroup comp.lang.xharbour is an active community for discussing xHarbour related questions. xHarbour has 6 scalar types : Nil, String, Date, Logical, Number, Pointer, and 4 complex types: Array, Object, CodeBlock, and Hash. A scalar holds a single value, such as a string, number, or reference to any other type. Arrays are ordered lists of scalars or complex types, indexed by number, starting at 1. Hashes, or associative arrays, are unordered collections of any type values indexed by their associated key, which may be of any scalar or complex type. Literal (static) representation of scalar types: Complex
    0.00
    0 votes
    242

    XHTML

    XHTML (Extensible HyperText Markup Language) is a family of XML markup languages that mirror or extend versions of the widely used Hypertext Markup Language (HTML), the language in which web pages are written. While HTML (prior to HTML5) was defined as an application of Standard Generalized Markup Language (SGML), a very flexible markup language framework, XHTML is an application of XML, a more restrictive subset of SGML. Because XHTML documents need to be well-formed, they can be parsed using standard XML parsers—unlike HTML, which requires a lenient HTML-specific parser. XHTML 1.0 became a World Wide Web Consortium (W3C) Recommendation on January 26, 2000. XHTML 1.1 became a W3C Recommendation on May 31, 2001. XHTML5 is undergoing development as of September 2009, as part of the HTML5 specification. XHTML 1.0 is "a reformulation of the three HTML 4 document types as applications of XML 1.0". The World Wide Web Consortium (W3C) also continues to maintain the HTML 4.01 Recommendation, and the specifications for HTML5 and XHTML5 are being actively developed. In the current XHTML 1.0 Recommendation document, as published and revised to August 2002, the W3C commented that, "The XHTML
    0.00
    0 votes
    243
    XML

    XML

    • Influenced: HTML
    Extensible Markup Language (XML) is a markup language that defines a set of rules for encoding documents in a format that is both human-readable and machine-readable. It is defined in the XML 1.0 Specification produced by the W3C, and several other related specifications, all gratis open standards. The design goals of XML emphasize simplicity, generality, and usability over the Internet. It is a textual data format with strong support via Unicode for the languages of the world. Although the design of XML focuses on documents, it is widely used for the representation of arbitrary data structures, for example in web services. Many application programming interfaces (APIs) have been developed for software developers to use to process XML data, and several schema systems exist to aid in the definition of XML-based languages. As of 2009, hundreds of XML-based languages have been developed, including RSS, Atom, SOAP, and XHTML. XML-based formats have become the default for many office-productivity tools, including Microsoft Office (Office Open XML), OpenOffice.org and LibreOffice (OpenDocument), and Apple's iWork. XML has also been employed as the base language for communication
    0.00
    0 votes
    244

    XPL

    • Influenced: PL/M
    XPL is a programming language based on PL/I, and a portable one-pass compiler written in its own language, and a parser generator tool for easily implementing similar compilers for other languages. XPL was designed in 1967 as a way to teach compiler design principles and as starting point for students to build compilers for their own languages. XPL was designed and implemented by William McKeeman and David B. Wortman at University of California, Santa Cruz and James J. Horning and others at Stanford University. XPL was first announced at the 1968 Fall Joint Computer Conference. The methods and compiler are described in detail in the 1971 textbook 'A Compiler Generator'. They called the combined work a 'compiler generator'. But that implies little or no language- or target-specific programming is required to build a compiler for a new language or new target. A better label for XPL is a Translator Writing System. It helps you write a compiler with less new or changed programming code. The XPL language is a simple, small, efficient dialect of PL/I intended mainly for the task of writing compilers. The XPL language was also used for other purposes once it was available. XPL can be
    0.00
    0 votes
    245
    XSL Formatting Objects

    XSL Formatting Objects

    XSL Formatting Objects, or XSL-FO, is a markup language for XML document formatting which is most often used to generate PDFs. XSL-FO is part of XSL (Extensible Stylesheet Language), a set of W3C technologies designed for the transformation and formatting of XML data. The other parts of XSL are XSLT and XPath. Version 1.1 of XSL-FO was published in 2006. Unlike the combination of HTML and CSS, XSL-FO is a unified presentational language. It has no semantic markup in the way it is meant in HTML. And, unlike CSS which modifies the default presentation of an external XML or HTML document, it stores all of the document's data within itself. The general idea behind XSL-FO's use is that the user writes a document, not in FO, but in an XML language. XHTML, DocBook, and TEI are all possible examples. Then, the user obtains an XSLT transform, either by writing one themselves or by finding one for the document type in question. This XSLT transform converts the XML into XSL-FO. Once the XSL-FO document is generated, it is then passed to an application called an FO processor. FO processors convert the XSL-FO document into something that is readable, printable or both. The most common output of
    0.00
    0 votes
    246
    XyMTeX

    XyMTeX

    XyMTeX is a macro package for TeX which renders high-quality chemical structure diagrams. Using the typesetting system, the name is styled as XϒMTeX. It was originally written by Shinsaku Fujita (藤田眞作, Fujita Shinsaku). Molecules are defined by TeX markup. The following code produces the image for corticosterone below.
    0.00
    0 votes
    247

    Yoix

    • Language Paradigms: Multi-paradigm programming language
    • Influenced By: C
    In computer programming, Yoix is a high-level, general-purpose, interpreted, dynamic programming language. The Yoix interpreter is implemented using standard Java technology without any add-on packages and requires only a Sun-compliant JVM to operate. Initially developed by AT&T Labs researchers for internal use, it has been available as free and open source software since late 2000. In 1998, Java technology was still emerging: the Swing toolkit was an add-on package; interruptible I/O, regular expressions, and a printf capability were not yet features; nor had Java Web Start been developed. Moreover, Java scripting languages were largely non-existent at that time: Groovy and JRuby had not yet been invented and Jython had just been created in late 1997. Browsers in 1998 had limited feature sets, were too unstable for production use in an 8-hour shift and were still fighting skirmishes in the Browser Wars. In this environment, Yoix technology was created in response to a pressing need for a reliable, easy to distribute and maintain, GUI front-end for a mission-critical application being developed within AT&T, namely its Global Fraud Management System, which to this day monitors and
    0.00
    0 votes
    248
    Yorick programming language

    Yorick programming language

    Yorick is an interpreted programming language designed for numerics, graph plotting and steering large scientific simulation codes. It is quite fast due to array syntax, and extensible via C or Fortran routines. It was created in 1996 by David H. Munro of Lawrence Livermore National Laboratory. Yorick is good at manipulating elements in N-dimensional arrays conveniently with its powerful syntax. Several elements can be accessed all at once: Like "theading" in PDL (Perl Data Language) and "broadcasting" in Numpy (Numeric extension for Python), Yorick has a mechanism to do this: ".." is a rubber-index to represent zero or more dimensions of the array. "*" is a kind of rubber-index to reshape a slice(sub-array) of array to a vector. Tensor multiplication is done as follows in Yorick: P(,+,,)*Q(,,+) means
    0.00
    0 votes
    249
    Z notation

    Z notation

    • Influenced: Eiffel
    The Z notation ( /ˈzɛd/), named after Zermelo–Fraenkel set theory, is a formal specification language used for describing and modelling computing systems. It is targeted at the clear specification of computer programs and computer-based systems in general. In 1974, Jean-Raymond Abrial published "Data Semantics". He used a notation that would later be taught in the University of Grenoble until the end of the 1980s. While at EDF (Électricité de France), Abrial wrote internal notes on Z. The Z notation is used in the 1980 book Méthodes de programmation. Z was originally proposed by Abrial in 1977 with the help of Steve Schuman and Bertrand Meyer. It was developed further at the Programming Research Group at Oxford University, where Abrial worked in the early 1980s, having arrived at Oxford in September 1979. Abrial answers the question "Why Z?" with "Because it is the ultimate language!" Z is based on the standard mathematical notation used in axiomatic set theory, lambda calculus, and first-order predicate logic. All expressions in Z notation are typed, thereby avoiding some of the paradoxes of naive set theory. Z contains a standardized catalog (called the mathematical toolkit) of
    0.00
    0 votes
    250

    Zonnon

    • Language Paradigms: Concurrent computing
    • Influenced By: Modula-2
    Zonnon is a general purpose programming language in the Pascal, Modula-2 and Oberon family. Its conceptual model is based on objects, definitions, implementations and modules. Its computing model is concurrent, based on active objects which interact via syntax controlled dialogs. The language is being developed at ETH Zürich Institute for Computer Systems by Prof. Jürg Gutknecht. Zonnon introduces the concept of 'active objects' which are used to represent real world concurrent objects within computer programs. The Zonnon Language Report was written by Brian Kirk (director at Robinsons Associates), and David Lightfoot (Oxford Brookes University) working with Prof. Jürg Gutknecht (ETH, Zürich) and Dr. Eugene Zueff (Moscow State University). Zonnon is a member of the Pascal family of languages, which has two beneficial consequences: a) it is a general purpose language and b) it is immediately familiar to Pascal, Modula-2 and Oberon programmers. Most Pascal programs from the domain of algorithms and data structures are successfully compiled by the Zonnon compiler after just a few minor modifications. However, from the perspective of “programming-in-the-large”, Zonnon is much more
    0.00
    0 votes
    Get your friends to vote! Spread this URL or share:

    Discuss Best Programming Language of All Time