Proliferation of Programing Languages

Pure

A pattern matching, term-rewriting lang.

Pure is a dynamically typed, functional programming language based on term rewriting. It has facilities for user-defined operator syntax, macros, multiple-precision numbers, and compilation to native code through the LLVM. It is the successor to the Q programming language.

The syntax of Pure resembles that of Miranda and Haskell, but it is a free-format language and thus uses explicit delimiters (rather than indentation) to indicate program structure.

https://agraef.github.io/pure-lang/

fib 0 = 0;
 fib 1 = 1;
 fib n = fib (n-2) + fib (n-1) if n>1;

// Better (tail-recursive and linear-time) version:

 fib n = fibs (0,1) n with
   fibs (a,b) n = if n<=0 then a else fibs (b,a+b) (n-1);
 end;

http://purelang.bitbucket.org/

Vala (2006), Genie

Vala is an object-oriented programming language with a self-hosting compiler that generates C code and uses the GObject system.

Vala is syntactically similar to C# and includes several features such as: anonymous functions, signals, properties, generics, assisted memory management, exception handling, type inference, and foreach statements.[2] Its developers Jürg Billeter and Raffaele Sandrini aim to bring these features to the plain C runtime with little overhead and no special runtime support by targeting the GObject object system.

https://wiki.gnome.org/Projects/Vala

Vala - Compiler for the GObject type system

Vala is a programming language that aims to bring modern programming language features to GNOME developers without imposing any additional runtime requirements and without using a different ABI compared to applications and libraries written in C.

Genie

https://wiki.gnome.org/action/show/Projects/Genie

Genie is a programming language, in the same vein as Vala. Genie allows for a more modern programming style while being able to effortlessly create and use GObjects natively.

The syntax is designed to be clean, clear and concise and is derived from numerous modern languages like Python, Boo, D language and Delphi. For a sample, take a look at instance.gs from the Khövsgöl project.

Genie is very similar to Vala in functionality but differs in syntax allowing the developer to use cleaner and less code to accomplish the same task.

Factor (2003)

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.

[see What is Point-free Programing? (point-free function syntax)]

The Fantom Language, and a Scathing Review of Scala

There are endless languages. Just discovered Fantom.

Fantom is a general purpose object-oriented programming language created by Brian and Andy Frank[4] that runs on the Java Runtime Environment (JRE), JavaScript, and the .NET Common Language Runtime (CLR) (.NET support is considered “prototype”[5] status).

Its primary design goal is to provide a standard library API[6] that abstracts away the question of whether the code will ultimately run on the JRE or CLR.

Like C# and Java, Fantom uses a curly brace syntax.

The language supports functional programming through closures and concurrency through the Actor model. Fantom takes a “middle of the road” approach to its type system, blending together aspects of both static and dynamic typing.

Fantom (programming_language)

Also, there's this scathing review of Scala by someone who seems to be a Java platform expert.

Scala feels like EJB 2, and other thoughts 2011-11-22 By Stephen Colebourne. At http://blog.joda.org/2011/11/scala-feels-like-ejb-2-and-other.html

Go (2009)

• Go began in 2009, created by Robert Griesemer, Rob Pike, Ken Thompson.
• Go is a low-level programing language, originally designed to replace C++.
• Syntax is like C
• Speed similar to C, with memory management
• its ease of use somewhat like a scripting language.

see my Golang Tutorial

Rust (2010)

Rust, came out in 2010.

Rust is a systems programming language.

Rust is a systems programming language sponsored by Mozilla which describes it as a “safe, concurrent, practical language” , supporting functional and imperative-procedural paradigms. Rust is syntactically similar to C++, but its designers intend it to provide better memory safety while still maintaining performance.

The language grew out of a personal project started in 2006 by Mozilla employee Graydon Hoare, who stated that the project was possibly named after the rust family of fungi. Mozilla began sponsoring the project in 2009 and announced it in 2010. The same year, work shifted from the initial compiler (written in OCaml) to the self-hosting compiler written in Rust. Named rustc, it successfully compiled itself in 2011. rustc uses LLVM as its back end.

Rust (programming_language)

Julia (2011)

Julia is a new lang for scientific computing. New around 2011.

http://julialang.org/

it's a competitor to number crunchers R, Fortran, MATLAB, etc, but as fast as C.

CoffeeScript (2009)

One of the earlist wrapper language of JavaScript.

