Languages

From Things and Stuff Wiki
Revision as of 17:12, 29 April 2018 by Milk (talk | contribs) (→‎APL)
Jump to navigation Jump to search


to reformat. should be more a graph..

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

FLOW-MATIC

1955

Fortran

1957

COMTRAN

1957

ALGOL

1958

COBOL

1959

Lisp

1959

See Lisp

See also Emacs

ALGOL 60

1960

JOVIAL

1960

Influenced by ALGOL, SAGE. Influenced CMS-2, Coral 66, and SYMPL.

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




  • Papers from the Lost Culture of Array Languages - 2012 is the 50th anniversary of Ken Iverson's A Programming Language, which described the notation that became APL (even though a machine executable version of APL didn't exist yet). Since then there's been APL2, Nial, A+, K, Q, and other array-oriented languages. Iverson (1920-2004) teamed with Roger Hui to create a modern successor to APL, tersely named J, in the late 1980s. The culture of array languages is a curious one. Though largely functional, array languages represent a separate evolutionary timeline from the lambda calculus languages like Miranda and Haskell. [13]


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.


  • 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.


  • Strongtalk - 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




  • Open Cobalt - a free and open-source software platform for constructing, accessing, and sharing virtual worlds both on local area networks or across the Internet, without any requirement for centralized servers. The technology makes it easy to create deeply collaborative and hyperlinked multi-user virtual workspaces, virtual exhibit spaces, and game-based learning and training environments that run on all major software operating systems. By using a peer-based messaging protocol to reduce reliance on server infrastructures for support of basic in world interactions across many participants, Open Cobalt makes it possible for people to hyperlink their virtual worlds via 3D portals to form a large distributed network of interconnected collaboration spaces. It also makes it possible for schools and other organizations to freely set up their own networks of public and private 3D virtual workspaces that feature integrated web browsing, voice chat, text chat and access to remote desktop applications and services.

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. [23]

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 Perl

HyperTalk

1987

for hypercard

Tcl

1988

  • Dodekalogue - the common name for the twelve rules that define the syntax and semantics of Tcl.



Mathematica

1988

A+

1988

  • A+: a programming language for actual programmers - a powerful and efficient programming language. It is freely available under the GNU General Public License. It embodies a rich set of functions and operators, a modern graphical user interface with many widgets and automatic synchronization of widgets and variables, asynchronous execution of functions associated with variables and events, dynamic loading of user compiled subroutines, and many other features. Execution is by a rather efficient interpreter. A+ was created at Morgan Stanley. Primarily used in a computationally-intensive business environment, many critical applications written in A+ have withstood the demands of real world developers over many years. Written in an interpreted language, A+ applications tend to be portable.

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

See Lua

R

1993

Good for stats, etc.


  • R packages - This is the book site for “R packages”. It was published with O’Reilly in April 2015. Packages are the fundamental units of reproducible R code. They include reusable R functions, the documentation that describes how to use them, and sample data. In this section you’ll learn how to turn your code into packages that others can easily download and use. Writing a package can seem overwhelming at first. So start with the basics and improve it over time. It doesn’t matter if your first version isn’t perfect as long as the next version is better.


sudo Rscript -e "install.packages('devtools', repos='https://www.stats.bris.ac.uk/R/')"

devtools::load_all("directory/for/my/package")



  • R Markdown - documents are fully reproducible. Use a productive notebook interface to weave together narrative text and code to produce elegantly formatted output. Use multiple languages including R, Python, and SQL.


[32]


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

Factor

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. [42]

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




  • https://github.com/willcrichton/lia - a dynamically typed and garbage collected programming language that seamlessly interoperates with Rust by using Rust as a compile target. This enables Lia users to drop down into efficient Rust code when necessary, but work with a high-level Javascript-esque language for the majority of their application.

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

  • Idris - Idris is a general purpose pure functional programming language with dependent types. Dependent types allow types to be predicated on values, meaning that some aspects of a program’s behaviour can be specified precisely in the type. It is compiled, with eager evaluation. Its features are influenced by Haskell and ML, and include:
  • Full dependent types with dependent pattern matching
  • Simple foreign function interface (to C)
  • Compiler-supported interactive editing: the compiler helps you write code using the types
  • where clauses, with rule, simple case expressions, pattern matching let and lambda bindings
  • Dependent records with projection and update
  • Interfaces (similar to type classes in Haskell)
  • Type-driven overloading resolution
  • do notation and idiom brackets
  • Indentation significant syntax
  • Extensible syntax
  • Cumulative universes
  • Totality checking
  • Hugs style interactive environment

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

SPARK

2014

Mu

Luna

klisp

Spry

2015

Full Metal Jacket

2015

Logic Production Systems

2015

Hivemind

2016

zig

2016

L.B. Stanza

Luna

2017

Nit

to sort


  • kayia

Other





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