POLYGLOT PROGRAMMING

Better poly than sorry!

Programming languages list

A list of languages I either looked at or am going to look at at some point.

There are links to official sites, tutorials and other learning resources for each one.

Some languages are tagged with a platform they compile to (JVM, dotNET, JS, Native). There are also 2 additional tags - Lisp and Smalltalk - which I use to mark Lisp- and Smalltalk-like languages (there's simply quite a lot of them).

Ada

Alpaca

Amber   JS Smalltalk

Avail

AWK

  • small, interpreted language for data extraction
  • and shell-related stuff (especially with gawk extensions)
  • jq and possibly Txr took inspiration from AWK

BiwaScheme   Lisp JS

Boo   dotNET

Boomerang

  • http://www.seas.upenn.edu/~harmony/manual.pdf
  • experimental, research langauge built around the concept of lenses
  • focused on text transformation
  • provides a core of lens combinators
  • and a full-blown functional language with many conveniences on top

C

  • low-level, compiled language with lots of undefined behaviour
  • has rock solid ABI and memory layout rules
  • I was writing some C in the '90
  • there's also a Ch language - it's a C interpreter, working on Windows, well suited for lightweight scripting

C++

  • low to high level, compiled multiparadigm language
  • with support for template metaprogramming and generic programming
  • not too big stdlib, but a workable one
  • multiple-inheritance, no interfaces (use pure abstract classes for this)
  • very complex syntax and semantics, lots of undefined behaviour
  • many useful patterns in community like RAII, but without explicit support in the language
  • I was writing C++ for several yearsat the end of the '90 and '00 beginnings

Cat

Ceylon

  • interesting, it says that:

    Ceylon's powerful flow-sensitive static type system catches many bugs while letting you express more, more easily: union and intersection types, tuples, function types, mixin inheritance, enumerated types, and reified generics.

  • and has rather flexible syntax
  • http://ceylon-lang.org/

Chapel

  • http://learnxinyminutes.com/docs/chapel/
  • A quick impression of the language:

    After skimming the page it looks rather similar to Nim. Chapel looks like it wants to be a systems programming language with special focus on concurrency and parallel computation. It's statically typed with local type inference. It supports product types with tuples, but I don't see sum types or (G)ADTs in general. It has numeric types with explicit range, like Ada or Nim (that is without dependent types). It supports generics, with a very lightweight syntax (ie. lack of any syntax). Supports in/out/inout parameters like C#. Supports operator overloading. Has iterators. Supports class-based OO with destructors (so probably is not GCed?). Has coroutines as a main concurrency construct. It has "sync" keyword, but I don't have the time to look at it in depth to know how it works.

    It looks like it's somewhere between C and Java, like Nim, Rust and a couple other languages. From a quick glance I can't tell if the language is garbage collected and I don't really know how the concurrency and parallelism really work in the language. Still, it looks rather nice and I suspect you'd use it any time you otherwise use C with pthreads.

Chicken Scheme   Lisp

  • http://www.call-cc.org/
  • many packages available via chicken-install
    • especially interesting: sxpath works (it didn't for Racket)
    • [2017-04-08 sob] SXPath still doesn't work for Racket! I guess I'll need to fix it myself…
  • at least twice as fast as Python for my purposes when compiled (via C)

Clamato   JS Smalltalk

Clean

Clojure   Lisp

  • http://clojure.org/
  • a Lisp for JVM
  • it's irritating because of JVM…
  • …it's also very powerful because of JVM…
  • immutability by default and nice support for concurrency
  • syntax improvements, less parens than usual
  • syntactic support for maps and vectors (besides lists)
  • simple pattern-matching

ClojureScript   JS Lisp

Cobra   dotNET

CoffeeScript   JS

  • http://coffeescript.org/
  • the first compile-to-JS-but-leave-the-semantics-untouched language that gained traction
  • I used it for a bit when it came out
  • I then went for LiveScript, so I don't have much to say on Coffee
  • But there are interesting languages forked from Coffee, like mentioned LS and now Imba

Common Lisp   Lisp Native

  • the most direct descendand of original LISP from the '50ies
  • quite a large language, defined in its specification and documented in http://www.lispworks.com/documentation/HyperSpec/Front/index.htm
  • supports procedural, functional and object-oriented programming
  • has variety of implementations; some may compile to native code
  • supports reflection, very late binding and redefinition of everything on runtime
  • supports optional type definitions, which may be used for optimizations
  • I learned it because I use StumpWM, which is a great Window Manager for X, written in CL: http://stumpwm.github.io

Crack

  • http://www.mindhog.net/~mmuller/projects/crack/Manual-0.9.html
  • Major Influences: C, C++, Java, Python
  • Syntax: C-style, curly-brace
  • Typing: Static, strong (with some implicit conversion)
  • Compiler: native compiled, either JIT (at runtime) or AOT (native binary)
  • Paradigms: Object oriented, procedural
  • Garbage Collection: Reference counted objects, programmer controlled
  • OO Features: Virtual functions, overloaded functions, multiple inheritance, generics.

Curry

Added on: [2015-02-25 śro]

Dylan/OpenDylan

E

Earl Grey   JS

Ela

Elixir

Elm   JS

Emacs Lisp   Lisp

  • a Lisp-2 used for scripting Emacs
  • recently it got lexical scoping
  • it also has a 'cl-lib - a library of Common Lisp-style macros

Erlang

  • I have quite some code written in it

F#   dotNET

F*

Added on: 2015-09-19

  • summarized rather well in its introduction

    F* (pronounced F star) is an ML-like functional programming language aimed at program verification. Its type system is based on a core that resembles System Fω (hence the name), but is extended with (full) dependent types, monadic effects, refinement types, and a weakest precondition calculus. Together, these features allow expressing precise and compact specifications for programs, including functional correctness properties. The F* type-checker aims to prove that programs meet their specifications using a combination of SMT solving and manual proofs. Programs written in F* can be translated to OCaml or F# for execution.

  • https://www.fstar-lang.org/

F-Script   Smalltalk

Fantom

Felix

Forth

Gravity

Added on: [2017-04-08 sob]

Haxe

  • http://haxe.org/
  • a language and toolchain optimized for compiling to many targets
  • supports PHP, Flash, JS, C++ and Java backends, among others
  • static typing, ADT, generics, extending existing classes
  • macros, class-based OO

Hoon

[2016-06-02 czw]

  • https://urbit.org/docs/hoon/
  • a language used by Urbit
  • purely functional, but with imperative-like features
  • very terse syntax, rivalling J and APL I think
  • compiles down to "low level funtional assembly"
  • has a formally verified interpreter?

Hot Cocoa Lisp   JS

TODO Hotel

Added on: [2017-03-08 śro]

  • https://github.com/onnlucky/hotel
  • High-level, dynamic language
  • focused on creating high level abstractions
  • claims to disallow any global effects other than I/O (isn't it the same as Erlang?)
  • may be interesting in a couple of years

Hy   Lisp

Idris

  • http://www.idris-lang.org/
  • full-dependently typed, pure, eager functional language
  • better than Agda and Coq by a large margin
  • described in "Seven More Languages in Seven Weeks"

Imba   JS

Added on: [2015-08-16 ndz]

  • https://github.com/somebee/imba
  • forked from CoffeeScript in 2012
  • made more JS-like in syntax
  • currently (2015-08-20) it lacks documention, so I will need to find the time to read the sources
  • it supposedly contains a virtual DOM implementation and supports XML literals (for the ignorant masses known as 'JSX'…)

Inform 7

Io

Ioke   JVM

  • https://ioke.org/
  • inspired by Io, but running on JVM
  • homoiconic, fully dynamic, prototype oriented OOP
  • still experimental, not production ready

Irken

J

  • http://code.jsoftware.com/
  • designed by Ken Iverson, one of the Ancient Programming Gods
  • it uses freakishly alien computation model, with absolutely nothing in common with any other language
  • except for APL of course
  • good for simulations, number crunching, dealing with tables of any kind
  • takes long to learn: on par with C++ (including learning some more advanced features)
  • takes being Iverson to master?

JavaScript

Added on: [2015-11-16 pon]

  • well, for now I see JS mostly as a compilation target…
  • but it does evolve and acquires interesting features
  • may be worth looking into (again) in the future

Jisp   JS Lisp

  • http://jisp.io/
  • Clojure-inspired JS sexpr syntax
  • partly or completely abandoned, this is what the author has to say about that:

    There's been a hiatus in updates. Mostly it's because I'm busy with other projects. Another part of the reason is that my views on JS have underwent a complete 180°. (Please mentally apply a vintage filter to everything else you read in this documentation.) JS doesn't need lispy features or macros because of its polymorphism and flexibility. Problems solved with macros are usually better solved with apt program architecture and using the language to its fullest. Preprocessors tend to be detrimental to the latter part.

  • of course, I disagree completely - JS syntax is a major PITA…

Joy

Added on: [2017-03-08 śro]

  • https://github.com/calroc/joypy
  • a functional, stack-based language
  • I couldn't get original implementation to work
  • but fortunately someone made a Python-based implementation
  • may be a good way to finally learn what is it all about

jq

  • https://stedolan.github.io/jq/
  • a DSL for JSON data manipulation
  • which happens to be a full blown functional language
  • (I assume this happened by accident, like with C++ templates)
  • written in C and command-line use optimized

TODO Kayia

Added on: [2017-03-08 śro]

  • http://kayia.org/
  • integrated, reactive
  • looks interesting, need find some time to try it out

Kernel (Klisp)

Khepri   JS

Ki   JS Lisp

WAITING Kitten

Koka

Added on: [2015-09-19 sob]

  • http://www.rise4fun.com/koka/tutorial
  • JavaScript-like language with strong typing
  • also tracks kinds of effects in the type system
  • (that dreaded word which starts with "M" would fit here)
  • very interesting language!

    Of course its dead now, no longer maintained and so on, but the idea seems very intriguing. I see this as a next step after F# with its workflows. The only conceptual difference now is that all the code runs in some workflow; this means that you have to add one additional workflow, called something like Normal. All the code that's not run in explicit workflows runs in the Normal workflow.

L++

Added on: [2016-05-13 ptk]

TODO Lily

Added on: [2017-04-08 sob]

LISP/c

Added on: [2016-05-13 ptk]

LispyScript   JS Lisp

LittleSmallScript   JS Smalltalk

LiveScript   JS

Added: [2013-11-14 czw 23:49]

  • http://livescript.net/#installation
  • it's really sweet little language which makes functional programming in JS really awesome
  • I got a little fix into it: https://github.com/gkz/LiveScript/pull/541
  • [2016-06-02 czw] nowadays I (unfortunately) use ES6/7 transpilers more than LS

    It became harder to smuggle LiveScript into a project once CoffeeScript fell out of favour. LiveScript still has many very nice features which I miss dearly, but ES6 is not that bad. Still, for its time, LiveScript was a very fun langugage to learn and use. I still use it in some personal projects.

Lua

  • http://www.lua.org/
  • mostly known as an embeddable scripting language
  • Baldur's Gate, MUSHClient, Redis, Nginx and much more use Lua for scripting
  • Lua is a simple language with very few primitives.
  • It sports a prototype-based OO programming for those so inclined
  • Lua is fast, and LuaJIT is blazingly fast and made by an alien robot from the future ;-)
  • MoonScript is to Lua what CoffeeScript is to JavaScript
  • Lua has a very simple syntax without much syntactic sugar, Moonscript fixes this

Mercury

Added on: [2014-04-16 śro]

Myrrdin

Updated on: [2017-03-08 śro]

  • http://eigenstate.org/myrddin/
  • described as "C with Generics"
  • statically typed and AOT compiled to native
  • ADT, pattern matching, type inference, package system
  • low level control, like in C

Neko

Nemerle   dotNET

NewLISP   Lisp

Newspeak   Smalltalk

Nf

Nial

Nim

  • http://nim-lang.org/
  • nice: clean, expressive, compiled and fast
  • on the other hand, it's an alpha-grade software: there are bugs
  • (but that's normal and will improve with time)
  • https://nim-by-example.github.io/oop_macro/
  • some features:
    • (from: http://hookrace.net/blog/what-is-special-about-nim/)
    • Run regular code at compile time
    • Extend the language (AST templates and macros);
      • this can be used to add a form of list comprehensions to the language
      • also, you can add your own optimizations to the compiler
    • Bind (easily) to your favorite C functions and libraries
    • Control when and for how long the garbage collector runs
    • Type safe sets and arrays of enums
    • Unified Call Syntax, so mystr.len() is equivalent to len(mystr)
    • Good performance - C level in micro-benchmarks
    • Compile to JavaScript
  • it has a package manager, called Nimble
    • it mostly works out of the box, comparable to pip, npm, lein, etc.
    • it works only for packages, not for Nim installations (like virtualenv or opam)
    • has ~270 packages in the repository, which is quite nice for a language this young

None

Nu   Lisp

TODO Oberon

OCaml

  • http://ocaml.org/
  • oo&functional, impure, eager, static typing with global type inference (HM style)
  • and ofc with module system, both bytecode and native compiler, nice async
  • compile-to-js and many more interesting features
  • has OPAM, native package manager and utop, IPython-like top-level (REPL)
  • my first real functional language

ooc

Added on: [2015-11-16 pon]

  • https://ooc-lang.org/
  • I encountered it a long time ago, along with Zimbu I think
  • compiles to C, static typing with inference
  • clean, minimal syntax

Opa

  • http://opalang.org/
  • a language and a framework for writing web apps
  • compiled to JS both on backend and frontend

Oz

Added on: [2015-02-25 śro]

TODO P

Added on: [2016-10-27 czw]

ParenScript   JS Lisp

Pascal

  • procedural language with static typing
  • its implementation Turbo Pascal was very popular when I started programming
  • its extension called Object Pascal provides an IDE and RAD capabilities
  • Delphi is one such tool for rapid development

Pharo   Smalltalk

  • http://pharo.org/
  • PBE2 (aka. Deep into Pharo)
  • I have a couple of simple projects done in it
    • package management is not the easiest, but it gets better
    • Pharo has its own versioning system (Monticello) and pkg management tool (Metacello)
    • Gofer is another package which helps with installing packages
    • there are many repositories with packages, no central repo like in Node, Python, Ruby…
    • one such repository is: http://smalltalkhub.com/
    • there is a problem, however: Smalltalk people like to use strange names for packages, like Pomodoro, Magritte, Ephestos, Epicea…
    • …but they apparently HATE writing descriptions for packages explaining what they do
    • in effect, you need to Google every second package name to learn what the heck it is
    • (the rest - installing the package - is easy…)

PHP

  • I worked with PHP a bit, I think it was 5.4 edition of the language
  • I don't remember much, but a couple of things that I can't forget:

    *

PicoLisp   Lisp

Pike

PogoScript   JS

  • http://pogoscript.org/
  • very flexible function definition syntax

    Allows for both defining and calling functions with arguments inserted between parts of a function name. This is similar to Avail.

  • adds primitives for async operations, transforms to CPS under the hood

Pony

Added on: [2015-11-16 pon]

  • http://www.ponylang.org/
  • https://github.com/CausalityLtd/ponyc
  • statically typed, with type system guaranteeing sharing/aliasing semantics
  • actor-based concurrency, built into method calls via behaviours
  • both nominal (traits) and structural (interface`) typing
  • classes, extending classes, no inheritance for classes (composition over inheritance)

PowerShell

  • http://powershell.com/cs/
  • Windows specific shell language
  • procedural, giving access to all of .NET
  • makes shell "pipes" (with | operator) into streams of objects

Prolog

PureScript   JS

TODO Pyret

Added on: [2017-03-08 śro]

  • https://www.pyret.org/
  • scripting language with functional capabilities
  • some more advanced features like pattern matching, built-in tests and type annotation
  • algebraic data types
  • syntactically resembles Lua, Python and possibly Ruby

Python

Added (for completeness) on: [2017-03-08 śro]

  • my main language at work and for some of my hobby projects
  • it manages to be quite a good, hybrid (imperative/OO/FP) language

Racket   Lisp

  • http://racket-lang.org
  • I did a little writeup on Racket when working on Bezier curves forget it, I'm writing a new version [2017-04-03 pon]
  • in general, my first Lisp; still very impressive
  • includes TONS of features, some of which are unique to Racket
    • strong contracts support
    • typed and lazy dialects
    • interesting object system with classes and mixins

Red

Added: [2013-12-13 ptk 22:56]

  • http://www.red-lang.org/
  • REBOL-inspired open source language
  • simple and extensible syntax, very small footprint (500Kb runtime + tools )
  • both compiled and interpreted, with cross-compiling capabilities (planned)
  • there's an interesting interview with Red author
  • it reminds me of Lisp and TCL (by the words of its author "it's in the Lisp family") in that it's:
    • homoiconic (but the syntax is more similar to TCL or Smalltalk than Lisp)
    • supports syntactic abstraction so you can implement your own loops etc.
    • basically every command can parse the remainder symbols however it wants
    • it has blocks, which are transparent and open for interpretation (unlike lambdas)
  • some interesting one-liners (largely the same as in REBOL IIRC):
    view layout [button “Click Me” [print “Hello”]]
    print read http://rebol.com
    parse read http://rebol.com [thru <title> copy text to </title> (print text)]
    send user@domain.com mold read %.
    foreach row read/custom mysql://root@localhost/books [“SELECT * FROM authors”] [print row]
    

Redline Smalltalk   Smalltalk

Ruby

  • https://www.ruby-lang.org/en/
  • I had a bit of a plugin for Emacs written in Ruby, so I had to learn a bit
  • it's familiar to me because of its Smalltalk roots

Rust

Added on: [2014-01-26 ndz 00:22]

  • http://doc.rust-lang.org/
  • Systems-programming language from Mozilla
  • focused on type- and memory-safety by default
  • focused on concurrency
  • incorporates the notion of ownership into type system

Sather

Scala

Added: [2013-12-08 ndz 00:58]

  • http://www.scala-lang.org/
  • FP/OO language for JVM, with seamless interop
  • "flexible" syntax (that is, full of special cases)
  • powerful static type system with local type inference
  • you can choose immutability or mutability (vars, collections)
  • supports dynamic, duck-typing-style structural subtyping too

Shen   Lisp

Shill

Added on: [2017-03-08 śro]

  • http://shill.seas.harvard.edu/
  • A shell-scripting language, which focuses on controlling privilages of running scripts
  • written in Racket and apparently only working on FreeBSD for now

Slate

Sparkling

Added on: [2015-11-16 pon]

Spry (formerly Ni)

Added on: [2015-09-19 sob]

  • https://github.com/gokr/ni
  • Smalltalk and REBOL influenced language
  • "homoiconic without parentheses"
  • with some influences from Nim, apparently
  • somewhat-active repository

TODO Squirrel

Updated on: [2017-03-08 śro]

  • https://github.com/albertodemichelis/squirrel
  • the features:
    • Open Source MIT licence
    • dynamic typing
    • delegation
    • classes & inheritance
    • higher order functions
    • lexical scoping
    • generators
    • cooperative threads(coroutines)
    • tail recursion
    • exception handling
    • automatic memory management (CPU bursts free; mixed approach ref counting/GC)
    • both compiler and virtual machine fit together in about 7k lines of C++ code and add only around 100kb-150kb the executable size.
    • optional 16bits characters strings
    • powerful embedding api
      • eg. function/classes can be defined by scripts or in C
      • eg. objects can fully exist in the VM or be bound to native code
      • eg. classes created in C can be extended by scripts or vice-versa
      • and more
  • fast, embeddable language with full OOP support

Swift

  • successor to Obj-C
  • some functional features on top of otherwise OO system
  • from Apple for Appleites, forever

TODO szl

Added on: [2016-10-27 czw]

TaijiLang   JS

Tcl

Terra

Added on: [2015-08-02 ndz]

  • http://terralang.org/
  • a new low-level language designed for interoperability with Lua
  • it extends Lua with a couple of keywords and constructs related to static typing and such
  • looks somewhat like Cython, but not quite

Tulip

Added on: [2015-07-04 sob]

Txr

  • http://www.nongnu.org/txr/
  • practical language for text manipulation and data extraction
  • sounds like PERL, but isn't
  • includes a full-blown Lisp-2 implementation
  • is focused on matching patterns in incoming data

Vala

wisp   JS Lisp

Wren

XSLT/XPath

  • language for transforming XML documents
  • it's a pure functional, dynamically typed language with XML syntax
  • based on pattern matching and recursion
  • most implementations allow for extension
  • http://en.wikipedia.org/wiki/XSLT

Zimbu

Added on: [2015-11-16 pon]

  • http://www.zimbu.org/
  • I found it some three years ago
  • according to HN comments, similar to ooc
  • written by Bram Moolenaar, the author of Vim