What are the best statically typed, compiled, memory safe programming languages?

Question

12

Options
Considered

153

User
Recs.

Sep 21, 2023

Last
Updated

Here’s the Deal

12 Options Considered

Best statically typed, compiled, memory safe programming languages	Price	Platforms	Current stable version
-- Golang	Free	Windows, Linux, Mac etc.	1.21.0
-- V	Free	-	-
64 Rust	Free	Linux, MacOS X, Windows, BSD	1.71.1
-- Haskell	-	-	-
-- Nim	-	Windows, Linux, Mac	-

See Full List

I Recommend...

Built By the Slant team

Find the best product instantly.

4.7 star rating

Try it now - it's free

score 23 · Answer 1

Golang

Top Pro

Great language for building networking services

Go was started as a systems language but now it has fully committed in the niche of networking services. This has been a brilliant move by Go because it allows them to capitalize on the immense talent of the Go engineering team (who are in the most part network engineers). In a world dominated by Java EE and slow scripting language, Go was a breath of fresh air and it continues to be one of the most powerful languages if you want to build networking services. See More

Top Con

Really annoying time formatting system

Everyone is used to formatting strings like Y-m-d H:i:s. Instead of going with the default, golang uses its own release time to specify the format, so Y-m-d H:i:s becomes 2006-01-02 15:04:05. Something that most go devs I know, even after years of use, still have to look up. See More

Elias Van Ootegem's Experience

I've been writing golang professionally for about 3 years now, and I have to say: It's a joy. The language is quite minimal and simple, much like one of its main influences (C). There's relatively few keywords and language constructs, making the language easy to learn. Overall the language is incredibly powerful because it borrowed just the right ideas from other languages (duck-type interfaces, channels as native types, functions as first class types, type embedding, pointers, maps, etc...). This was done without adding bloat (e.g. interfaces and structs, no classes). The very elaborate and mature toolchain is a big selling point for new gophers. Unlike other languages, go requires virtually no setup at all: install the package, use go get to get new tools, or use commands like go test, go generate, and go tool to dramatically increase your productivity. The one thing people somehow seem to be confused by in some way is the GOPATH variable, which now defaults to ~/go anyway. As a development package, go feels mature, stable, well thought out, and simple to use. The compiler is fast (especially when we compare it to rust!), Go balances nicely between the low and high levels. The language often gets criticised because some of its quirks really take time to get used to, and really only make sense if you start using them in the way it was intended. The best example of this is errors being values, not exceptions. The lack of generics is something people complain about at first quite often, and although it looks like they'll be making their debut in Go2, the times I've honestly felt a need for generics are ridiculously few and far between. TL;DR: Go was quick to learn, a lot harder to master, but was absolutely worth it. Strongly recommend. See More

Specs

Platforms:Windows, Linux, Mac etc.

Current stable version:1.21.0

Developer:Google with Ken Thompson, Robert Griesemer, Rob Pike

Top Pro

Easy to install and configure; simple to compile software

Go software can be immediately installed, regardless of your operating system, package manager, or processor architecture with the go get command. Software is compiled statically by default so there is no need to worry about software dependencies on the client system. Makefiles and headers are no longer necessary, as the package system automatically resolves dependencies, downloads source code and compiles via a single command: go build. See More

Top Con

Golang controlled by Google

Solves Google problems, which might not be your or the majority of user's problems. Was created for the benefit and purposes of Google, so is less flexible in language direction and options. See More

Top Pro

The go compiler compiles binaries instantly — as fast as a scripting language interpreter

Compiled binaries are fast — about as fast in C in most cases. Compiles on every OS without effort — truly cross-platform compiler. As a result of the fast compilation speed, you can use the gorun program to use go source code as if it was a scripting language. See More

Top Con

It appears Google uses position to snuff out or suppress other languages

Newer languages that could threaten Golang (or other Google controlled languages) appear to have suppressed search results on Google and YouTube. Dangerous situation where large company can manipulate user choice and market share. The freedom to freely choose and user rights need to be protected. See More

Top Pro

Performance is on the order of C and Java

Go is blazing fast, but easier to write than Python, JS, Ruby, or many other dynamic languages. See More

Top Con

Doesn't have true enums

Golang does weirdness with const versus having real enums, like other languages. This reflects the stubbornness and shortsightedness of the core developers, similar to the issue with generics, where it was denied that it was needed until it became too obvious that it should have been added years ago. See More

Top Pro

Syntax for exported code from a package is simplified to be less verbose than other languages

Any variable, type and function whose name begins with a capital letter will be exported by a project, while all other code remains private. There is no longer a need to signify that a piece of code is 'private' or 'public' manually. See More

Top Con

Forces K&R style and won't allow Allman style

Golang developers were extremely short-sighted and biased by forcing the K&R style, which should never have happened. Basically kicking Allman style users out of their language. See More

Top Pro

Very complete, mature tool chain

Aside from the compiler, go comes with the essentials built-in (like go test, gofmt, go tool, go vet, go build, go install, go doc, ....). All tools are easy to use, well documented, open source, and reliable See More

Top Con

Does not have sum types

