Languages

From Things and Stuff Wiki
Revision as of 20:46, 16 July 2016 by Milk (talk | contribs) (→‎Spry)
Jump to navigation Jump to search


to reformat

Languages

  • https://en.wikipedia.org/wiki/First-generation_programming_language - a grouping of programming languages that are machine level languages used to program first-generation computers. The instructions were given through the front panel switches of these computers, directly to the CPU. There was originally no compiler or assembler to process the instructions in 1GL.


  • https://en.wikipedia.org/wiki/Second-generation_programming_language - a generational way to categorize assembly languages. The code can be read and written by a programmer. To run on a computer it must be converted into a machine readable form, a process called assembly. The language is specific to a particular processor family and environment.
  • https://en.wikipedia.org/wiki/Third-generation_programming_language - a generational way to categorize high-level computer programming languages. Where assembly languages, categorized as second generation programming languages, are machine-dependent, 3GLs are much more machine independent and more programmer-friendly. This includes features like improved support for aggregate data types, and expressing concepts in a way that favors the programmer, not the computer. A third generation language improves over a second generation language by having the computer take care of non-essential details. 3GLs feature more abstraction than previous generations of languages, and thus can be considered higher level languages than their first and second generation counterparts.

First introduced in the late 1950s, Fortran, ALGOL, and COBOL are early examples of this sort of language. Most popular general-purpose languages today, such as C, C++, C#, Java, BASIC and Pascal, are also third-generation languages, although each of these languages can be further subdivided into other categories based on other contemporary traits.




Plankalkül

1948

Speedcoding

1953

IPL

1954

Fortran

1957

COMTRAN

1957

ALGOL

1958

COBOL

1959

Lisp

1959

See also Emacs

Flavors

  • https://en.wikipedia.org/wiki/Flavors_(programming_language) - an early object-oriented extension to Lisp developed by Howard Cannon at the MIT Artificial Intelligence Laboratory for the Lisp machine and its programming language Lisp Machine Lisp, was the first programming language to include mixins. Symbolics used it for its Lisp machines, and eventually developed it into New Flavors; both the original and new Flavors were message passing OO models. It was hugely influential in the development of the Common Lisp Object System (CLOS). Implementations of Flavors are also available for Common Lisp. New Flavors replaced message sending with calling generic functions.

Common Lisp

1984 / 1994 ANSI



8 http://www.draketo.de/english/wisp/shakespeare

ALGOL 60

1960

SNOBOL

CPL

1963

BASIC

1964

  • https://en.wikipedia.org/wiki/Dartmouth_BASIC - the original version of the BASIC programming language. It is so named because it was designed and implemented at Dartmouth College. The language was designed by John Kemeny and Thomas Kurtz as part of the Dartmouth Time Sharing System (DTSS) and was one of the first programming languages intended to be used interactively.

Several versions were produced at Dartmouth over the years, all implemented as compile and go compilers, unlike many of the versions of the language implemented elsewhere, which were interpreters. The first compiler was produced before the time-sharing system was ready. Known as CardBASIC, it was intended for the standard card-reader based batch processing system. Like all the following versions, it was implemented by a team of undergraduate programmers working under the direction of Kemeny and Kurtz. The first interactive version was made available to general users in June 1964; the second in October, 1964; the third in 1966; the fourth in 1969; the fifth in 1970; the sixth in 1971; and the seventh in 1979.


APL

1964

wut


BCPL

1966

Simula

1967

1967

Forth

1968ish

B

1969

Pascal

1970

Smalltalk

1972


  • Squeak is an open-source Smalltalk programming system with fast execution environments for all major platforms. It features the Morphic framework, which promotes low effort graphical, interactive application development and maintenance. Many projects have been successfully created with Squeak. They cover a wide range of domains such as education, multimedia, gaming, research, and commerce.


  • Strongtalk is a major re-thinking of the Smalltalk-80 programming language and system. While retaining the basic Smalltalk syntax and semantics, it contains a number of significant advances
  • Pharo - an open source implementation of the programming language and environment Smalltalk. Pharo offers strong live programming features such as immediate object manipulation, live update, hot recompilation. Live programming environment is in the heart of the system. Pharo emerged as a fork of Squeak.


C / C++

to sort out!

See C/C++

ML / Standard ML

1973 / 1990 / 1997

CLU

1974

Iterators.

Mesa

1974

Xerox, used on Alto and Star

Influenced Modula-2 and Java

Modula

1975

Scheme

1975

Continuation-passing_style

Icon

1977

FP

1977

Mouse

Rexx

1979

Ada

1980

BBC BASIC

1981

C++

to move

Objective-C

1983

  • 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.[1] Generic Objective-C programs that do not use the Cocoa or Cocoa Touch libraries can also be compiled for any system supported by GCC or Clang.

