Skip to content

Existing system language survey

Jump to bottom
Andreas Reischuck edited this page May 28, 2017 · 2 revisions

A list of acknowledgable system programming languages.

We should not take features that don't fit our goals. But it's always good to take terminology and inspirations.

C

http://www.open-std.org/jtc1/sc22/wg14/

very mature system programming language.

  • the PC world is build on C
  • well defined ABI and calling conventions
  • no required std library (only what you use)
  • all burden for resource management on developers
  • only precompiler macros
  • depends on precompiler "#include"-system
  • no standard for error handling
  • no std for higher level concurrent concepts

C++

https://isocpp.org/

modern system development language

  • native OOP support
  • large scale of abstractions
  • code and type generation with templates
  • RAII resource management
  • exceptions
  • depends on precompiler "#include"-system
  • tends to slow compile times
  • templates use verbose syntax and have limitations
  • no defined ABI
  • requires a std-library runtime for many features

D

https://dlang.org/

language to replace C & C++.

  • module and import system
  • no precompiler or macros
  • not mandatory garbage collector (allows faster prototyping)
  • RAII and scope actions
  • interface & class OOP
  • rich compile time execution
  • templates, constraints, traits, mixins, reflection
  • module/import system
  • text based mixins (basically string based macros)
  • bad error messages (eg. no indication which constraint failed)
  • no easy initialization patterns for classes
  • does not feel polished (eg. templates constructors cannot be called, weak pointers are missing)
  • no ABI guarantees

Go

https://golang.org/

server programming language

  • no external runtime required
  • package/import system
  • omitable parenthesis & semicolons
  • channel based goroutines (allows stacked coroutine)
  • garbage collector
  • no scopes for member function

Pony

http://www.ponylang.org/

actor-model, capabilities-secure, high performance programming language

  • directory based package/use system
  • language based actors
  • actor based garbage collector (faster than other options)
  • full soundness check on compile time
  • type expressions
  • actor based garbage collector (not zero abstraction)
  • only simple generics
  • not very mature (0.2.1)

Crystal

http://crystal-lang.org/

ruby inspired syntax with static typing & compile-time evaluation

  • explicit, easy to read syntax
  • ast based templating macro system (mustache syntax)
  • fiber & channel based actor concurrency
  • require system (basically #include)
  • garbage collector
  • no parallelism so far
  • still alpha

Rust

https://www.rust-lang.org/

systems programming language with compile time safety

  • sane defaults (const vs. mut, ...)
  • guaranteed memory safety (borrow system)
  • ast based pattern matching macro system
  • module/use system with explicit publishing
  • package manager crates.io included
  • no garbage collector
  • limited generics (trade off for safety features without long compile times)
  • very strict compiler (stdlib can do stuff users cannot)
  • hard to learn for classical OOP programmers
  • not all libraries

Swift

https://developer.apple.com/swift/

modern system programming language from Apple to superseed C and Objective C

  • module/import system
  • Taylored to Apple platforms
  • ARC for memory management
  • Limited generics system
  • Language wired features (properties, protocols, weak, ...)
  • No macro system (Only conditional compiling)

Felix

http://felix-lang.org/

High performance scripting language.

  • differentiates fun, proc & gen methods
  • coroutines
  • garbage collector
  • very magically (all built in)

Sylph

https://eev.ee/blog/2015/02/28/sylph-the-programming-language-i-want/

a collection of thoughts on a better language.

  • non existing (only a blog post of wishes and opinions)

Jai

https://www.youtube.com/playlist?list=PLmV5I2fxaiCKfxMBrNsU1kgKJXD3PkyxO

Jonathan Blows game programming language.

  • Structure of Array support
  • Run any code as compile time script
  • Imperative meta programming with compiler events and AST
  • In code build system
  • no public code (only Youtube videos)
  • hard focus to game development

Zig

http://ziglang.org/

Andrew Kellys system programming language. It aims to be simple and easy to use.

  • Sane array syntax
  • Every array carries its length
  • Array slices
  • Can parse C header files
  • Support for embedded assembler
  • still in early development
  • not much documentation
Clone this wiki locally