Makes it harder to have functions of different parameters types in a non OOP language. Thus messy generics and interfaces, and more confusion, where sum types could have solved a number of issues. See More

Top Pro

Demonstrates a unique, simple concept to object-oriented programming

All types are essentially objects, be they type aliases or structs. The compiler automatically associates types to their methods at compile time. Those methods are automatically associated to all interfaces that match. This allows you to gain the benefits of multiple inheritance without glue code. As a result of the design, classes are rendered obsolete and the resulting style is easy to comprehend. See More

Top Con

Hard to abstract even the simplest notions

Go is famously regarded as very simple. However, this simplicity becomes problematic in time. Programmers who use Go find themselves over and over again writing the same thing from a very low point of view. Domains not already served by libraries that are easy to glue are very difficult to get into. See More

Top Pro

Supports 'modules' in the form of packages

Every Go source file contains a package line that indicates which package a file belongs to. If the name of the package is 'main', it indicates that this is a program that will be compiled into a binary. Otherwise, it will recognize that it is a package. See More

Top Con

Weak type system

Top Pro

Jobs available

You can find a Job knowing Go. Which is more than can be said with many other languages. See More

Top Con

Performance slowdown because of indirect calls and garbage collection

Practically no meaningful Go application can be written without indirect function calls and garbage collection, these are central to Go's core infrastructure. But these are major impediments to achieving good performance. See More

Top Pro

Exceptionally simple and scalable multithreaded and concurrent programming

Goroutines are "lightweight threads" that runs on OS threads. They provide a simple way for concurrent operations — prepending a function with go will execute it concurrently. It utilizes channels for communication between goroutines which aids to prevent races and makes synchronizing execution effortless across goroutines. The maximum number of OS threads goroutines can run on may be defined at compile time with the GOMAXPROCS variable. See More

Top Con

Expects prior familiarity with tooling, "advanced" OS use

A standard step of even installing Go is modifying your path -- a person who's encountering their first language might not even understand. It's hard to escape using Go without familiarity with using build tools, managing and organizing project directories, etc. It's not as simple as Python's "just run the .py file with the interpreter." See More

Top Pro

Simplified C-like syntax that is as easy to read and write as Python

The language is designed in a manner that seems logical. Syntax is simplified to reduce burden on the programmer and compiler developers. See More

Top Con

Easy to shadow variable

Due to single character only difference, declare and assign statement can easily shadow variable from outer scope unconsciously. Example: err := nil if xxx { err := somefunctionthatreturnsanerr } return err // always return nil See More

Top Pro

Provides tools for automatically formatting code for your entire software project

This helps keep every programmer on the same page in a project and eliminates arguments over formatting styles. See More

Top Con

Designed to make the programmer expendable

Go was designed for large team projects where many contributors may be incompetent. That Go can still get things done under these conditions is a testament to its utility in this niche. Go's infamously weak abstraction power is thus a feature, not a bug, meant to prevent your teammates from doing too much damage. This also means any team member can be easily replaced by another code monkey at minimum cost. Good for the company, bad for you. The more talented programmers, on the other hand, will be very frustrated by having one hand tied behind their back. See More

Top Pro

Programmers don't have to argue over what 10% subset of the language to implement in their software project

The language promotes programming in a specific idiomatic style, which helps keep every programmer on the same page. See More

Top Con

Implementation of interfaces are difficult to figure out

Finding out what interfaces are implemented by a struct requires a magic crystal ball. They are easy to write, but difficult to read and trawl through. See More

Top Pro

Built-in unit testing

The idiomatic approach to writing a Go software project is to perform test-driven development with unit testing. Every source code file should have an associated *_test.go file which tests functions in the code. See More

Top Con

Does not support circular dependencies

Top Pro

Multiple variables may be assigned on a single line

This conveniently eliminates the need to create temporary variables. Fibonacci example: x, y = y, x+y See More

Top Con

Requires specific directory structure and environment variable settings

Too much knowledge required for a first programming language. See More

Top Pro

Automatically generates API documentation for installed packages

Godoc is provided to automatically generate API documentation for Go projects. Godoc also hosts it’s own self-contained web server that will list documentation for all installed packages in your Go path. See More

Top Con

No forms designer

Those who are used to Visual Studio may feel the lack of a forms designer for rapid development. However there are some libraries for building GUI Applications and libraries for forms. See More

Top Pro

API documentation is rich in content; easy to memorize

Only features deemed critical are added to the language to prevent cruft from working it's way into the language. The language is small enough to fit inside one's head without having to repeatedly open documentation. Documentation is hosted on an official webpage in a manner that is simple to read and understand. See More

Top Pro

Great team working behind it

Go has a solid team of engineers working on it (some of the best networking engineers in the world are working on Go). Up until now, the great engineering of the language has compensated for its lack of power. See More

Top Pro

Supports functional programming techniques such as function literals

This naturally also supports first class and high order functions, so you may pass functions as variables to other functions. See More

Top Pro

Programmers don't have to argue over what 10% subet of the language to implement in their software project

The language promotes programming in a specific idiomatic style, which helps keep every programmer on the same page. See More

Top Pro

Supports functional programming techniques such as function literals.

This naturally also supports first class and high order functions, so you may pass functions as variables to other functions. See More