Basically, JavaScript with a syntax skin.

CoffeeScript or JavaScript?

Dart (2011)

Dart came out in 2011. It is basically typed JavaScript in Java syntax AND semantics.

import 'dart:async';
import 'dart:html';
import 'dart:math' show Random;

// We changed 5 lines of code to make this sample nicer on
// the web (so that the execution waits for animation frame,
// the number gets updated in the DOM, and the program ends
// after 500 iterations).

main() async {
  print('Compute π using the Monte Carlo method.');
  var output = querySelector("#output");
  await for (var estimate in computePi().take(500)) {
    print('π ≅ $estimate');
    output.text = estimate.toStringAsFixed(5);
    await window.animationFrame;
  }
}

/// Generates a stream of increasingly accurate estimates of π.
Stream<double> computePi({int batch: 100000}) async* {
  var total = 0;
  var count = 0;
  while (true) {
    var points = generateRandom().take(batch);
    var inside = points.where((p) => p.isInsideUnitCircle);
    total += batch;
    count += inside.length;
    var ratio = count / total;
    // Area of a circle is A = π⋅r², therefore π = A/r².
    // So, when given random points with x ∈ <0,1>,
    // y ∈ <0,1>, the ratio of those inside a unit circle
    // should approach π / 4. Therefore, the value of π
    // should be:
    yield ratio * 4;
  }
}

Iterable<Point> generateRandom([int seed]) sync* {
  final random = new Random(seed);
  while (true) {
    yield new Point(random.nextDouble(), random.nextDouble());
  }
}

class Point {
  final double x, y;
  const Point(this.x, this.y);
  bool get isInsideUnitCircle => x * x + y * y <= 1;
}

[see What do Microsoft, Apple, Mozilla, say about Dart?]

TypeScript (2012)

http://www.typescriptlang.org/

Microsoft created TypeScript in 2012.

TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.

[see TypeScript Will Kill CoffeeScript and Dart!]

asm.js

Then, in ~2013-02-28, asm.js is created. Home page at http://asmjs.org/ .

It's a subset of JavaScript that will make it run very fast, as in C/C++. It's a subset, so it runs in any browser. The typical application is for games written in C/C++ be compiled into asm.js and run (fast enough) browser. The UNREAL engine has been ported to asm.js.

Here's some blogs about it:

