see also [1]
categorized list of some languages to learn/study
partially based on [2] chapters "my favorite languages" and "everyone else's favorite languages":
Due to their extreme popularity and belovedness by people who use them:
Due to their belovedness by people who use them:
- Haskell
- Go
- Lua
- Racket
- Clojure
- Common Lisp
Due to extreme popularity:
- Java (note: hated)
- PHP (note: hated)
- Javascript
- Objective-C
Due to high popularity combined with high belovedness:
Due to moderate popularity combined with moderate belovedness:
To learn other paradigms:
Because people who have done impressive things (in the programming language area) are involved:
Because they are new languages that are often mentioned:
Because they are languages or packages that sound up my alley or that probably have something to teach me:
| parent [-] | on: OCaml 4.03: Everything else. "There's one language I know that gives nearly all of those things, which is Ur (of the ur/web framework fame). Modules, type classes, eager evaluation, HKTs. It even adds features that aren't in either language such as first-class records and row polymorphism, type-level programming, macros and probably more. It's apparently very high performance, and even has a nice C FFI. The major downside is that it's only meant to be used for writing web servers, and for whatever reason, despite the huge number of features it supports, there seems to be little demand (or effort) to broaden its usage beyond this role. It also suffers from poor documentation, both from a language manual perspective as well as the compiler itself, which quite frankly has some of the sparsest comments I've ever seen in a code base of its size (when I was perusing before, there were practically zero comments across tens of thousands of lines of code). So yeah, probably not headed for the mainstream in its current state. Also I don't think there's much in regards to parallism in the language, although this might be able to be put in a library ¯\_(ツ)_/¯"...catnaroek agrees. |
- https://en.wikipedia.org/wiki/Esterel (b/c https://news.ycombinator.com/item?id=14239170 )
- http://c0.typesafety.net/
- http://ziglang.org/
- https://github.com/ethereum/viper
- kadena.io/pact
- https://github.com/pirapira/bamboo
- http://xoofx.com/blog/2017/01/17/the-stark-programming-language-experiment/
- Kragen's Bicicleta: http://archive.li/e3lZU https://www.mail-archive.com/kragen-tol@canonical.org/msg00162.html
- "You might find Isle interesting (https://github.com/gvx/isle). It is a small programming language I've designed and implemented a couple of years ago heavily inspired by Lua's "everything is a table". In it, a function call looks like a name concatenated to a table literal, and calling a function actually consists of creating that table and using it as the environment for the function."
- http://coconut-lang.org/
- https://web.archive.org/web/20190404163415/http://strlen.com/lobster/; i already read the first half, so start reading at "Types, multimethods, immutables and vector ops:"
- COLA stuff
- https://futhark-lang.org/index.html
- https://cseweb.ucsd.edu/~wgg/CSE131B/oberon2.htm
- https://pisc.junglecoder.com/home/apps/fossil/PISC.fossil/home
- Dylan and Rebol?
- http://sprylang.se/
- objective-C (read the David Chisnall articles (the ones at informit) in the plChCtmLangs section on Objective-C)
- https://github.com/arturo-lang/arturo/wiki https://news.ycombinator.com/item?id=24834636
- https://github.com/titzer/virgil
- https://github.com/google/wuffs/blob/main/doc/wuffs-the-language.md
- https://docs.microsoft.com/en-us/cpp/code-quality/using-sal-annotations-to-reduce-c-cpp-code-defects?view=msvc-160
- https://www.cs.cmu.edu/~fp/courses/15122-f10/lectures/25-sal.pdf
- Popular annotations in Windows SALCount _In_1961906_Out_381083_In_opt_253496_Inout_185008_Outptr_99447_In_reads_(size)71217_Out_opt_63749_Out_writes_(size)56330_In_reads_bytes_(size)43448_Out_writes_bytes_(size)19888_Inout_opt_18845_In_z_17932_Inout_updates_(size)14566_Out_writes_opt_(size)12701_In_reads_opt_(size)12247_Outptr_result_maybenull_(size)12054_Outptr_result_buffer_(size)9597_In_reads_bytes_opt_(size)9138_Outptr_result_bytebuffer_(size)7693_Out_writes_bytes_opt_(size)7667_Outptr_opt_6231_Out_writes_to_(size, count)5498
- https://wiki.alopex.li/GarnetLanguageV2 (dont know anything about it but i think it's cool that this guy has a notes wiki; this guy did https://wiki.alopex.li/LanguageCompilationSpeed; mb see also older version https://wiki.alopex.li/GarnetLanguage ; i think this guy (later?) discovered and liked Rust)
- https://thakeenathees.github.io/pocketlang/getting-started-learn-in-15-minutes.html
- https://monte.readthedocs.io/en/latest/taste.html
- http://bloom-lang.net/
- A Bestiary of Single-File Implementations of Programming Languages: has a lot of small languages and variant subsets of languages
- https://gist.github.com/cellularmitosis/1f55f9679f064bcff02905acb44ca510 : has a lot of small languages and variant subsets of languages
- "Well, most mainstream languages are dialects of Lisp (though usually with syntax, records, methods, and sometimes static typing) so if you strip them down far enough you get Lisp. Other reasonably usable minimal programming languages do exist, like the lambda-calculus, the pi-calculus, Abadí and Cardelli's object calculus, the ur-Forth, and the ur-Smalltalk, but they're not as familiar." -- kragen
- https://github.com/vrtbl/passerine
- Oberon-0 (the successor to PL/0); defined in https://people.inf.ethz.ch/wirth/CompilerConstruction/ Chapter 6 (https://people.inf.ethz.ch/wirth/CompilerConstruction/CompilerConstruction1.pdf PDF page 30)
- https://www.ldpl-lang.org/
- mb https://pisc.junglecoder.com/home/apps/fossil/PISC.fossil/home
- https://lobste.rs/s/echyqc/bestiary_single_file_implementations
- mb https://gavinhoward.com/tag/yao/ https://docs.yzena.com/yc/master/yao/main.html
- mb https://en.wikipedia.org/wiki/T_(programming_language) TIC-80 langs:
- "TIC-80 has 80k of RAM and accepts 64k of user code of any of: Lua, Moonscript, Javascript (using Duktape, which claims to be full JS, not a subset), Wren, and Fennel"
- cowlark (the Golang vs Brand X guy)'s little languages:
- http://cowlark.com/cowgol/ "an experimental, Ada-inspired language for very small systems (6502, Z80, etc). It’s different because it’s intended to be self-hosted on these devices"
- http://cowlark.com/calculon/index.html "a very simple but very fast programming language designed to be embedded into other programs. It uses LLVM to generate high-quality machine code and is ideal for shaders, user-supplied mathematical formulae, etc. The Calculon language itself is a pure functional language with support for upvalues, tail recursion, and bindings to the standard maths library. It supports 3-vectors, reals and booleans as first-class values. "
- http://cowlark.com/cowbel/index.html "cowbel is a minimalist but expressive statically typed programming language which compiles into real machine code via C. It has generics, interfaces, a garbage collector, non-nullable types, an object-oriented system based on interfaces and composition, and features a familiar Javascript-like syntax. The purpose of cowbel is to fit the niche where hard-core systems languages like C or C++ are too much work, but dynamic or virtual-machine languages like Python or Java are too heavyweight."
- *Lisp (Connection Machine StarLisp?): http://www.softwarepreservation.org/projects/LISP/parallel#Connection_Machine_*Lisp_(StarLisp)
- https://justine.lol/lambda/
- https://derw-lang.github.io/
- https://myrlang.org/
- https://github.com/lojikil/coastML
- https://github.com/vmware/differential-datalog
- http://squirrel-lang.org/
- https://vale.dev/
- https://github.com/Kindelia/Kind
- https://www.passerine.io/
- https://hg.sr.ht/~icefox/garnet
- https://antelang.org/
- https://news.ycombinator.com/item?id=31775216
- "Looking through the language tour there already seem to be a plethora of very sensible/ergonomic design decisions here. The 'loop' and 'recur' keywords are a great feature, making a nice little functional nod towards while loops. As a long-time Haskell user the explicit currying initially turned me off, but after seeing a couple examples I can see how it's actually a very reasonable solution, and moreover the ability to curry out of order is really nice instead of having to use 'flip' or similar combinators (as a side note, the explicit currying reminds me a bit of APL's α and ω arguments in dfns, a feature I'd love to see pop up more). The paired tuples also seem like they'd be a pleasure to use; certainly a bit more flexible than tuples in other ML style langs. Making '.' the pipeline operator is also a smart bit of syntax, and I can see it being very accessible to OO programmers in that it looks (and acts) like the method chaining they're familiar with. Refinement Types seem like a good alternative to full on dependent typing (ATS has an analogous (and more general) proof system for ensuring things like array indices are valid (an essential feature in a low level FP lang), but it involves threading those proofs through your program which seems much more clunky than what's presented here)."
- https://lobste.rs/s/02tu4z/ante_low_level_functional_language
- caml light
- ""better C" language like Odin, Zig, Jai, C3, etc."
- https://odin-lang.org/docs/overview/
- http://www.complang.tuwien.ac.at/anton/euroforth/ef13/papers/ertl-paf.pdf
- https://www.val-lang.dev/
- https://simon.peytonjones.org/assets/pdfs/haskell-exchange-22.pdf
- https://koka-lang.github.io/koka/doc/book.html
- "Gibbon, an experiment language design based on the idea of keeping the in-memory representation of tree-shaped data identical to a compact serialization format (relative offsets rather than pointers, etc.)." http://iu-parfunc.github.io/gibbon/
- https://sr.ht/~icefox/garnet/
- https://rhovas.dev/
- partcl (i like how he made the lexer etc good for small memory implementations): https://zserge.com/posts/tcl-interpreter/
- https://berry-lang.github.io/
languages with a small implementation:
oft-mentioned languages with formal verification:
- F*
- Dafny
- Why3
- mb Chalice (this guy mentions it at least [9] )
oft-mentioned languages with formal semantics:
bookmarked for some reason, i forgot why:
Frameworks:
- CLOS
- Perl Moose
- ?Sage theorem prover
- rails
- flask
- everything in 'codebases to read', above
- angular
- d3
- nanomsg
- datomic
Target languages:
- Inferno's Dis
- Dalvik
- asm.js
- JVM
- CLR's CIL
- LLVM
- CPython bytecode
- Parrot, Parrot M0
- MoarVM?
- Smalltalk VM
- GHC Core, STG, Cmm (C--)
- LuaVM?
- NekoVM?
mildly filtered/prioritized list of languages to learn/study
Due to popularity and/or belovedness:
- C
- Python
- Haskell
- Go
- Lua
- Racket
- Clojure
- Common Lisp
- SQL
- C#
Due to popularity only, or popularity/belovedness plus personal interest:
- Java (note: hated)
- PHP (note: hated)
- Javascript
- Rust
To learn new paradigms:
Because people who have done impressive things (in the programming language area) are involved:
- Hoon (the impressive thing is Nock)
- Oberon-07 (and modula-3?)
- Arc
- https://en.wikipedia.org/wiki/Scratch_%28programming_language%29
- Glew, Sweeney, Petersen's Lambda Aleph: http://arxiv.org/pdf/1307.5277.pdf N. Glew, T. Sweeney, and L. Petersen. A multivalued language with a dependent type system. In Dependently Typed Programming. ACM, Sept. 2013.
- http://wren.io/ https://github.com/munificent/wren [10] ("> I was inspired by the size of Lua's VM, but deterred by its obscurity (and lack of inline documentation), so my original goal was to create a very clean and minimal VM." "Me too, so I created Wren... It's about the same size as Lua, significantly faster, and much more thoroughly documented. I also like the language itself more — it's object model is more familiar to someone coming from Java/C++/C#/etc...")
Because they are new languages that are often mentioned:
- Perl 6
- Julia
- D
- coffescript
- elixir
- nimrod (nim)
- http://moonscript.org/ (mentioned in http://neovim.org/news/2014/sept/ https://github.com/neovim/neovim/issues/207 )
- http://livescript.net/ https://en.wikipedia.org/wiki/LiveScript (recc. by https://news.ycombinator.com/item?id=10541081 )
- Swift
- kotlin
- mb: Oden (Go + generics + some other stuff? also has an interesting implementation: "Oden’s first compiler was written in Racket while its type inferencer was developed using MiniKanren?, a relational programming language embedded in Scheme. The compiler was then rewritten using Haskell. ")
- mb: Crystal (gradual typing, macros, FFI): https://news.ycombinator.com/item?id=12223395
- https://c3.handmade.network/blog/p/8486-the_case_against_a_c_alternative mentions Zig, Odin, Jai, also C3, as C replacements, and D, Rust, Nim, Crystal, Beef, Carbon as C++ replacements.
- some comparisons:
- virgil
- ante
- roc (a general-purpose Elm) https://github.com/roc-lang/roc/blob/main/roc-for-elm-programmers.md https://lobste.rs/s/vnjt6x/roc_is_language_for_making_delightful https://github.com/roc-lang/roc https://www.roc-lang.org/
Because they are languages or packages that sound up my alley or that probably have something to teach me:
- https://janet-lang.org/index.html
- Shen
- OMeta
- Powershell
- https://gleam.run/
- Inferno shell https://github.com/pete/euler/blob/master/infernosh/031.sh https://github.com/pete/euler/blob/master/bash/031.sh
- R
- OCaml (interestingly, many compilers are written in OCaml, such as Haxe)
- metalua
- metaocaml
- http://www.pyret.org/
- Dylan
- PLOT
- scala
- bitc
- perl5
- some of readevalprintlove's mentions:
- some of http://readevalprintlove.fogus.me/sakura/index.html (now at http://replove.herokuapp.com/ ) 's practical lisps: Common Lisp, Clojure, Scheme (R5RS, R6RS, R7RS-big), Racket, Dylan
- http://readevalprintlove.fogus.me/sakura/index.html 's kernel lisps: R7RS-small, Scheme48, Lisp Machine Lisp, EuLisp?, and Kawa. (and shouldn't we add the new one called 'kernel')
- http://readevalprintlove.fogus.me/sakura/index.html 's figure "
- read the rest of * http://readevalprintlove.fogus.me/sakura/index.html
- http://readevalprintlove.fogus.me/sakura/index.html 's Fluchtpunkt Lisps: T ( http://mumble.net/~jar/tproject/ ) , shen, http://www.newlisp.org/ , arc, PicoLisp? , Wasp Lisp
- http://readevalprintlove.fogus.me/sakura/index.html : "PicoLisp? is, in my opinion, the most interesting entry in a family of really really small Lisps that also includes Nanolisp and femtoLisp, although I would hesitate to include these latter two in the Fluchtpunkt category"
- similar to previous bullet point, the Lisp in The Roots of Lisp
- unix commandline tools
- awk
- sed
- kernel http://web.cs.wpi.edu/~jshutt/kernel.html
- https://github.com/nineties/amber/tree/master/amber ; the implementation of it looks very multistage and clean judging by this slide presentation: https://speakerdeck.com/nineties/creating-a-language-using-only-assembly-language
- https://ioke.org/ (recc. by http://lebo.io/2015/03/02/steve-yegges-next-big-language-revisited.html )
- https://github.com/aaron-lebo/prose (this guy wrote the blog posts http://lebo.io/2015/06/22/the-unix-philosophy-and-elixir-as-an-alternative-to-go.html and http://lebo.io/2015/03/02/steve-yegges-next-big-language-revisited.html ) and recommended Ioke)
- http://www.wolfram.com/language/fast-introduction-for-programmers/
- https://github.com/tibru/tibru (Nock alternative)
- https://github.com/Gozala/wisp recc. by https://news.ycombinator.com/item?id=9191260
- https://jesserayadkins.github.io/lily/
- http://som-st.github.io/
- https://github.com/senshu/Reflexio
- https://github.com/liljencrantz/crush
- https://www.cell-lang.net/
- koka
- https://github.com/buzz-language/buzz
- https://www.onebigfluke.com/2023/03/a-new-functional-programming-language.html
- https://lobste.rs/s/x5avwc/verse_language_reference
- https://dt.plumbing/
- https://verdagon.dev/blog/first-regions-prototype
Misc:
Graydon Hoare (Rust founder) said in an old slide presentation about Rust: " Many older languages better than newer ones: – eg. Mesa (1977), BETA (1975), CLU (1974) ...
- We keep forgetting already-learned lessons.
- Rust picks from 80s / early 90s languages: – Nil (1981), Hermes (1990), – Erlang (1987), – Sather (1990), – Newsqueak (1988), Alef (1995), Limbo (1996), – Napier (1985, 1988). "
Frameworks:
- CLOS
- Perl Moose
- rails
- flask
- everything in 'codebases to read', below
- angular
- d3
- nanomsg
- datomic
Target languages:
- Inferno's Dis
- Dalvik
- asm.js
- JVM
- CLR's CIL
- LLVM
- CPython bytecode
- Parrot, Parrot M0
- MoarVM?
- Smalltalk VM
- GHC Core, STG, Cmm (C--)
- LuaVM?
- NekoVM?
- KLambda
- RPython
- HashLink?
codebases to read and related books
arising from [11]
todo: condense papers and books toRead for ootToReads
misc
may as well read
http://adv-r.had.co.nz/
rust vs. ruby example code in http://blog.skylight.io/introducing-helix/ section "What About My App?"
![[Home]](http://www.bayleshanks.com/cartoonbayle.png)