Top Pro

Supports splitting source code into multiple files

As long as every source code file in a directory has the same package name, the compiler will automatically concatenate all of the files together during the compilation process. See More

Top Pro

Multiple variables may be assigned on a single line

This conveniently eliminates the need to create temporary variables. Fibonacci example: x, y = y, x+y See More

See All

score 6 · Answer 2

V

Top Pro

Sum types

V has sum types. See More

CuriousIsimud's Experience

Excellent alternative or can be used with C, Go, or JavaScript. This is so because of transpiling capability and interoperability. See More

Top Pro

Cross-platform

Compile app to run on different OSes. See More

SincereBythos's Experience

Use C for now See More

Top Pro

Fast like C

V is easier than C and fast like C. See More

ColorfulPhobos's Experience

Easier to learn, read, and use. Great new language that's powerful and enjoyable. See More

Top Pro

Clear syntax

Highly understandable language. See More

Top Pro

GUI support

V comes with (simple) GUI support out of the box. See More

Top Pro

Safety

V is very safe. See More

Top Pro

C Interop

Can import C libraries, structs, and headers. See More

Top Pro

Closures

V has closures, which gives the user additional options and usefulness. See More

Top Pro

Supports concurrency and channels

Can run functions concurrently that communicate over channels. See More

Top Pro

Generics

V has generics. See More

Top Pro

Fast compile times

Compiles programs fast, less waiting around, so more productive and fun. See More

See All

score 30 · Answer 3

Rust

Top Pro

Supports cross compilation for different architectures

Since Rust 1.8 you can install additional versions of the standard library for different targets using rustup/multirust. For example: $ rustup target add x86_64-unknown-linux-musl Which then allows for: $ cargo build --target x86_64-unknown-linux-musl See More

Top Con

Questionable roadmap

Current focus of Rust dev team seems to be shifted towards WebAssembly. This feels like it's not a well-thought decision given the overall language state. See More

ImaginativeShennong's Experience

After spending signifcant time using this language, it hits as more hype and grift (for a select few) than really useful and productive. Then there is the 'Rust Evangelism' and 'Rust Foundation', which just comes across as bananas. Rust Foundation is like a drunk dictator, trying to force what we have never seen any other language try to do: 1) Prohibit firearms at their events. 2) No using "rust" in crate names. 3) No using "rust" in product or service name. 4) No using "rust" in domain or company name. 5) No using "rust" if user group or conference makes a profit. 6) Your trademarek must be bigger than theirs on your own website. 7) Must comply with local health regulations, because they say so. Rust is a low productivity, masochistically difficult, ugly syntax, long compile time, not so safe as hype suggests language. If really out here wanting to use something besides C/C++, in 98% of use cases, would do just as well or be better off using something other than Rust. See More

Specs

Platforms:Linux, MacOS X, Windows, BSD

Current stable version:1.71.1

License:MIT/Apache

Top Pro

Official package manager and build tool

Cargo is the official package manager for Rust. It comes with the language and downloads dependencies, compiles packages, and makes and uploads distributable packages See More

Top Con

Low readability

Harder to read and understand language. See More

CapableSupay's Experience

Nice syntax, compared to c++(the languge that rust wants to replace) See More

Top Pro

Compiles to machine code allowing for extra efficiency

Rust uses LLVM as a backend, among other things this allows Rust code to compile down to machine languages. This allows developers to write programs that run as efficiently as possible. See More

Top Con

Rust not as safe as it pretends to be

Rust problems: 1) Massive undisclosed usage of unsafe. 2) Massive amounts of memory safety CVEs - see details. 3) Large bloated Rust binaries increase attack surface for exploits. 4) Many corporate types claiming Rust is safe, don't actually program or use it (have some quiet financial interest to push it). See More

Top Pro

Threads without data races

Unique ownership system guarantees a mutable data to be owned and mutated by only one thread at a time, so there's no data race, and this guarantee is checked at compile time statically. Which means easy multi-threading. Of course, immutable data can be shared among multiple threads freely. See More

Top Con

Not yet a mature and stable language - still developing key features

Top Pro

Catch errors at compile-time

Since Rust is statically typed, you can catch multiple errors during compile time. This is extremely helpful with debugging, especially compared with dynamically typed languages that may fail silently during runtime. See More

Top Con

Lifetime & trait annotation can be very complex and noisy in function signatures

Top Pro

Memory model enforces safety and compile-time error checks

Rust implements concept of "borrowing" as a solution to memory management. While still requiring programmer to handle it properly, it's less verbose than direct memory management and much more efficient than garbage collecting. Plus the benefit of runtime safety by compile-time checks. See More

Top Con

Not as useful or productive as advertised.

If really out here wanting to use something besides C/C++, in 98% of use cases, would do just as well or be better off using something other than Rust. Will complete the project faster, would be easier, will be happier, and nearly as safe (use newer language with optional GC). See More

Top Pro

Built-in concurrency

Rust has built-in support for concurrency. See More

Top Con

Very ugly and verbose syntax

Compared to many languages. One tool needed to be productive is the language to be pleasing and effective, yet Rust friction is as high as its safety. See More

Top Pro