DRAKON

1986

Eiffel

1986

Caml / OCaml

1985

1996

  • http://en.wikipedia.org/wiki/OCaml - originally known as Objective Caml, is the main implementation of the Caml programming language, created by Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez and others in 1996. OCaml extends the core Caml language with object-oriented constructs. OCaml's toolset includes an interactive top level interpreter, a bytecode compiler, a reversible debugger, a package manager (OPAM), and an optimizing native code compiler. It has a large standard library that makes it useful for many of the same applications as Python or Perl, as well as robust modular and object-oriented programming constructs that make it applicable for large-scale software engineering. OCaml is the successor to Caml Light. The acronym CAML originally stood for Categorical Abstract Machine Language, although OCaml abandons this abstract machine. OCaml is a free open source project managed and principally maintained by INRIA. In recent years, many new languages have drawn elements from OCaml, most notably F# and Scala.


2016

  • Facebook: Reason is a new interface to OCaml - a highly expressive dialect of the ML language featuring type inference and static type checking.Reason provides a new syntax and toolchain for editing, building, and sharing code, and will evolve in the open as a community collaboration. Reason already has contributers across several organizations/companies. Much of Reason’s core syntax should be familiar to anyone who has ever used modern JavaScript / Flow or Rust. The examples in this document give an overview of the most important language constructs and their respective syntax. [27]

OCaml is a great tool for writing highly expressive, functional or imperative code, with type inference and fast runtime performance. Because of these properties, OCaml has helped Facebook quickly build scalable infrastructure such as Hack, Flow, and Infer. It is also used for other performance sensitive applications in the financial industry (Jane Street, Bloomberg). At the same time, OCaml has a very mature (and still growing) ecosystem for targeting browser and JavaScript environments with a focus on language interoperability and integration with existing JavaScript code.Reason‘s non-invasive approach to the OCaml compiler allows Reason code to take advantage of all of the existing OCaml compiler optimizations/backends such as bare metal ARM, x86, and even JavaScript compilation.

Fabrik

1985

Object Pascal

1986

Modula-3

1986/1989

Oberon

1986

Self

1987

Perl

1987

See also Regex

  • Periodic Table of the Operators - Being a comprehensive and complete enumeration of the Operatic Elements of the Perl 6 Language, assembled and drawn with dedication and diligence by M. Lentczner as a service to both the Community and the Republic.


Articles

Modules

Other

  • Welcome to Perl 11 - Perl 11 is an effort to make Perl 5 pluggable at the following levels: Runtime Virtual Machine

Compilation Unit Format / AST, Source Code Syntax / Compilers [31]

Perl6

HyperTalk

1987

for hypercard

Tcl

1988

Mathematica

FL

1989

Haskell

1990

  • Haskell is an advanced purely-functional programming language. An open-source product of more than twenty years of cutting-edge research, it allows rapid development of robust, concise, correct software. With strong support for integration with other languages, built-in concurrency and parallelism, debuggers, profilers, rich libraries and an active community, Haskell makes it easier to produce flexible, maintainable, high-quality software.
  • GHC is a state-of-the-art, open source, compiler and interactive environment for the functional language Haskell. Highlights:

Packages

A package is a library of Haskell modules known to the compiler. GHC comes with several packages: see the accompanying library documentation. More packages to install can be obtained from HackageDB.

Using a package couldn't be simpler: if you're using ––make or GHCi, then most of the installed packages will be automatically available to your program without any further options. The exceptions to this rule are covered below in Section 4.9.1, “Using Packages ”.

Building your own packages is also quite straightforward: we provide the Cabal infrastructure which automates the process of configuring, building, installing and distributing a package. All you need to do is write a simple configuration file, put a few files in the right places, and you have a package. See the Cabal documentation for details, and also the Cabal libraries (Distribution.Simple, for example).

  • Cabal (Common Architecture for Building Applications and Libraries) is a system for building and packaging Haskell libraries and programs. It defines a common interface for package authors and distributors to easily build their applications in a portable way. Cabal is part of a larger infrastructure for distributing, organizing, and cataloging Haskell libraries and programs. Specifically, the Cabal describes what a Haskell package is, how these packages interact with the language, and what Haskell implementations must to do to support packages. The Cabal also specifies some infrastructure (code) that makes it easy for tool authors to build and distribute conforming packages.
  • HackageDB (or just Hackage) is a collection of releases of Haskell packages. Each package is in the Cabal format, a standard way of packaging Haskell source code that makes it easy to build and install. These pages are a basic web interface to the Hackage package database.
  • cabal-install package provides the cabal command-line tool which simplifies the process of managing Haskell software by automating the fetching, configuration, compilation and installation of Haskell libraries and programs. Those packages must be prepared using Cabal and should be present at Hackage.
  • Gtk2Hs - A GUI Library for Haskell based on Gtk