• one of the asm.js creator: [What asm.js is and what asm.js isn't 2013-06-20 By Alon Zakai. At http://mozakai.blogspot.com/2013/06/what-asmjs-is-and-what-asmjs-isnt.html , accessed on 2013-07-29 ]
• JQuery author: [Asm.js: The JavaScript Compile Target 2013-04-03 By John Resig. At http://ejohn.org/blog/asmjs-javascript-compile-target/ , accessed on 2013-07-29 ]
• [asm.js: A Low Level, Highly Optimizable Subset of JavaScript for Compilers 2013-02-18 By Devon Govett. At http://badassjs.com/post/43420901994/asm-js-a-low-level-highly-optimizable-subset-of , accessed on 2013-07-29 ]

OMeta

A lang based on Parsing Expression Grammar, called OMeta, by Alessandro Warth.

OMeta: an Object-Oriented Language for Pattern Matching 2013-03-12 By Alessandro Warth. At http://tinlizzie.org/ometa/

[Tom Novelli https://plus.google.com/108241330104058929067/posts] provided the following insights and links:

Yeah, that seems promising. there's actually a long history behind it; see for example [Pragmatic Parsing in Common Lisp 1991-01-30 By Henry G Baker, Nimble Computer Corporation. At http://home.pipeline.com/~hbaker1/Prag-Parse.html , accessed on 2013-03-12 ]

I found a copy of Val Schorre's META-II paper from 50 years ago… and some followup work throughout the 1960s (For example, TREE-META)… these guys were in Douglas Englebart's group. Then apparently the military took it over and made it classified, probably ruined it with bureaucracy rather than developing it into awesome top-secret technology, heh ☺

• The programming languages behind “the mother of all demos” 2008-12-10 By Ehud Lamm. At http://lambda-the-ultimate.org/node/3122
• TREE-META Manual 1974-04-30 By F R A Hopgood. At http://www.chilton-computing.org.uk/acl/literature/manuals/tree-meta/contents.htm

Elm (2012)

http://elm-lang.org/

Elm is a functional programming language for declaratively creating web browser based graphical user interfaces. Elm uses the Functional Reactive Programming style and purely functional graphical layout to build user interface without any destructive updates.

Elm was designed by Evan Czaplicki as his thesis in 2012. The first release of Elm came with many examples and an online editor that made it easy to try out in a web browser.[3] Evan Czaplicki now works on Elm at Prezi.[4]

The initial implementation of the Elm compiler targets HTML, CSS, and JavaScript.[5] The set of core tools has continued to expand, now including a REPL,[6] package manager,[7] time-traveling debugger,[8] and installers for Mac and Windows.[9] Elm also has an ecosystem of community created libraries.[10]

Haxe

Haxe is an open source high-level multi-platform programming language and compiler that can produce applications and source code for many different platforms from a single code-base.[1][2][3][4]

Haxe includes a set of common functionality that is supported across all platforms, such as numeric data types, text, arrays, binary and some common file formats.[2][5] Haxe also includes platform-specific API for Adobe Flash, C++, PHP and other languages.[2][6]

Code written in the Haxe language can be source-to-source compiled into ActionScript 3 code, JavaScript programs, Java, C#, C++ standalone applications, Python, PHP, Apache CGI, and Node.js server-side applications.[2][5][7]

Haxe is also a full-featured ActionScript 3-compatible Adobe Flash compiler, that can compile a SWF file directly from Haxe code.[2][8] Haxe can also compile to Neko applications, built by the same developer.

Major users of Haxe include TiVo, Prezi, Nickelodeon, Disney, Mattel, Hasbro, Coca Cola, Toyota and BBC.[9][10] OpenFL and Flambe are popular Haxe frameworks that enable the creation of multi-platform content from a single codebase.[10] With HTML5 dominating over Adobe Flash in recent years, Haxe, Unity and other cross-platform tools are increasingly necessary to target modern platforms while providing backward compatibility with Adobe Flash Player.[10][11]

Hacklang (2014)

Facebook created a new lang: hacklang. Basically, it's PHP with optional type system, with type inference. Designed to run existing PHP code as much as possible. Already deployed in large scale by Facebook.

I think this is fantastic.

announcement: [Hack: a new programming language for HHVM 2014-03-20 By Julien Verlaguet, Alok Menghrajani. At https://code.facebook.com/posts/264544830379293/hack-a-new-programming-language-for-hhvm/ , accessed on 2014-03-23 ]

home page http://hacklang.org/

egison (2011)

egison, pattern matching language.

http://www.egison.org/

Swift (2014)

Swift is a multi-paradigm, compiled programming language created by Apple Inc. for iOS, OS X, and watchOS development. Swift is designed to work with Apple's Cocoa and Cocoa Touch frameworks and the large body of existing Objective-C code written for Apple products. Swift is intended to be more resilient to erroneous code (“safer”) than Objective-C, and also more concise. It is built with the LLVM compiler framework included in Xcode 6, and uses the Objective-C runtime, allowing C, Objective-C, C++ and Swift code to run within a single program.[8]

Swift (programming_language)

Elixir (2011)

Elixir is a functional, concurrent, general-purpose programming language that runs on the Erlang virtual machine (BEAM). Elixir builds on top of Erlang to provide distributed, fault-tolerant, soft real-time, non-stop applications but also extends it to support metaprogramming with macros and polymorphism via protocols.[3]

• A language that compiles to bytecode for the Erlang Virtual Machine (BEAM)[5]
• Everything is an expression[5]
• Erlang functions can be called from Elixir without run time impact, due to compilation to Erlang bytecode, and vice versa
• Meta programming allowing direct manipulation of AST[5]
• Polymorphism via a mechanism called protocols. Like in Clojure, protocols provide a dynamic dispatch mechanism. However, this is not to be confused with multiple dispatch as Elixir protocols dispatch on a single type.
• Support for documentation via Python-like docstrings in the Markdown formatting language[5]
• Shared nothing concurrent programming via message passing (Actor model)[6]
• Emphasis on recursion and higher-order functions instead of side-effect-based looping
• Lightweight concurrency utilizing Erlang's mechanisms with simplified syntax (e.g. Task)[5]
• Lazy and async collections with streams
• Pattern matching[5]
• Unicode support and UTF-8 strings

Elixir (programming_language)

http://elixir-lang.org/

[A Week with Elixir 2013-05-31 By Joe Armstrong (Creator Of Erlang). At http://joearms.github.io/2013/05/31/a-week-with-elixir.html , accessed on 2015-10-16 ]

Kotlin (2011)

New language, Kotlin, from JetBrains. Runs on Java Virtual Machine. Similar to Java, but designed to improve java.

Kotlin is a statically-typed programming language that runs on the Java Virtual Machine and also can be compiled to JavaScript source code. Its primary development is from a team of JetBrains programmers based in Saint Petersburg, Russia (the name comes from the Kotlin Island, near St. Petersburg).

While not syntax compatible with Java, Kotlin is designed to interoperate with Java code and is reliant on Java code from the existing Java Class Library, such as the collections framework.

Kotlin_(programming_language)

http://kotlinlang.org/

nim (2008)

http://nim-lang.org/

Nim in is python syntax with modernized C-like semantics and speed.

Nim came out in 2008.

Crystal (2014)

https://crystal-lang.org

Ruby syntax, fast like C. Began in 2014.

[see Ruby: Learn Ruby in 1 Hour]

pyret

Pyret is designed to serve as an outstanding choice for programming education while exploring the confluence of scripting and functional programming. It's under active design and development.

pyret, from the Racket Scheme Lisp group.

sample pyret code:

fun to-celsius(f):
  (f - 32) * (5 / 9)
end

for each(str from [list: "Ahoy", "world!"]):
  print(str)
end

pyret is basically Racket Scheme Lisp in Python syntax.

pyret spells the end of Scheme era, and the end excellence of the Rice University Programing Language Team (PLT).

one of said reason for pyret is to experiment with syntax. It dispells the lisp myth about how lisp macro/reader can change syntax. [see Can Lisp Macro Change Lisp Syntax?]

see also

• Scheme Lisp and Failure
• Language, Purity, Cult, and Deception

PureScript

http://www.purescript.org/

PureScript is a small strongly typed programming language that compiles to JavaScript

ReasonML

https://reasonml.github.io/

ReasonML is OCaml in JavaScript syntax. Created by Facebook.

P language

P is a language for asynchronous event-driven programming. P allows the programmer to specify the system as a collection of interacting state machines, which communicate with each other using events. P unifies modeling and programming into one activity for the programmer. Not only can a P program be compiled into executable code, but it can also be validated using systematic testing. P has been used to implement and validate the USB device driver stack that ships with Microsoft Windows 8 and Windows Phone. P is also suitable for the design and implementation of networked, embedded, and distributed systems.

https://github.com/p-org/P

LEAN

L∃∀N

Lean is a new open source theorem prover being developed at Microsoft Research, and its standard library at Carnegie Mellon University. The Lean Theorem Prover aims to bridge the gap between interactive and automated theorem proving, by situating automated tools and methods in a framework that supports user interaction and the construction of fully specified axiomatic proofs. The goal is to support both mathematical reasoning and reasoning about complex systems, and to verify claims in both domains.

The Lean project was launched by Leonardo de Moura at Microsoft Research in 2013. It is a collaborative open source project, hosted on GitHub. Contributions to the code base and library are welcome.

You can experiment with an online version of Lean that runs in your browser, or use an online tutorial.

[2016-12-26 http://leanprover.github.io/about/]

https://cakeml.org/

functional programming language with a proven-correct compiler and runtime system.

someone asked why not perl6, and i said it's 18 years late and too many other interesting languages today. He asked for examples.

several classes to consider:

• does it have C speed? eg golang rust julia nim crystal
• can it do symbolic term rewriting? Mathematica, lisp.
• can it define operators, do matrix computation? e.g. array langs. Mathematica, apl, matlab, julia.
• can it do logic programing? prolog, mercury.
• can it do parallel and currency? e.g. goglang, clojure, erlang, alice.
• can it do math proofs? e.g. coq, agda, idris.

etc.

Microsoft Bosque Language

https://github.com/Microsoft/BosqueLanguage

beyond_structured_report_v2.pdf

The language is designed based on TypeScript syntax and JavaScript semantics.

The language is supposed to avoid the following problems they called complexity

• multable states and frames. → no mutable variable.
• loops, recursion, and invariants. → the language has no loop construct. instead, use functions like map, forEach etc.
• indeterminate behaviors → e.g. keywords like undefined, null, and others.
• Data Invariant Violations → stop updating array etc elements. provide a more controlled way to do so.
• Equality and Aliasing → reference equality, value equality, etc.