Zero-cost futures or Async IO

Top Con

Steep learning curve

Pretty strict and hard to adapt for beginners. See More

Top Pro

Makes developers write optimal code

Rust is a modern programming language written around systems. It was designed from the ground up this way. It's language design makes developers write optimal code almost all the time, meaning you don't have to fully know and understand the compiler's source code in order to optimize your program. Furthermore, Rust does not copy from memory unnecessarily, to give an example: all types move by default and not copy. Even references to types do not copy by default. In other words, setting a reference to another reference destroys the original one unless it's stated otherwise. See More

Top Con

Low productivity

The compiler is strict, such as ownership and borrowing checkers. See More

Top Pro

Zero-cost abstractions

Most of Rust's generalizations and abstractions do not cost anything at runtime. See More

Top Con

Long compile times

Way longer to compile than other languages. See More

Top Pro

Support for macros

When you identify a part of your code which gets repeated often, which you cannot abstract using functions or classes, you can use Rust's built-in Macros. See More

Top Con

Documentation is still incomplete

Some features, like macros, don't have proper documentation at all. See More

Top Pro

Generics support

You don't have to write same array and dictionary classes hundreds and thousands times for strong type check by compiler. See More

Top Con

Significant time required to understand the language fully

There's the infamous borrow checker for example. See More

Top Pro

Easy to write understandable code

While not as verbose as Java, it still is much more verbose than languages like Go and Python. This means that the code is very explicit and easy to understand. See More

Top Con

Reference counting is via standard library with noisy syntax

There's no other support for sharing references to mutable data. See More

Top Pro

High-level abstactions with low-level performance

You can write fast and modern code without GC. Rust implements zero-cost abstractions. See More

Top Con

Lots of abandoned crates

Many crates appear to be abandoned or forked and no longer maintained. Many of these crates should be incorporated into the language itself. See More

Top Pro

Functional programming

Very easy to create functional with some additional from structure application. See More

Top Con

Very new and untested

Top Pro

Big community

The biggest community contributing to language. See More

Top Con

Lack of mature libraries

While crates.io is a good source of third-party libraries, there's still a long way to go until even the most basic ones, like date and time handling, will reach maturity. See More

Top Con

Borrow checker prevents many programming styles and often disallows code that is memory-safe

See All

score 13 · Answer 4

Haskell

Top Con

Difficult learning curve

Haskell lends itself well to powerful abstractions - the result is that even basic, commonly used libraries, while easy to use, are implemened using a vocabularly that requires a lot of backround in abstract mathematics to understand. Even a concept as simple as "combine A and B" is often, both in code and in tutorials, described in terms of confusing and discouraging terms like "monad", "magma", "monoid", "groupoid", and "ring". This also occasionally bears its ugly head in the form of complicated error messages from type inference. See More

Top Pro

Mathematical consistency

As Haskell lends itself exceedingly well to abstraction, and borrows heavily from the culture of pure mathematics, it means that a lot more code conforms to very high-level abstractions. You can expect code from vastly different libraries to follow the same rules, and to be incredibly self-consistent. It's not uncommon to find that a parser library works the same way as a string library, which works the same way as a window manager library. This often means that getting familiar and productive with new libraries is often much easier than in other languages. See More

Specs

Site:https://www.haskell.org/

Paradigm:functional

Type System:static

Top Con

You have to learn more than just FP

Haskell is not only a functional language but also a lazy, and statically typed one. Not only that but it's almost necessary to learn about monads before you can do anything useful. See More

Top Pro

Referentially transparent

Haskell's Purely Functional approach means that code is referentially transparent. This means that to read a function, one only needs to know its arguments. Code works the same way that expressions work in Algebra class. There's no need to read the whole source code to determine if there's some subtle reference to some mutable state, and no worries about someone writing a "getter" that also mutates the object it's called on. Functions are all directly testable in the REPL, and there's no need to remember to call methods in a certain order to properly initialize an object. No breakage of encapsulation, and no leaky abstractions. See More

Top Con

Package manager is unstable & lacking features

Cabal (There are other choices but this is the most popular) can not uninstall a package. Also working at a few locations it is difficult to have the same environment for each one be the same. See More

Top Pro

Highly transferable concepts

Haskell's referential transparency, consistency, mathematics-oriented culture, and heavy amount of abstraction encourage problem solving at a very high level. The fact that this is all built upon little other than function application means that not only is the thought process, but even concrete solutions are very transferable to any other language. In fact, in Haskell, it's quite common for a solution to simply be written as an interpreter that can then generate code in some other language. Many other languages employ language-specific features, or work around a lack of features with heavy-handed design patterns that discourage abstraction, meaning that a lot of what is learned, and a lot of code that is needed to solve a particular problem just isn't very applicable to any other language's ecosystem. See More

Top Con

Language extensions lead to unfamiliar code

Haskell's language extensions, while making the language incredibly flexible for experienced users, makes a lot of code incredibly unfamiliar for beginners. Some pragmas, like NoMonomorphismRestriction, have effects that seem completely transparent in code, leading beginners to wonder why it's there. Others, like ViewPatterns, and particularly TemplateHaskell, create completely new syntax rules that render code incomprehensible to beginners expecting vanilla function application. See More