Arch

pacman -Rncs ghc
  remove all haskell..

Web

  • Yesod is a Haskell web framework for productive development of type-safe, RESTful, high performance web applications.
  • Snap is a simple web development framework for unix systems, written in the Haskell programming language. Snap has a high level of test coverage and is well-documented. Features include: a fast HTTP server library, a sensible and clean monad for web programming, an HTML-based templating system for generating pages

JS

  • Fay - A proper subset of Haskell that compiles to JavaScript. Fay is a small programming language which has the following properties: A proper syntactic and semantic subset of Haskell, Statically typed, Lazy, Pure by default, Compiles to JavaScript, Has fundamental data types (Double, String, etc.) based upon what JS can support, Outputs minifier-aware code for small compressed size, Has a trivial foreign function interface to JavaScript

Erlang

1990

J

1990

Piet

1990

Esoteric, image based.

Python

1991

See Python

Q

1991

Oz

1991

Lua

1993

  • Lua is a powerful, fast, lightweight, embeddable scripting language. Lua combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, runs by interpreting bytecode for a register-based virtual machine, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.
  • http://code.google.com/p/lua-checker/
  • LuaJIT — a Just-In-Time Compiler for Lua.
  • Metalua is a language and a compiler which provide a complete macro system, similar in power to what's offfered by Lisp dialects or Template Haskell; manipulated programs can be seen as source code, as abstract syntax trees, or as an arbitrary mix thereof, whichever suits your task better.
os.time();
os.getenv()
  i.e. os.getenv( "HOME" ); ?? to confirm, hardcoded as no time atm.

R

1993

Good for stats, etc.

OpenDylan

1993

K

1993

Brainfuck

1993

Racket

1994

SAC

1994

PHP

1995

See PHP

Java

1995

Java syntax seems unwieldy.



Apache Tomcat

Jetty

JavaScript

1995

See JavaScript

Ruby

1995

See Ruby

Rebol

1997

Dylan

Mid 90s

Slate

1999

C#

2000

D

2001

Processing

2001

.NET

2002

Io

2002

Scala

2003

Spec# / Sing#

2004

F#

2005

Agda

2005

Vala

2006

Sage

2006

  • Sage is a prototype functional programming language designed to provide high-coverage checking of expressive program specifications (types).

Little

2006

  • Little (L) is a compiled-to-byte-code language that draws heavily from C and Perl. From C, Little gets C syntax, simple types (int, float, string), and complex types (arrays, structs). From Perl, Little gets associative arrays and regular expressions (PCRE). And from neither, Little gets its own simplistic form of classes. [47]

Clojure

2007

LOLCODE

2007

Arc

2008

Lisp dialect by PG etc. Developed in Racket.

Pure

2008

Go

2009 


go get ./...
  # run in go project directory to install dependencies

go build project.go
  # compile a project



Dao

2009

Zimbu

2009

  • Zimbu is an experimental programming language. It is a very practical, no-nonsense kind of language. It mixes the good things of many existing languages and avoids their deficiencies. And then throws in a few brand new ideas.

Potion

2009

Rust

2010


Crack

2010

Ur

2010?

Dart

2011

Elm

2011

Elixier

2011

  • Elixir is a functional meta-programming aware language built on top of the Erlang VM. It is a dynamic language with flexible syntax with macros support that leverages Erlang's abilities to build concurrent, distributed, fault-tolerant applications with hot code upgrades. Elixir also provides first-class support for pattern matching, polymorphism via protocols (similar to Clojure's), aliases and associative data structures (usually known as dicts or hashes in other programming languages). Finally, Elixir and Erlang share the same bytecode and data types. This means you can invoke Erlang code from Elixir (and vice-versa) without any conversion or performance hit. This allows a developer to mix the expressiveness of Elixir with the robustness and performance of Erlang.

Shen

2011

Red

2011

Gosu

2011

Julia

2012

Typescript

2012

From Microsoft, compiles to JS.

Nim

Slash

2012

Idris

2012

Clay

Babar

2013

Lobster

2013

Chicken

2013

Z

2013

Urbit

2013

Ioke

2013

Pyret

2013

Crystal

2013

Egison

Ceylon

Lobster

Cosmos

Mochi

Wren

Lasp

Swift

2014

Eve

2014

Mu

Luna

klisp

Spry

2015

Full Metal Jacket

2015

Hivemind

2016

zig

2016

L.B. Stanza

Nit

to sort


  • kayia

Other





Retrieved from "https://wiki.thingsandstuff.org/index.php?title=Languages&oldid=37067"