Language Reviews

Sorted by overall language score

(Most) criteria values: exceptional, very good, good, ok, bad

Languages marked with [~] won't get their sections updated

Rust

  • v) Speed runtime: very good
  • v) Speed development: ok
  • v) Error handling: return
  • v) Typing: strong
  • v) Package manager: yes
  • v) it allows you to think of a function without having to think of the context surrounding the code where you call it
  • v) it allows you to express situations where you "steal" memory, say you need to merge statistics_a and statistics_b, you can simply use statistics_a.merge(statistics_b), and in the function definition you can specify that you take ownership of statistics_b
  • v) it feels much better writing code, knowing that you are not burdened with having to think of memory access patterns / when to free / weather you memory leaked
  • v) it feels much better knowing that the convention is "if something can fail, return an option or a result"
  • x) writing rust for the first time can be infuriating due to the borrow checker - a skill issue but nontheless an issue
  • x) the code can get noisy (you might have to use as usize a million times, have to write .unwrap a million times)
  • v) the community has a create for anything it seems
  • x) having a million functions chained one after the other .iter().map(|x| b c d).filter(|e| f g h).cycle().take()... can spiral out of control

Go

  • v) Speed runtime: good (worse than rust)
  • v) Speed development: good
  • v) Error handling: return
  • v) Typing: strong
  • v) Package manager: yes
  • v) simple
  • v) channels allow you to make a single-threaded program into a multitireaded one easily
  • x) no exaustive enum
  • x) camel case, abreviations capitalised, exported items start with uppercase
  • x) channels can become the bottleneck of your program
  • x) community not as crazy as rust's, no package alternatives for many of rust's
  • =) prefers to use float64 and int for everything instead of the more specialised types like float32 and int16 and so on; one one hand this is good because all data types are the same, on the other it makes it tideous to have to cast often if you want to use a specific data format

Python

  • x) Speed runtime: bad
  • v) Speed development: exceptional
  • x) Error handling: exception
  • v) Typing: strong (but you have to use basedpyright or mypy or ...)
  • v) Package manager: yes (but is best if you use venv)
  • v) simple, easy to write code for
  • x) no type checking by default
  • x) slow, even with pypy is slower than alternative languages, and pypy can become a pain if you are on windows and use many libraries
  • x) have to setup a venv and a static type checker instead of being able to use the language right away, also have to add a static type checker

C

  • v) Speed runtime: exceptional (of you bother with optimising, which might take a while since it does not come with data structures such as hashmap, ...)
  • x) Speed development: bad
  • v) Error handling: return
  • v) Typing: strong
  • x) Package manager: no
  • v) no surprises - can easily be translated into asm in your head, good for DOA
  • v) is easy to make a compiler for
  • v) build system - pick a build system, creation and maintenance cost, incremental compilation, libraries
  • x) comes with very small standard library and no package manager

C++

  • v) Speed runtime: very good (worse than C due to the false promise of 0-cost abstractions)
  • x) Speed development: bad (debugging can take ages due to the language complexity; hidden control flow; teamplates; ...)
  • x) Error handling: exception
  • v) Typing: strong
  • x) Package manager: no
  • x) full of shit
  • v) can be good if you control yourself
  • x) made obsolete by other lanuages
  • x) leeches off of C
  • x) build system (see C)
  • x) 999 different ways to do the same thing
  • v) good for your CV

Bash

  • x) Speed runtime: bad
  • v) Speed development: good
  • x) Error handling: have to use set -euo pipefail and then check $?
  • x) Typing: weak
  • x) Package manager: no
  • v) ok if you really need to do something real quick
  • x) in 99.99% of cases you are better off writing a python script

[~] Julia

  • x) Error handling: exception
  • x) lies about being able to run any code on the GPU with no efffort required

[~] Java

  • x) Error handling: exception
  • x) OOP undermines DOA
  • x) where is this situation where when the VM runs out of memory, the GC breaks it's legs trying to reclaim more memory, but it fails, so you end up in this situation where not only that your program has no memory, but now you have 1 less CPU core to work with, because it's on 100%

[~] C#

  • x) Error handling: exception

x) microsoft java