Top Pro

Forces you to learn pure functional programming

It is pure and does not mix other programming paradigms into the language. This forces you to learn functional programming in its most pure form. You avoid falling back on old habits and learn an entirely new way to program. See More

Top Con

Obscure ugly notation

0 = 1 Using "=" like this: <code> -- Using recursion (with pattern matching) factorial 0 = 1 factorial n = n * factorial (n - 1) </code> Example from See here. Is quite simply annoying aesthetics. See More

Top Pro

Open source

All Haskell implementations are completely free and open source. See More

Top Con

Documentation for most packages is short and lacking

A few Haskell packages are well documented but this is the exception, not the rule. Most of the time a list of function signatures is what passes for documentation. See More

Top Pro

Quick feedback

It's often said that, in Haskell, if it compiles, it works. This short feedback loop can speed up learning process, by making it clear exactly when and where mistakes are made. See More

Top Con

Too academic, hard to find "real world" code examples

Top Pro

Hand-writeable concise syntax

Conciseness of Haskell lets us to write the expression on the whiteboard or paper and discuss with others easily. This is a strong benefit to learn FP over other languages. See More

Top Con

Symbols everywhere

Haskell allows users to define their own infix operators, even with their own precedence. The result is that some code is filled with foreign looking operators that are assumed to be special-case syntax. Even for programmers who know they're just functions, operators that change infix precedence can potentially break expectations of how an expression is evaluated, if not used with care. See More

Top Pro

Functions curry automatically

Every function that expects more than one arguments is basically a function that returns a partially applied function. This is well-suited to function composition, elegance, and concision. See More

Top Con

Curried type signatures obfuscate what were the in and out types originally

Top Pro

Powerful categorical abstractions

Makes categorical higher order abstractions easy to use and natural to the language. See More

Top Con

You need some time to start seeing results

Haskell's static typing, while helpful when building a project, can be positively frustrating for beginners. Quick feedback for errors means delaying the dopamine hit of code actually running. While in some languages, a beginner's first experience may be their code printing "Hello World" and then crashing, in Haskell, similar code would more likely be met with an incomprehensible type error. See More

Top Pro

Easy to read

Haskell is a very terse language, particularly due to its type inference. This means there's nothing to distract from the intent of the code, making it very readable. This is in sharp contrast to languages like Java, where skimming code requires learning which details can be ignored. Haskell's terseness also lends itself to very clear inline examples in textbooks, and makes it a pleasure to read through code even on a cellphone screen. See More

Top Con

Lazily evaluated

Haskell's lazy evaluation implies a level of indirection - you're not passing a value, you're passing a thunk. This is often difficult to grasp not just for beginners, but for experienced programmers coming from strictly evaluated languages. This also means that, since for many, strict evaluation is their first instinct, initial expectations of a function's performance and complexity are often broken. See More

See All

score 7 · Answer 5

Nim

Top Pro

Great portability and optimization

Nim gains portability and optimization because it compiles to C, which offers a lot of choices from modern C compilers. See More

Top Con

You won't get a job programming with Nim

It's not a mainstream language. See More

Specs

Platforms:Windows, Linux, Mac

Top Pro

Python-like syntax

Readable, clean and familiar to Python developers. See More

Top Con

Atrocious error messages

Unhelpful to users, wasting hours deciphering and extremely annoying. See More

Top Pro

Cross-platform

Works on Windows, macOS, and Linux. See More

Top Con

Weird thread model

Not turned on by default. Has very odd and convoluted rules on memory sharing between threads. Harder to use. See More

Top Con

Lacks void / null safety

Easy to get involved in safety issues. See More

Top Con

Failed wannabe Python knockoff language

Created in 2008, Nim has failed to make TIOBE top 100 or PYPL rankings for programming languages. Pythoners can use alternatives like Cython or use the Codon compiler instead for a more Python-like experience. See More

Top Con

It can get a little convoluted at times (especially the functions {procs})

Not necessarily a bad thing. See More

See All

score 3 · Answer 6

F#

Top Pro

Easy to learn and fun programming.

Fast and fun programming is with F# See More

Specs

Current stable version:6.0

License:Apache 2.0

IDE Support:Visual Studio, Code, Rider

Top Pro

Easier transition from other paradigms

Since F# is not a purely functional language, it lends itself to being more easily picked up by programmers that have experience with other paradigms. See More

Top Pro

Concise syntax

F#'s syntax tends to be terse while remaining very readable and easy to understand without being a chore to write. See More

Top Pro

F# is supported by Xamarin

Thanks to Xamarin, F# is a functional language that you can use to build for iOS, Android and Windows. See More

Top Pro

Allows writing predictable code

Like many other functional languages, F# takes a stance of immutability for most of its constructs (state, values etc...). There are several reasons why having immutable values is good. One of those is that the code you are writing becomes much more predictable and you don't have to worry about any side effects. See More

Top Pro

Natively supported by Visual Studio

This is a .Net language natively supported by Visual Studio. Though it is not as tooled up as C# the support is still substantial. In particular, C# deployment scenarios can be enabled for it with small C# wrapper projects. Integration with Visual Studio provides: IntelliSense, debugging, projects an other features. See More

Top Pro

Multiplatform, it runs on .Net Core

Forget Xamarin and Mono. F# now runs on the multiplatform .Net Core! See More

Top Pro

.NET Interoperability

Since F# runs on the Common Language Runtime or CLR, it has access to the entire .NET Framework, as well as libraries written in other .NET languages such as C#, VB.NET, and C++/CLI. See More

Top Pro

Type Providers

Top Pro

Fall into the pit of success

F# directs you into a workflow where the right way is the path of least resistance. Coming from a C# background, its restrictions might feel arbitrary at first (e.g., what do you mean my code has to be in dependency order!? Arbitrary alphabetical or bust!), but you'll soon realize that your code is cohesive, concise and consistent in a way that it never was before - and you can compile and run with confidence! See More

Top Pro

You can run F# in the browser

Thanks to a project like Fable, you can write and run your client app in F# and run it over JavaScript. It allows you to share code between your server and client. See More

See All

score 2 · Answer 7

Vala

Top Pro

Well-integrated with C language

Vala itself is compiled to C, therefore it can use the vast ecosystem of C language, with least effort. See More

Top Con

Very limited adoption

Vala isn't used in areas other than GTK development, and no major business has adopted the language. See More

Top Pro

Fast

Underneath there is C. It makes some stuff easier to write than it would be with plain C code. See More

Top Pro

Rich GTK Support

Vala developed by Gnome Foundation. See More

Top Pro

C compatible API (and ABI)

C programs can use libraries written in Vala, and vice versa. See More

Top Pro

Easy Syntax

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. See More

See All

score 9 · Answer 8

Java

Top Pro

Mature ecosystem

The language and all its tools have enough time to age and they've aged well. See More

Top Con

Memory hungry

Running the virtual machine, application server and application itself consumes significant amount of resources. See More

Elias Van Ootegem's Experience

Java does feel like it's time has come and gone. The language is stupendously verbose, despite the attempts to add more and more new constructs to the language to make it feel less dated. The JVM is a decent platform, but it requires specialist knowledge to get the most out of your application. The same code can often be made to run significantly faster by having someone tweak the JVM to better suit the code. Java developers can't hide. When they eventually end up writing any other language, you can quite easily spot code written by someone used to Java. Always. XML would've died ages ago, but Java is not letting us abandon it. Java frameworks and tools not only use XML fol configuration. It's quite common to see frameworks rely on XML to contain actual business logic. This is madness. It can reach absurd levels to the point where I've actually heard a Java developer say that he recons he writes, on average, 20 lines of XML for each line of Java. Pure lunacy. MyArgumentConImpl lastCon = new MyArgumentConImpl(); is ridiculously verbose. Java devs have since come around and said the Impl bit is just noise (and it is), but it somehow hasn't occurred to them that having to write the time twice is just as noisy? Why can't I just write lastCon := new MyArgument(); or MyArgument lastCon;? See More

Top Pro

Type-safe

It is easier to catch errors sooner. See More

Top Con

Verbose

It's a known trait of java. The code is verbose, and because there's no way around classes for everything, even a simple hello world requires more lines than it should. See More

Top Pro

The JVM

Without Java, we wouldn't have the JVM. For all its faults, there's some pretty neat stuff being done on the JVM. Things like Kotlin wouldn't exist if it weren't for the JVM and Java's faults. Clojure is just a Lisp implementation, but because of the JVM, it was instantly portable. See More

Top Con

XML everywhere

XML based config is a dated approach, but worthy of a con. Worse still is that a great many of widely used frameworks allow for, and actively encourage the use of XML to contain logic. See More

Top Pro

Library

The language defines a very large and comprehensive library that covers the needs of many applications. See More

Top Con

Oracle

Enough said. In more detail: Oracle has acquired Java from Sun and continues to surround it with controversy ever since (legendary lawsuit with google, money extortion from the enterprise users etc.). See More

Top Pro

Built in concurrency support

Java has built in support for writing threaded applications. See More

Top Con

Don't use newer version than 8

Because Java download still refers to Java 8, if you use newer versions, you can't reach to true cross platform as most users will have Java 8 installed. See More

Top Pro

Well thought out packaging structure

Class, the basic unit of Java code, belongs to a package which is a naming mechanism allowing reuse of class names perhaps written by different organizations. For example, one organization can write a Java library with whatever names they want in the package com.company1, and another organization write a library with whatever names they want, including the same names, in the package com.company2, and there is never a name collision and all classes can be used as desired. See More

Top Con

Unnecessarily obtuse and verbose

If you like typing 40 lines of code to open a file, Java is the language for you. If, on the other hand, you’d actually like to get something done, look elsewhere. See More

Top Pro

Write once, run anywhere

Compiled Java applications run in a JVM, so any platform for which there is a JVM can run the Java application without recompilation. See More

Top Con

Some idioms require by the built in libraries are complex.

There are many idioms need to use some aspects of the language that make simple programs more complex than seems justified. For example having to compose several objects together to read a file is frustratingly complex and difficult to remember. Fortunately googling what you want to do will lead you to code fragments. Likewise threading is somewhat obscure to do in the recommended manner although the straight forward use of Thread works fine. See More

Top Pro

Language defined GUI toolboxes

AWT, Swing and JavaFX are all very useful for creating GUI applications. See More

Top Con

More syntactic sugar than most people would like.

There is a lot of boiler plate coding to get started. While useful in larger application the boiler plate is difficult for beginning programmers in the language. import blah package packages names class class name { public void main (String [] args) { } } See More

Top Con

There's only one way to do it: the Java way

Java developers tend to approach things the same way: the Java way. This shows when they're writing code in a different language. They have a tendency to over-abstract/over-engineer the simplest of things, make everything OO, even the simplest of things, and often are reluctant to consider an approach other than OOP. See More

Top Con

Java default charset for string encoding is chosen when JVM starts

This can give rise to bugs/issues when same code is ported on different operating systems/environments. See More

See All

score 7 · Answer 9

C#

Top Pro

Visual Studio

The Visual Studio IDE offers one of the best development environments. The Community Edition can be used for free. See More

Specs

Platforms:Windows, Linux, Mac, Web, Android, iOS

Language type:Interpreted

Current Stable Version:10

Top Pro

Forms

Can be designed visually with the Visual Studio designer for traditional Windows forms, WPF, or Web forms. See More

Top Pro

Versatile

.NET offers rich functionality. See More

Top Pro

Cross-Platform

Runs on Linux, Mac, and Windows See More

Top Pro

Can be used in a variety of fields

with Xamarin for Mobile (ios, android) with .net core asp for server (linux, windows) with .net core for desktop (windows, mac) with mono for desktop (windows, linux) with blazor for web client with webassembly. However, it is not considered top for any of those categories top choice for windows desktop with .net framework top choice for Unity .net 5 will unify frameworks similar to JVM (just one) See More

Top Pro

It is a C like language.

Being a C like language counts in favor for it as a general purpose programming language, given the ease of using existing skills to pick up this language easily. there are other superior languages that could be used as a general purpose, such as: F#, Haskell, but the complexity of those languages, being functional, make them strange to the usual C Syntax. C# is better than C whenever garbage collection, Objects, classes, data access, are needed. But C is going to be the choice when hardware access and performance are paramount. See More

Top Pro

3rd Party support

Lot's of tools and libraries available. See More

See All

score 5 · Answer 10

D

Top Con

Failed at becoming alternative to C or C++

Almost as confused and complicated as C++, but without the popularity and widespread corporate usage. Also failed at becoming a good cross-platform GUI application development language like Object Pascal. Many missed past opportunities, and now newer languages are better alternatives. See More

Top Pro

Designed for concurrency and parallelism

Supports first-class functionality for both concurrency and parallelism, offered as part of the standard library. Global variables are thread-local by default. 'shared' type qualifier for multithreaded data. See More

Specs

Current stable version:2.101.2

Site:https://dlang.org/

Latest beta version:2.102.0-rc.1

Top Con

Lack of vision

D is community-driven and lacks the support of any large corporation. While this increases the amount of talent and engineering abilities of the people working on D, it also brings a severe lack of charisma, leadership and vision. See More

Top Pro

Unit testing built-in

D provides unittest blocks to insert code that verifies functions preform their expected behavior and document edge cases. Since these are enabled with a compiler switch, there is no need to teach new programmers how to install new libraries and import modules, instead training on test driven design can start from the very first function. See More

Top Con

Poor adoption even after many years of existence

There's a widely accepted perception of D as a language that has been poorly adopted. Since adoption is driven by perception this becomes a fact. So managers and engineers start becoming nervous in adopting a language that has such a perception among the community and that has been so unsuccessful for so long. See More

Top Pro

Easy to read and understand code

Top Con

Reference counting support can't be both memory-safe and efficient

As of March 2021, library support can't provide both due to limitations in memory-safety of types. However, library implementations are safer than C++ smart pointers. See More

Top Pro

Very fast compilation

D is usually up to 10 times faster than C++. Having a language that compiles this fast means that you are free to write highly optimized code because of the relatively low cost of experimentation. See More

Top Pro

Compile-time Function Execution

Top Pro

Has an improved C subset

With few exceptions, D will either compile C code to work exactly as when compiled as C, or it won't compile - it won't quietly change the semantics of C code and give unexpected results. This means that D contains an improved C, as it fails compilation where type safety is missing in C. This allows learning the same machine operations available in C and other low-level languages. See More

Top Pro

Provable purity and immutability

The compiler can check that functions don't have side effects, extremely important for functional programming in concurrent scenarios, and can check immutability. Therefore, the compiler will prove that your programs are functionally pure and respect immutable data, if you want it to. See More

Top Pro

Value types with scoped destruction

Structs support RAII with destructors. Also a reference variable declared with 'scope' supports stack allocation as an optimization. See More

Top Pro

Clear, powerful metaprogramming for runtime efficiency

Top Pro

Static with type inference

For a new user adding types can feel tedious, and takes focus off the meaning of the code, but they are also important for checking logic. D provides static types, and a good system to infer types, so types are checked when calling functions, but do not need to be specified everywhere, making it feel more dynamic. See More

Top Pro

Great functional programming support

See std.algorithm. Closure type inference. Inferred function purity. True transitive immutability support. See More

Top Pro

Doesn't force you to deal with memory management

When you're just starting out, dealing with manual memory management and its bugs is a huge pain! D is garbage collected by default, which removes a huge class of things that could go wrong. And later on, if you decide you don't want or need the GC, you can turn it off. See More

Top Pro

Industrial quality

Top Pro

Built-in Unicode support

Top Pro

Easy to integrate with C and C++

D practically has the same memory structure as C and C++; all D does it build a structure around that. The entire C standard library is accessible at no cost (syntactic or speed) and it's being worked on allowing the same for the C++ standard library. See More

Top Pro

Asynchronous I/O that doesn’t get in your way

Because all types can be treated as objects, all files can call functions in the same manner -- even stdin and stdout. stdout.writeln(); stdin.readln(); file.writeln(); file.readln(); See More

Top Pro

Supports calling functions from types in an object-oriented manner.

if (exists(file)) {} may be written as if (file.exists) {}. writeln(file); may be written as file.writeln(); isDivisibleBy(10, 2); may be written as 10.isDivisibleBy(2); writeln(isEven(add(5, 5))); may be written as 5.add(5).isEven().writeln(); See More

Top Pro

It's a state-of-art evolution of C

Top Pro

Provides a powerful data structure on top of C's arrays called slices

D provides a structure that builds on C's arrays called slices. A slice is a segment of an array that tracks the pointer and the length of the segment. Slices are extremely powerful because they combine the protection of knowing the length of the data with the garbage collector that manages the memory backing that data, thus avoiding most memory corruption issues. See More

See All

score 2 · Answer 11

Ada

Top Pro

Expressive types

Specs

Platforms:Windows, Linux, MacOS, embedded

score 1 · Answer 12

C

Top Con

It's not memory safe

Top Pro

C is simple with lesser rules than any other language

C is standardized and it is the go-to language when you have to speed things up. See More

Specs

Current stable version:C'18

Paradigm:imperative

Language type:imperative, ALGOL family

Standard:ISO/IEC 9899:2011/Cor 1:2012 or C11

See All Specs

Top Con

Requires memory management

Learning programming is already hard enough when you don't have to worry about memory leaks. See More

Top Con

Languages is full of corner cases and undefined behaviors

Undefined behavior in a program can cause unexpected results, making it hard to debug. With UB, program behavior may vary wildly depending on optimization settings. There are many cases that invoke UB, such as signed overflow, invalid dereferences, large integer shifts, uninitialized variables, etc. These serve to frustrate novice programmers when they could be learning other concepts. See More

See All

12 Options Considered

My Recommendation for Golang

My Recommendation for Golang

Great language for building networking services

Really annoying time formatting system

Easy to install and configure; simple to compile software

Golang controlled by Google

The go compiler compiles binaries instantly — as fast as a scripting language interpreter

It appears Google uses position to snuff out or suppress other languages

Performance is on the order of C and Java

Doesn't have true enums

Syntax for exported code from a package is simplified to be less verbose than other languages

Forces K&R style and won't allow Allman style

Very complete, mature tool chain

Does not have sum types

Demonstrates a unique, simple concept to object-oriented programming

Hard to abstract even the simplest notions

Supports 'modules' in the form of packages

Weak type system

Jobs available

Performance slowdown because of indirect calls and garbage collection

Exceptionally simple and scalable multithreaded and concurrent programming

Expects prior familiarity with tooling, "advanced" OS use

Simplified C-like syntax that is as easy to read and write as Python

Easy to shadow variable

Provides tools for automatically formatting code for your entire software project

Designed to make the programmer expendable

Programmers don't have to argue over what 10% subset of the language to implement in their software project

Implementation of interfaces are difficult to figure out

Built-in unit testing

Does not support circular dependencies

Multiple variables may be assigned on a single line

Requires specific directory structure and environment variable settings

Automatically generates API documentation for installed packages

No forms designer

API documentation is rich in content; easy to memorize

Great team working behind it

Supports functional programming techniques such as function literals

Programmers don't have to argue over what 10% subet of the language to implement in their software project

Supports functional programming techniques such as function literals.

Supports splitting source code into multiple files

Multiple variables may be assigned on a single line

My Recommendation for V

My Recommendation for V

Sum types

Cross-platform

Fast like C

Clear syntax

GUI support

Safety

C Interop

Closures

Supports concurrency and channels

Generics

Fast compile times

My Recommendation for Rust

My Recommendation for Rust

Supports cross compilation for different architectures

Questionable roadmap

Official package manager and build tool

Low readability

Compiles to machine code allowing for extra efficiency

Rust not as safe as it pretends to be

Threads without data races

Not yet a mature and stable language - still developing key features

Catch errors at compile-time

Lifetime & trait annotation can be very complex and noisy in function signatures

Memory model enforces safety and compile-time error checks

Not as useful or productive as advertised.

Built-in concurrency

Very ugly and verbose syntax

Zero-cost futures or Async IO

Steep learning curve

Makes developers write optimal code

Low productivity

Zero-cost abstractions

Long compile times

Support for macros

Documentation is still incomplete

Generics support