What are the best (productivity-enhancing, well-designed, and concise, rather than just popular or time-tested) programming languages?

Question

Follow

Development

What are the best (productivity-enhancing, well-designed, and concise, rather than just popular or time-tested) programming languages?

85

Options
Considered

2.2K

User
Recs.

Feb 12, 2019

Last
Updated

Here’s the Deal

78 Options Considered

Best (productivity-enhancing, well-designed, and concise, rather than just popular or time-tested) programming languages	Price	Current stable version	Site
88 Elixir	-	1.8.1	https://elixir-lang.org
88 Nim	-	0.18.0	https://nim-lang.org
85 Python	-	3.7.2 and 2.7.15	-
85 Smalltalk	-	6.1	-
81 Rust	-	1.32.0	rust-lang.org

See Full List

score 46 · Answer 1

Elixir

Top Pro

Very friendly functional language

Top Con

Slow

Single core perfomance is significantly slower than most other languages. See More

Specs

Current stable version:1.8.1

Site:https://elixir-lang.org

Price:Open source (Free)

GZipped size:3.61 MB (without required Erlang VM)

Top Pro

Amazingly robust and fluid multi-processing

Top Con

Some design choices may seem strange

Some design choices could have been a little more appealing, for example: using "do...end" comes natural in Ruby for blocks but Elixir uses them for everything and it looks pretty weird: Enum.map [1, 2, 3], fn(x) -> x * 2 end or receive do {:hello, msg} -> msg {:world, msg} -> "won't match" end See More

Top Pro

Compiler errors usually explain why that's an error

Compiler errors and warnings tend to be accompanied with explanations of why the error/warning happened, and even with hints on how to solve them. See More

Top Con

Dynamically typed

Top Pro

BEAM VM and OTP library

Top Con

Single threaded

A lot of problems arise from async code. See More

Top Pro

Great for concurrency

Leverages the existing Erlang Beam VM which is amazing for concurrency. See More

Top Pro

Great documentation

Elixir's documentation is very good. It covers everything and always helps solving any problem you may have. It's also always available from the terminal. See More

Top Pro

Part of the best web full-stack framework currently available

Phoenix Framework is coded in Elixir and is very stable and performant as compared to the competition. See More

Top Pro

Easy to download libraries

Comes with built in build tool called "mix". This will automatically download libraries and put them in the scope of the application when you add them to the "deps" function and run mix deps.get See More

Top Pro

Powerful metaprogramming

Write code that writes code with Elixir macros. Macros make metaprogramming possible and define the language itself. See More

Top Pro

Syntax is similar to Ruby, making it familiar for people used to OOP

All of the benefits of Erlang; without as steep a learning curve of prolog based syntax. Elixir is heavily inspired by Ruby's syntax which many people love. See More

Top Pro

Full access to Erlang functions

You can call Erlang functions directly without any overhead: https://elixir-lang.org/getting-started/erlang-libraries.html See More

Top Pro

Dynamically typed

See All

score 40 · Answer 2

Nim

Top Pro

Statically typed

Has static type system with great type interference and safety See More

Top Con

Community is too small

Too small of a community to keep up with development of similar concurrent projects, like Haxe or Kotlin. See More

PrivateAhMuzenCab's Experience

Fast development, Fast execution, Easy to learn See More

Specs

Current stable version:0.18.0

Site:https://nim-lang.org

GZipped size:12 MB

IDE Support:https://github.com/nim-lang/Nim/wiki/editor-support

See All Specs

Top Pro

Runtime speed

Nim can compile to C or C++, which means it can execute almost as fast as C (in some cases it has the same performance as C) See More

Top Con

Still in pre 1.0

Not very stable and has a rather small community. See More

Top Pro

Compiles to C or JavaScript

Also compiles to C++, Objective C See More

Top Pro

Async/await features

Brilliant C#-inspired async/await implemented via macros. See More

Top Pro

Awesome syntax

Pascal and Python inspired syntax can make code much more readable. See More

Top Pro

Powerful metaprogramming

You can use templates to remove boilerplate and macros to create your own DSLs. For an example click here. See More

Top Pro

Open source

Compiler and all core language tools are open source See More

Top Pro

Garbage-collected

You don't need to deal with all those manual memory allocations, Nim can take care of it! But also you can use another GC, or tweak it for you real-time application or a game See More

Top Pro

Easy to integrate with another languages

You can use Nim with any language that can be interfaced with C. There's a tool which helps you to create new C and C++ bindings for Nim - c2nim Also you can use Nim with Objective C or even JavaScript (if you're compiling for these backends) See More

Top Pro

Easy to read

Nim has a lot of common with Python in terms of syntax. Indentation-based syntax, for/while loops. See More

Top Pro

Strict typing

Checks your code at compile time. See More

Top Pro

Has built-in async support

Nim has "asyncdispatch" module, which allows you to write async applications. See More

Top Pro

Really crossplatform

The same code can be used for web, server, desktop and mobile. See More

Top Pro

Type interferencing

You only need to specify types in your procedures and objects - you don't need to specify type when you're creating a new variable (unless you're creating it without initialization) See More

Top Pro

Multi paradigm

Imperative, OOP, functional programming in one language. See More

Top Pro

Built-in Unicode support

You can use unicode names for variables, there is "unicode" module for operations with unicode See More

Top Pro

Supports UFCS (Unified Function Call Syntax)

writeLine(stdout, "hello") can be written as stdout.writeLine("hello") proc add(a: int): int = a + 5 can be used like 6.add.echo or 6.add().echo() See More

Top Pro

Great metaprogramming features

There are generics, templates, macros in Nim. They can allow you to write new DSL for your application, or avoid all boilerplate stuff. See More

Top Pro

Has built-in unittest module

With built-in "unittest" module you can create test with a very readable code See More

Top Pro

Compile-time execution

Nim has built-in VM, which executes macros and some other code at compile time. For example - you can check if you're on Windows, and Nim will generate code only for it See More

See All

score 105 · Answer 3

Python

Top Pro

Comes with extensive libraries

Python ships with a large standard library, including modules for everything from writing graphical applications, running servers, and doing unit testing. This means that beginners won't need to spend time searching for tools and libraries just to get started on their projects. See More

Top Con

Bad parallelism

GIL See More

Romuald Texier-Marcadé's Experience

Great language and ecosystem for scientic computing, machine learning and data science. See More

Specs

Current stable version:3.7.2 and 2.7.15

GZipped size:22.5MB

Language type:Interpreted

Top Pro

Clear syntax

Python's syntax is very clear and readable, making it excellent for beginners. The lack of extra characters like semicolons and curly braces reduces distractions, letting beginners focus on the meaning of the code. Significant whitespace also means that all code is properly and consistently indented. The language also uses natural english words such as 'and' and 'or', meaning that beginners need to learn fewer obscure symbols. On top of this, Python's dynamic type system means that code isn't cluttered with type information, which would further distract beginners from what the code is doing. See More

Top Con

Arbitrary semantic quirks

The language suffers from issues with non-systematic language semantics, such as differentiation between functions and methods; operators and functions; inconsistencies in default scope behavior (conflation of variable assignment and declaration--global vs nonlocal, and class declarations don't quite have lexical scope.); a mixture of statements and expressions with unclear standards for what kinds of operations get to be an expression and which are only statements, and weird issues like no statements in lambdas. See More

Top Pro

Multipurpose

Python is heavily used in education sector, web and internet development, scientific and numeric computing as well as in big data and machine learning algorithms development. The depth and breadth of Python makes it the language of choice in education and research sector and students across the globe use Python for learning programming and building research projects. See More

Top Con

Language fragmentation

A large subset of the Python community still uses / relies upon Python 2, which is considered a legacy implementation by the Python authors. Some libraries still have varying degrees of support depending on which version of Python you use. There are syntactical differences between the versions. See More

Top Pro

Easy syntax. Easy to learn, hard to master

On top of the wealth of tutorials and documentation, and the fact that it ships with a sizeable standard library, Python also ships with both an IDE (Integrated Development Environment: A graphical environment for editing running and debugging your code); as well as a text-based live interpreter. Both help users to get started trying out code immediately, and give users immediate feedback that aids learning. See More

Top Con

Harder to catch bugs because of its dynamic type system

Top Pro

Emphasis on readability

Top Con

Bad performance

Python, like many interpreted and untyped languages, is fairly slow compared to compiled languages like C, C++ or Java. Sometimes this won't matter, but when it does you're talking about twenty times slower than C/C++ and ten times slower than Java on average. See More

Top Pro

Sequences

Top Con

Improper closures

Lambdas are limited to single-expression statements, and functions that close over local variables easily invalidate references, limiting their capability for maintaining state. Other functional languages that implement closures do not have any of these limitations (or they are comparatively so substantially relaxed as to not make a difference.) See More

Top Pro

C Interop

CFFI is the bee's knees. But there are other options too. See More

Top Con

Slow to run

Check for example the first result from Google: https://benchmarksgame.alioth.debian.org/u64q/python.html See More

Top Pro

Generators

Top Con

No access modifiers

Underscores don't change anything. See More

Top Pro

All objects including functions are first-class objects

Functions have attributes and can be referenced and assigned to variables. As Guido points out in his blog, "One of my goals for Python was to make it so that all objects were 'first class.' By this, I meant that I wanted all objects that could be named in the language (e.g., integers, strings, functions, classes, modules, methods, etc.) to have equal status. That is, they can be assigned to variables, placed in lists, stored in dictionaries, passed as arguments, and so forth." See More

Top Con

Not good for mobile development

You can use frameworks like Kivy, but if your ultimate goal is to write mobile apps Python may not be the best first choice. See More

Top Pro

One right way to do things

One of the Guiding Principles of Python is that there should be only one obvious way to do things. This is helpful for beginners because it means that there is likely a best answer for questions about how things should be done. See More

Top Con

Limited support for functional programming

While Python imports some very useful and elegant bits and pieces from FP (such as list comprehensions, higher-order functions such as map and filter), the language's support for FP falls short of the expectations raised by included features. For example, no tail call optimisation or proper lambdas. Referential transparency can be destroyed in unexpected ways even when it seems to be guaranteed. Function composition is not built into the core language. Etc. See More

Top Pro

Decorators

Top Con

Significant whitespace

While proper formatting is essential for any programmer, beginners often have trouble understanding the need and lack the discipline to do it. Add to that all those editors that randomly convert N spaces (usually 8) to tabs and you get an instant disaster. See More

Top Pro

Default parameter values

Though, this feature is hardly unique to Python. See More

Top Con

Slower language updates

Compared to languages maintained by larger entities, such as C# and Kotlin, Python is quite slow in adding new features. See More

Top Pro

Good language for beginners

Simple syntax and the ability to execute code using the interpreter make it easier for beginners to learn and experiment, but it also means that experienced programmers can be more productive with Python, as well. See More

Top Con

Sacrifices principles for beginner-friendliness

Python tries hard to look like imperative pseudocode. This is great for simple scripts, but for more advanced applications one would often wish for a bit more depth-oriented design with enforcement of standards. Python tends to be procedural at the small scale, OO at the large scale and occasionally functional when it's deemed elegant, but this doesn't always latch together very well. The “English-like” syntax often make it difficult to understand how something works precisely. See More

Top Pro

Lots of tutorials

Python's popularity and beginner friendliness has led to a wealth of tutorials and example code on the internet. This means that when beginners have questions, they're very likely to be able to find an answer on their own just by searching. This is an advantage over some languages that are not as popular or covered as in-depth by its users. See More

Top Con

Speed can matter

Python, like many interpreted and untyped languages, is fairly slow compared to compiled languages like C, C++ or Java. Sometimes this won't matter, but when it does you're talking about twenty times slower than C/C++ and ten times slowed than Java. See More

Top Pro

Good documentation

The Python community has put a lot of work into creating excellent documentation filled with plain english describing functionality. Contrast this with other languages, such as Java, where documentation often contains a dry enumeration of the API. As a random example, consider GUI toolkit documentation - the tkinter documentation reads almost like a blog article, answering questions such as 'How do I...', whereas Java's Swing documentation contains dry descriptions that effectively reiterate the implementation code. On top of this, most functions contain 'Doc Strings', which mean that documentation is often immediately available, without even the need to search the internet. See More

Top Con

Mandatory indentation

While proper formatting is essential for any programmer, beginners often have trouble understanding the need and lack the discipline to do it. Add to that all those editors that randomly convert N spaces (usually 8) to tabs and you get an instant disaster. More importantly, the semantic significance of leading whitespace and newlines forces a line-oriented syntax on a language that also requires more verbosity than strictly necessary, without some of the syntactic sugar convenience of languages like Ruby that can help keep line length down. As a result, it can get difficult at times to maximize readability of conceptually complex operations by breaking up those operations in relatively digestible chunks. See More

Top Pro

Very similar to pseudo-code

When learning Computer Science concepts such as algorithms and data structures, many texts use pseudo-code. Having a language such as Python whose syntax is very similar to pseudo-code is an obvious advantage that makes learning easier. See More

Top Con

Does not teach you about data types

Since Python is a dynamically typed language, you don't have to learn about data types if you start using Python as your first language. Data types being one of the most important concepts in programming. This also will cause trouble in the long run when you will have to (inevitably) learn and work with a statically typed language because you will be forced to learn the type system from scratch. See More

Top Pro

Docstrings

Code is self-documenting. Functions tell you what their parameters are for and how to use them. You can even include TeX math and it is displayed in tools like Spyder. See More

Top Con

Abstraction to the point of hinderance

Python is abstracted far enough that if it's your first language, it will be harder to pick up lower level languages later versus going the other direction. See More

Top Pro

Cross-platform

Installs and works on every major operating systems if not already installed by default (Linux, macOS). See More

Top Con

Inelegant and messy language design

The first impression given by well-chosen Python sample code is quite attractive. However, very soon a lack of unifying philosophy / theory behind the language starts to show more and more. This includes issues with OOP such as lack of consistency in the use of object methods vs. functions (e.g., is it x.sort() or sorted(x), or both for lists?), made worse by too many functions in global name space. Method names via mangling and the init(self) look and feel like features just bolted on an existing simpler language. See More

Top Pro

Has many libraries for scientific computing, data mining and machine learning

Python is commonly used in data science and has many libraries for scientific computing, such as numpy, pandas, matplotlib, etc. See More

Top Con

Unflexible userbase

You will be expected to rigidly stick to the coding practices and to do everything by-the-numbers. See More

Top Pro

Mandatory indentation

No holy wars about which indentation style is best. No wasted time managing brackets, semicolons, or other redundant garbage. See More

Top Con

The elegant design is not translated to numerical applications

Python is popular for data science, but there it's not really used as Python but just as a user interface for NumPy, which is basically Matlab-in-a-library. Python numerical code thus features much of the same bad design as Matlab scripts: inscrutable everything-is-an-array signatures, confusion about row vectors vs. column vectors etc.. See More

Top Pro

Advanced community projects

There are outstanding projects being actively developed in Python. Projects such as the following to name a random four: Django: a high-level Python Web framework that encourages rapid development and clean, pragmatic design. iPython: a rich architecture for interactive computing with shells, a notebook and which is embeddable as well as wrapping and able to wrap libraries written in other languages. Mercurial: a free, distributed source control management tool. It efficiently handles projects of any size and offers an easy and intuitive interface. PyPy: a fast, compliant alternative implementation of the Python language (2.7.3 and 3.2.3) with several advantages and distinct features including a Just-in-Time compiler for speed, reduced memory use, sandboxing, micro-threads for massive concurrency, ... When you move on from being a learner you can still stay with Python for those advanced tasks. See More

Top Pro

Active and helpful community

Python has an active and helpful community, such as the comp.lang.python Google Groups, StackOverflow, reddit, etc. See More

Top Pro

It's really simple

It's very simple for understanding how programming works. See More

Top Pro

Can be used in many domains

Python can be used across virtually all domains: scientific, network, games, graphics, animation, web development, machine learning, and data science. See More

Top Pro

Supports various programming paradigms

Python supports three 'styles' of programming: Procedural programming. Object orientated programming. Functional programming. All three styles can be seamlessly interchanged and can be learnt in harmony in Python rather than being forced into one point of view, which is helpful for easing confusion over the debate amongst programmers over which programming paradigm is best, as developers will get the chance to try all of them. See More

Top Pro

Easy to get started

On top of the wealth of tutorials and documentation, and the fact that it ships with a sizeable standard library, Python also ships with both an IDE (Integrated Development Environment: A graphical environment for editing running and debugging your code); as well as a text-based live interpreter. Both help users to get started trying out code immediately, and give users immediate feedback that aids learning. See More

Top Pro

Easy to find jobs

Python's popularity also means that it's commonly in use in production at many companies - it's even one of the primary languages in use at Google. Furthermore, as a concise scripting language, it's very commonly used for smaller tasks, as an alternative to shell scripts. Python was also designed to make it easy to interface with other languages such as C, and so it is often used as 'glue code' between components written in other languages. See More

Top Pro

Static typing via mypy

Python's syntax supports optional type annotations for use with a third-party static type checker, which can catch a certain class of bugs at compile time. This also makes it easier for beginners to gradually transition to statically typed languages instead of wrestling with the compiler from the start. See More

Top Pro

Has features of both high and low level language

It is somewhere between C and Java. See More

Top Pro

Good introduction to data structures

Python's built-in support and syntax for common collections such as lists, dictionaries, and sets, as well as supporting features like list comprehensions, foreach loops, map, filter, and others, makes their use much easier to get into for beginners. Python's support for Object Orient Programming, but with dynamic typing, also makes the topic of Data Structures much more accessible, as it takes the focus off of more tedious aspects, such as type casting and explicitly defined interfaces. Python's convention of only hiding methods through prefacing them with underscores further takes the focus off of details such as Access Modifiers common in languages such as Java and C++, allowing beginners to focus on the core concepts, without much worry for language specific implementation details. See More

Top Pro

Great REPL

Python's read eval print loop is amazingly useful for being able to test new libraries and unfamiliar idioms without having to organize source files in the file system. See More

Top Pro

Best chances of earning most money

According to Quartz, Python programming skills on average earn $100,000 per year. Closely followed by Java, C++, JavaScript, C, and R with $90,000 per year and above. See More

Top Pro

Interpreters for JS, Microtontrollers, .Net , Java & others

Python is not limited to just be cross platform. It goes far beyond all high level languages since it can run on top of several other frameworks & architectures : Examples of interpreters: Standard (PC Win/Lin/Mac, ARM, Raspberry, Smartphones): CPython usually, but some more specialized for smartphones: Kyvi, QPython, ... Web Browser JS : Brython, PyJS, .Net : IronPython Java: Jython Microcontrollers with WiFi like ESP8266 or ESP32: MicroPython Can be statically compiled (instead of interpreted) with Cython. (Do not mix up with cPython) With python, you're sure your code can run (almost) everywhere, from 2€ computers to the most expensives. So, for instance, with Jython you can access the Java libraries with Python language. See More

Top Pro

Import Turtle

Do something visually interesting in minutes by using the turtle standard library package. https://docs.python.org/3.6/library/turtle.html Turtle graphics is a popular way for introducing programming to kids. It was part of the original Logo programming language developed by Wally Feurzig and Seymour Papert in 1966. Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an import turtle, give it the command turtle.forward(15), and it moves (on-screen!) 15 pixels in the direction it is facing, drawing a line as it moves. Give it the command turtle.right(25), and it rotates in-place 25 degrees clockwise. Turtle can draw intricate shapes using programs that repeat simple moves. Example Turtle Star Drawing from turtle import * color('red', 'yellow') begin_fill() while True: forward(200) left(170) if abs(pos()) < 1: break end_fill() done() See More

Top Pro

Zen of Python

https://www.python.org/dev/peps/pep-0020/ See More

Top Pro

Type hinting

The current version of Python has built-in syntax for both function and variable annotations--for optional static (compile-time) typing via third-party tools like mypy and PyCharm IDE. See More

See All

score 85 · Answer 4

Smalltalk

Top Pro

Live programming environments available

VisualWorks, Pharo, Squeak, Dolphin, Cuis See More

Top Con

Isolation

Smalltalk has its own world inside the image. You cannot use your current text editor with it. At least not in a straight forward way. See More

EnchantingZaqar's Experience

Excellent developing tools, like debugger and inspector. Far better than most languages. See More

Specs

Current stable version:6.1

GZipped size:38MB

IDE Support:Self-Hosted

OS:Windows, macOS, Linux

Top Pro

Simple syntax

The syntax famously fits on a postcard. Programmers are free to worry about the problem at hand instead of the language itself. Not C or Java like syntax. Avoid bracket soup with keywords that make it clear what is expected / passed into methods. See More

Top Con

Not common

Smalltalk missed an opportunity to become mainstream when its implementations cost $5000 per seat versus $0 open source. New open source implementations (Pharo, Squeak) have minor corporate backers but not yet an IT behemoth. Direct jobs are scarce (but indirectly Smalltalk experience is very well regarded). Online communities are relatively small. See More

Arie van Wingerden's Experience

Done a lot of programming in S/370 Assembler, Rexx, Basic, Go, Rust, Rebol, Erlang, Lisp and Scheme variants. What burdens me is that every single project you must start from almost nothing. Reusability of code is often not possible. In Smalltalk that is totally different. Code reuse is the standard. See More

Top Pro

Smalltalk amenable to creating domain-specific languages

If written well, Smalltalk almost reads like English. See More

Top Con

Not used as much anymore

ThoughtfulArohirohi's Experience

Using Smalltalk since the early 90's. Used many 3GL and 4GL app building environments. Always use Smalltalk as my first choice as competitive advantage. See More

Top Pro

Object Oriented

How it was meant to be. See More

Top Con

Limited libraries to connect with external services

Although it has libraries to connect with major services (eg. databases like PostgreSQL, MongoDB, Riak, etc.), it takes some time for those libraries to be available. It's not cutting edge like node.js or Python where libraries are usually written first there and then ported to other languages. See More

ReverentHesperus's Experience

Developing large scale commercial projects using Smalltalk. Projects include electronic medical records (eMRs), eCommerce, sales order entry, TicketMaster style event registration for reserved and festival seating... See More

Top Pro

Very nice and active community around Pharo, Squeak and Cuis

Top Con

Language design and implementation makes it difficult to utilize multi-core systems

PeterPetr's Experience

Using Smalltalk, when every possible, since 1990 for commercial projects, ecommerce, electronic medical records and more. It's my secret competitive advantage. See More

Top Pro

Provides powerful metaprogramming facilities

Top Con

Limited object system

The object system, which by the way is the essence of Smalltalk (Smalltalk is purely object oriented), is very limited, conforming to the old and weak paradigm of tying methods to classes. Modern OOP systems such as the ones provided by Julia and Common Lisp, separate methods from objects allowing for multiple-dispatch and powerful "method combinations", which together greatly enhance the possibilities of OOP and allow for easy translation of your problem domain to actual code. For example, in those two languages the "Circle-Ellipse problem" is easily solved in a few lines and without any hack (such as changing the hierarchy at runtime.) See More

Top Pro

Fun to use

Top Con

Only one paradigm allowed

Smalltalk is a purely object-oriented language, which means that other paradigms can't be used, like functional programming. Although Smalltalk allows easy creation of closures, functional programming can't be fully exploited, because methods are always handcuffed to objects, also, there's no proper tail-call optimization, so either Smalltalk systems allow for unlimited recursion at the expense of speed or memory, or they implement stack frames and thus work fast at the expense of recursion. See More

Top Pro

Rich libraries including many powerful data types, collections, frameworks, development tools etc.

Top Con

Virtual machine in its own isolated world

Smalltalk wants to be the whole OS. While this has tremendous advantages internally, interacting with the world outside the VM is not as easy as pure Smalltalk and must be done via a Foreign Function Interface. See More

Top Pro

Allows programming at various levels of abstraction, including with pure domain concepts

Top Con

A little slow

Smalltalk's VM and lack of attention makes it slower than other languages although most of the time this is unnoticeable. See More

Top Pro

Powerful integrated debugger

You can edit code and swap it in while the your program is still running after an exception has already been signaled, or restart from anywhere in the call stack. You can inspect and modify the state of any object. Some Smalltalkers write unit tests and then program exclusively in the debugger. See More

Top Con

Simple, but not C-like syntax

Top Pro

Superb Integrated Development Environment (IDE)

All tools (Inspector, Browser, Debugger etc.) are written in Smalltalk and are live objects in the environment. All sources are present, so that the tools can easily be studied, changed and experimented with. The same goes for the other components like the compiler, OS-Integration etc. See More

Top Pro

Environment of live objects

You can modify the system as it's running. You're "swimming with the fish", instead of probing a black box by remote control. See More

Top Pro

Easy to learn and experiment

Top Pro

Agile "interactive" test-driven development

Smalltalk had the original (and still the best) unit test system that inspired it in many other languages (like Java's JUnit). Working with interactive live objects in Smalltalk style TDD makes it easy to teach and learn TDD. See More

Top Pro

First-class functions with lexical closures

Top Pro

Elegant syntax fits on a postcard

The syntax was designed to be easy enough for children to learn. Beginners can learn the language rules very quickly and then focus on programming without fighting the syntax at the same time. Things that have to be baked into the grammar in other languages are simple message sends with block arguments in Smalltalk. Expressions have only three precedence levels to worry about. See More

Top Pro

Inspector makes objects transparent

Programmers must make detailed mental models of the system they are developing. Bugs usually happen when the mental model does not match the actual system. This is one of the greatest difficulties beginners have because most systems are so opaque. It takes a lot of effort to see what's really going on. But in Smalltalk this is much easier, thanks to the powerful tools included in the environment, like the object inspector. See More

Top Pro

As a first language, almost forces you to learn OO design.

Hybrid languages (e.g., Java, C#, C++) make it easy to slip into procedural thinking. Smalltalk's pure OO approach makes it hard not to think in object-oriented terms. In addition, since the entire IDE and runtime components are there in the image for you to browse, you have plenty of examples of good OO design to learn from. See More

Top Pro

Language uniformity

This leads to a very simple programming model (pure OO) that is still very powerful. A lot of stuff that is hard to implement in other languages is easier in Smalltalk. See More

Top Pro

Pure and easy object orientation

Smalltalk is one of few languages that are purely object oriented. This provides a solid and easy to understand base on which to learn object oriented programming, the most popular approach to programming. See More

Top Pro

Internal source code and documentation

You can explore how everything works easily. See More

Top Pro

Open source

MIT licensed implementations Pharo, Squeak, Cuis & Dolphin and GPL licensed GnuSmalltalk. See More

Top Pro

Graphical user interface

Beginners are usually stuck making command-line applications in other languages, because GUIs are too hard. Smalltalk GUIs are easy enough to start with. See More

Top Pro

Incremental compilation

Provides an extremely fast code-compile-run-debug cycle. This is great for beginners to experiment and prototype ideas. See More

Top Pro

Save and restore virtual machine image

A Smalltalk environment can save the state of a running program and later restore and resume execution. This includes the internal state of live objects, multiple thread stacks, and debugging sessions, making it easier for beginners to take the exact problem to an expert for assistance. See More

Top Pro

With PharoJS, easy to generate code for the web

Top Pro

With SqueakJS, run in the browser

Top Pro

The true Smalltalk- 80 Dynabook experience on Cuis.

Cuis Smalltalk shares and follows the original values of Smalltalk-80. Especially on the value of being able to study, understand and modify any part of the system, and see immediate results. See https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-Dev See More

Top Pro

It invented a lot of stuff

Smalltalk is the inventor of Just-in-Time compilation and the MVC concept, refactoring through their so-called refactoring browser and it was also one of the first adopters of a language virtual machine, closures, live programming, test driven development, an IDE and the development of GUI`s. See More

Top Pro

Provides a functional way to interact with objects

Many languages today use object orientation, while the most of them stock on the half way in that perspective. Smalltalk sees literally everything as an object and this includes things like the classes and primitive data types. There is are zero control structures such as selection and iteration, since all is done by sending messages to objects. It use a lot of concepts from Lisp in order to provide a nice experience for this pure kind of object orientation. It provides immutable data structures, closures, anonymous functions and higher order functions, while all those functions are objects. This is what makes Smalltalk so simple, elegant, and easy. All this counts for Pharo, while other implementations as Amber are probably feature complete to it. See More

Top Pro

Inspired many other languages' object systems

Top Pro

The summum environment for code reuse!

Top Pro

With Amber, easy to generate code to run in the web browser

Top Pro

Tooling emerges, cheaply, as a consequence of its design rather than being bolted on

Top Pro

Code rewriting to program yourself out of a corner again

See All

score 63 · Answer 5

Rust

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

Difficult learning curve

Learning curve of the fairly complex rules for Ownership, References and Borrowing, and Lifetimes required. Their use must be internalized in order to become reasonably fluent in Rust. See More

Specs

Current stable version:1.32.0

Site:rust-lang.org

Price:free

License:MIT/Apache

Top Pro

Memory Safety

Rust is designed to prevent null pointers and segfaults. See More

Top Con

Terrible compile-time management

Top Pro

Emphasis on Zero-Cost Abstractions

Programming is all about abstractions. The more powerful abstractions you can use, the more efficiently you can program. Rust, bucking the trend from most languages in its niche, has aspired to take a hint from functional languages, moving away from low-level thinking, and included powerful abstractions for getting work done. To make things better, these abstractions come with no overhead. See More

Top Con

Horrible syntax

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

Error handling

Rust uses algebraic data types(Option, Result) instead of exception. 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

Hard to find learning resources or libraries

Because it's still a relatively new language, Rust does not enjoy a following as large as other languages/environments. Rust development has also been rather volatile for a long time during the beginning of the development of the language adding to this issue. Because of the small community, it's harder to find useful libraries for projects or any other kind of resource. 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

No Higher Kinded Types

Top Pro

Built-in concurrency in the standard library

Rust has built-in support for concurrency in the standard library. See More

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 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 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 Pro

First-class sum types

Sum types (i.e., tagged unions) are a very expressive way of representing state. The simplest example of this is Rust's Option<T> type which has two variants Some(T) and None. One can use an Option to represent a computation that may or may not have a meaningful result (e.g., retrieving a value from a hash table, the element is there, Some(element), or it isn't, None). Rust allows the programmer to pattern match (destructure) these sum types in a very ergonomic way. See More

Top Pro

Expressive error handling, no exceptions

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 Pro

Error Handling

Rust forces the programmer to handle errors, but provides zero cost abstractions and syntactical niceties for this purpose. Error handling is fast, concise, and safe See More

Top Pro

Package manager (cargo) is extremely useful, builds are reproducible

Cargo can be used to manage libraries/library revisions, building rust code, building and linking C code, tool installation, text and benchmark execution... See More

Top Pro

Ha built-in support for concurrency

See All

score 23 · Answer 6

Scheme

Top Pro

Concise

Top Con

Too many parentheses

Uses too many parentheses () which makes it hard to read. See More

Top Pro

Homoiconic syntax

Top Con

A language that is purely academic

If someone said "I am starting a project in Scheme" then they are either talking about their homework or they are starting a joke. See More

Top Pro

Powerful Hygienic Macro System

Top Con

Fragmented ecosystem

Scheme is an IEEE standard, not an implementation. Unfortunately, the standard is too minimal and practical implementations have diverged--they had to expand on the standard to get anything done, but did so in incompatible ways. The later de facto standard R6RS tried to correct this, but lost Scheme's minimalist elegance in the process. The newer R7RS standard takes the best of both worlds with an elegant minimalist core and a practical standard library. See More

Top Pro

Simple

Top Con

Small job market

There are little to none jobs searching for a Scheme programmer. The ones that exist are more related to Research in Maths or Artificial Intelligence. See More

Top Pro

Elegant

Top Con

Few libraries

Compared to languages like Java, Javascript and Python, Scheme has few libraries to provide directly re-usable features. See More

Top Pro

Easy To Learn

Top Con

Evaluation order is unspecified in calls

And almost everything is a call. The compiler is free to re-order the evaluation of arguments, like C does. You can force a particular order with let or let* (like using locals in C), but this is an extra cognitive burden for the programmer in an otherwise simple language. Bugs caused by this are very hard to find, because sometimes it works, and sometimes it doesn't. See More

Top Pro

Extendable

Scheme even has extensions to reduce the number of parentheses while keeping the full expressiveness of the language (SRFI-49, SRFI-110 and SRFI-119). For many other extensions, see the SRFIs. See More

Top Pro

Standardized

With the RnRS reports Scheme has a stable base which is implemented and specialized in many implementations for different domains. Reports — benchmark of many different implementations which support the most recent standards. See More

Top Pro

Robust metaprogramming

The quotation functionality of Lisp allow for extremely powerful, yet syntactically straightforward metaprogramming via macros. This is more powerful than the C preprocessor while being less involved than something like Template Haskell or F# quotations. Using macros to properly decompose a problem domain teaches new developers good habits, improving composibility and reliability when tackling large programs. Scheme metaprogramming also serves as a gentle introduction to domain specific languages. See More

Top Pro

Great at teaching fundamental programming ideas

Scheme teaches the important, fundamental ideas immediately without the distraction of unnecessary syntax or language features. See More

Top Pro

No Magic - it's clear how everything works

Scheme has far less built into the language itself, helping students see that things like OOP are not magical: they are just patterns for organizing code. Everything in Scheme is built up from a very small set of primitives which compose in a natural and intuitive fashion. Having a language that does not accord many things special status helps keep students open minded. This will help students later go between different languages and paradigms from procedural to object-oriented to functional. See More

See All

score 17 · Answer 7

Elm

Top Pro

Immutable values

The values in Elm are immutable - that is once assigned they cannot be changed. This makes it easier (especially for beginners) as values aren't constantly changing. See More

Top Con

Adds an additional layer of abstraction

Some users claim that Elm adds an additional layer of abstraction, meaning that it is one more hurdle between the brain and the product. See More

Specs

Current stable version:0.19

Site:http://elm-lang.org/

Price:Open Source

Platforms:Windows Linux Mac Web

See All Specs

Top Pro

No run-time exceptions

Lack of run-time exceptions makes it easy to produce large swathes of reliable front-end code without drowning in tests. See More

Top Con

Higher-kinded types are unsupported

Some generic operations such as fold, filter, apply and map are unsupported. See More

Top Pro

Performant

Top Con

Poor backend capability

Top Pro

Meaningful, easy to understand error messages

Top Pro

Super easy refactoring with very helpful compiler errors

In no other language you can refactor so easy without any worries, since the compiler will guide you through. It is like TDD but than compiler-error driven. See More

See All

score 33 · Answer 8

Clojure

Top Pro

Designed for concurrency

Since Clojure is designed for concurrency, it offers things like Software Transaction Memory, functional programming without side-effects and immutable data structures right out of the box. This means that the development team can focus their energies on developing features instead of concurrency details. See More

Top Con

May be hard to catch some bugs because of its dynamic type system

ImaginativeVucubCaquix's Experience

Awesome See More

Specs

Current stable version:1.9

Site:www.clojure.org

Price:Free, Open Source

Platforms:Windows, Linux, Mac

See All Specs

Top Pro

Terse syntax

Clojure is a Lisp and as such is has the distinct syntax of Lisp dialects which is extremely terse and easy to read for the trained eye. See More

Top Con

Syntax may seem confusing to programmers not used to Lisp

Lisp syntax may seem confusing to anyone not used to Lisp because of its over-reliance on parentheses. See More

VersatileBeliMawr's Experience

Wonderful sintax and productivity See More

Top Pro

Java interop

Since Clojure runs on the JVM it can make use of the Java standard library and other Java libraries or frameworks. See More

Top Con

Slow repl startup time

Amiran Chyb's Experience

Homoiconic See More

Top Pro

Huge ecosystem of libraries to work with

There's a very large ecosystem of high-quality Clojure libraries which developers can use. One example is Incanter. It's a great data analytics library and a very powerful tool for dealing with matrices, datasets and csv files. See More

Top Con

Restrictive License

The Eclipse Public License is a fairly restrictive, complicated license with a lot of license compatibility issues. See More

Top Pro

Interactive development

Although interop/the JVM limits this to a degree (compared to other lisps), clojure is still quite capable/effective at interactive and exploratory programming. See More

Top Pro

Tries to solve problems as simply as possible

Simplicity is one of the pillars on which Clojure is built. Clojure tries to solve many problems in software development as simply as possible. Instead of building complex interfaces, objects or factories, it uses immutability and simple data structures. See More

Top Pro

Immutability is the default

Clojure programmers are highly encouraged to use immutable data in their code. Therefore, most data will be immutable by default. State change is handled by functions (for transformations) and atoms (an abstraction that encapsulates the idea of some entity having an identity). See More

Top Pro

Minimal syntax

Being a LISP, programs are simple: they're just functions and data. That it doesn't get bogged down with syntax or the loftier FP concepts like monads makes it one of most approachable functional languages for beginners. See More

Top Pro

Rich Hickey

The creator is so awesome, he's a feature. Just look up his talks and see why. See More

Top Pro

Cross platform

Clojure compiles to JVM bytecode and runs inside the JVM. This means that applications written in Clojure are cross-platform out of the box. See More

Top Pro

No C/Java syntax

Refreshing, BTW! See More

See All

score 33 · Answer 9

Kotlin

Top Pro

Java interoperability

Since it runs on the JVM, Kotlin is 100% interoperable with Java and can use existing Java frameworks and libraries. See More

Top Con

The need for Java interoperability has forced some limitations

The need to make Kotlin interoperable with Java has caused some unintuitive limitations to the language design. See More

Specs

Current stable version:1.3

Site:http://kotlinlang.org

Price:Free, Open Source

Top Pro

Amazing IDE support

Since Kotlin is made by Jetbrains (the developers of IntelliJ IDEA) so it stands to reason that the IntelliJ support for Kotlin is also great. See More

Top Con

May be hard for programmers already used to imperative style to learn functional programming from Kotlin

Since Kotlin does not enforce any particular paradigms and is not purely functional, it can be pretty easy to fall back to imperative programming habits if a programmer comes from an imperative background. See More

Top Pro

Good standard library

Kotlin has a great standard library. It can also import and use classes from Java's standard library. See More

Top Con

Complex syntax

Could someone update that makes Kotlin syntax more complex that other modern languages? See More

Top Pro

Multiplatform support

Kotlin code can be compiled into JVM byte-code, JS or native app on Unix, MacOS, Windows or iOS. See More

Top Pro

Great Documentation

Top Pro

Inline Functions

Allows to normalize out the code into the function without overhead of function call. See More

Top Pro

Extension Functions

Within the scope code may define function/constructor which behaves like it is part of the class itself. Makes code more concise and readable. See More

Top Pro

No Null References by default

Explicit nullable and not-nullable types allows compiler to fail fast (during compilation) instead of run-time NPE See More

Top Pro

Type-Safe Builders

Kotlin support great way to build DSL for any purpose and yet keep code type-safe. Actually a lot of standard libraries are DSL wrapper around standard Java libraries. See More

Top Pro

Android development

Kotlin can be used for developing new and existing Android applications. It compiles to Java bytecode and has can be used alongside Java. See More

Top Pro

Properties

No boiler plate definition of class properties with auto generated getters and setters See More

Top Pro

Value types

Language making sure values are read-only See More

Top Pro

Generics

Declaration-site variance, Use-site variance: Type projections and Constraints See More

Top Pro

Open Source / Contribution

Top Pro

Tail Recursive Functions Marker

With compiler optimization See More

Top Pro

Low-risk adoption for existing Java codebases

Since it has such a good interoperability with Java, Java libraries, and Java tools. It can be adopted for an existing Java codebase at little to no cost. The codebase can be converted from Java to Kotlin little by little without ever disrupting the functionality of the application itself. See More

Top Pro

Smart Casts

Auto Cast on Type check etc. See More

Top Pro

No runtime overhead

Because the standard library is pretty small and tight, it mostly consists of focused extensions of the Java standard library. See More

Top Pro

Gradle Language

Top Pro

Great tooling support

Since Kotlin is made by Jetbrains (the developers of IntelliJ IDEA) so it stands to reason that the IntelliJ support for Kotlin is also great. Besides that, Kotlin also works well with existing Java tools such as Eclipse, Maven, Gradle, Android Studio, etc... See More

Top Pro

Easy to define type-safe DSLs

Language includes features to define DSL (Domain Specific Language). See More

Top Pro

Enthusiastic community

Kotlin has an enthusiastic and rapidly growing community of fans. See More

Top Pro

Data class

Automatically creates getters, setters, hashCode, equals and components access for spread operator. See More

Top Pro

Quick compiler

Including incremental compilation See More

Top Pro

Ranges

Simple syntax to define ranges and “lazy” execution if used the “streaming” interface. See More

Top Pro

Less error-prone because of its static type system

Since Kotlin is statically typed, potential type errors are caught at compile-time. See More

Top Pro

Built to solve industrial problems

Kotlin has been designed and built by developers who have an industrial background and not an academic one. As such, it tries to solve issues mostly found in industrial settings. For example, the Kotlin type system helps developers avoid null pointer exceptions. Reasearch languages usually do not have null at all, but APIs and large codebases usually need null. See More

Top Pro

Include both OOP and FP features

Easy to develop in either paradigm, or switch back and forth between paradigms depending on developer's preference. See More

Top Pro

Type Check Constructs

Top Pro

Default parameter values

Supports default values for parameters, avoiding the unnecessary boilerplate code needed to go have default values in languages that don't support them. See More

Top Pro

Object Declaration and Expressions

Built in syntax for creating anonymous, singleton and companion objects. See More

Top Pro

Annotations

Top Pro

Dynamic Type

The dynamic type basically turns off Kotlin’s type checker. See More

Top Pro

Does not impose a particular philosophy of programming

It's not overly OOP like Java and it does not enforce strict functional paradigms either. See More

Top Pro

Easy adoption for existing Java programmers

Kotlin runs on the JVM and Java interoperability has been one of the main objectives since the language was born. It runs everywhere Java does; web servers, mobile devices (Android), and desktop applications. It also works with all the major tools in the Java ecosystem like Eclipse, IntelliJ, Maven, Ant, Gradle, Spring Boot, etc. All of this makes adoption extremely easy even for existing Java projects. On top of this there's also ensured Type safety and less boilerplate code needed. See More

Top Pro

Operator overloading

Top Pro

Easy to learn if you have prior programming experience

Kotlin's syntax is extremely easy to understand. The language can be picked up in a few hours just by reading the language reference. See More

Top Pro

Officially supported for Android development

Starting with version 3.0 of Android Studio, Kotlin support will be built-in. This means that it's now easier than ever to use Kotlin for existing Android projects or even start writing Android apps only with Kotlin from scratch. This also means that Kotlin and Kotlin plugins for Android Studio will be fully supported in the future and their likelihood of being abandoned is quite small since Google is fully embracing the language for their Android ecosystem (alongside Java and C++). See More

Top Pro

Reflection

Top Pro

JavaScript interop

See All

score 40 · Answer 10

Haskell

Top Pro

Statically typed

Haskell's type system is extremely expressive. Often, it is clear how a function should be used from only looking at its type signature. Thanks to full type inference, this seldom gets in your way though and there's generally no need to declare the type of any local variables. See More

Top Con

Very difficult learning process

For people unfamiliar with functional programming, it's a difficult language to learn. See More

FriendlyEucleia's Experience

Easy and clear syntax, especially on the type level See More

Specs

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

Paradigm:functional

Type System:static

Top Pro

Ubiquitous referential transparency

The = used to bind functions and constants means actual mathematical equality. A function's name, code, and calculated value for a given input are all identical and interchangeable; substituting one for another will never change program behavior. See More

Top Con

Basically has no foothold in industry

Nearly 30 years of existence and basically no application effectively in use. (Apart from some mini apps smuggled in by Haskell evangelists, that will disappear once they leave the company). Although, this is slowly changing in the last years. See More

Top Pro

Type Level Computation

One is able to use the type system to induce much more interesting sorts of functional polymorphism than a language which doesn't have this feature can at compile time. See More

Top Con

Rigid pure functional only

It's a wanted limitation to prevent potentially bad code, however it also takes away choices in how you want to code. Also being a pure and rigid functional language, it can take some time to become accustomed to the language, and until some has had a lot of practice and experience with Haskell, they might feel unproductive. See More

Top Pro

Very few language constructs

The base language relies primarily on function application, with a very small amount of special-case syntax. Once you know the rules for function application, you know most of the language. 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

Easy to reason about

Provable correctness, means we can actually know the code is correct. 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

Strong guarantees about library behavior

Because anything a function might do is reflected in its type signature, quirky or unexpected library behavior is generally a non-issue. 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

Pure functional language

Perfect for learning what it really means to use functional paradigms. See More

Top Con

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

Top Pro

Lazy evaluation

Can do things like operating on infinite lists. See More

Top Con

Harder to debug

Once a bug occurs of course. See More

Top Pro

Well-suited for test-driven development

QuickCheck can generate automatic test cases, using the types of a function's arguments to decide what values are relevant. The functional paradigm makes it easy to formulate what equalities a some code should fulfill. See More

Top Con

Disconnected from von Neumann architecture

Compiler need to translate to imperative low level code. See More

Top Pro

Extremely robust for refactoring

If some interface / data structure needs to be modified, even if it's a rather intrusive change in a large codebase, type inference keeps most of the code working as-is, and the compiler will reliably point out the places where it would fail. The strong types make it easy to figure out how to fix those problems. This allows quick prototyping without needing to worry too much about long-term design, and it makes Haskell largely immune to legacy-cruft problems. See More

Top Con

Rejecting community

Unhelpful for newcomers, rejection of any new ideas, haughty and academic people. 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

Written for theory rather than practicality

Intended as a 'model' language rather than something that is supposed to increase productivity/efficiency. See More

See All

score 44 · Answer 11

Go

Top Pro

Compile speed

Top Con

No generics

Elias Van Ootegem's Experience

Even though the question tries to define "best programming language" in a particular way, these questions will always suffer from fanboy-ism. This recommendation isn't too different. Productivity-enhancing: Golang compiles to native, as one of its core design criteria was to build a language that would spit out fast binaries. This usually means dealing with a lot of lower-level nitty-gritty stuff. To get around this, the language has an impressive array of standard packages that allow you to do basic things (like reading/writing files) in a couple of lines, all the way through to writing an HTTP/RPC server that handles some requests, and unit test it. Being able to do this within the standard ecosystem of the language, with a simple toolchain is, by any means, productivity enhancing. Another thing that is productivity enhancing is: there's no runtime to set up (no JVM, no nginx, no interpreter stealing CPU cycles), the compiler is fast, and you either run the binaries locally, or just spin up a container. Either way, docker doesn't really slow you down much (top-tip: use scratch containers). The development cycle (write, test, build, debug) is short and sweet, allowing you to get on with things. Well-designed: The design follows the KISS principle. Some things take time getting used to: curly brackets are not optional, there is no ternary operator, and the most hotly contested language feature: no exceptions. The core design team followed the rule that no feature would make it in to the language unless they all agreed it was needed. Result: classes aren't there (but composition through embedding is a big plus), and ducktype interfacing is all the rage. There are no generics, but interfaces + type assertions/type switches can be used most of the time instead. Overall, the grammar is simple, the number of keywords very limited, but the language does not feel restrictive. Powerful, yet simple, that looks like the hallmark of good design to me. Of course, part of the design is the optimised runtime (GC, routines, channels), which get even better with each new release of the language. Something that isn't listed as a key feature that I really like is how some packages contain functions that you shouldn't use. I know, it sounds weird, but stay with me: The language designers understand the importance of predictable, and symmetrical API's. That's why the strings and buffers packages will have the same functions within them (for consistency). It shows someone thought about usability, and it genuinely feels like a nice touch Concise: Like most modern languages, go is concise. Not as concise as some, but one could argue there's a line between concise, terse, and plain silly. Golang walks that line carefully. Some people may complain that the error handling is a bit verbose, and yes, it adds 3~4 lines each time, where a language with exceptions would add, erm... 3~4 lines, too (try, catch, handle). Either way, if you can write a service providing a basic RESTful API in ~50 lines, whilst still being readable and maintainable, then I'd consider that language to be well designed and concise. See More

Specs

Current stable version:1.11.1 / October 1, 2018

Platforms:Windows, Linux, Mac etc.

GZipped size:21,1 MB

Paradigm:Multi-paradigm: procedural, object-oriented, concurrent

See All Specs

Top Pro

Go routines

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

Event Horizon's Experience

finishing off writing a project for past 18 months which parses video to synthesize the audio equivalent where all the RGB pixel level information of the input data is expressed in audio ... the kicker is it then parses the audio to synthesize output video which matches the input video ... of course the loop can start with audio as well as in audio -> video -> audio and not just video -> audio -> video ... I am using Hilbert Curve as well as Fourier Analysis ... possible uses include ability to permit people to see what others can hear and visa versa ... or to edit visually a music or audio project you are creating This is my first golang project - and have learned to appreciate go See More

Top Pro

Statically typed

Top Con

Dependency management not (yet) settled

The default dependency "management" pulls code directly from repositories, making your code fragile if you are not careful. There are currently several options for managing vendoring the dependencies with 'go dep' on the horizon as standard solution, but this will not happen in the short term yet. See More

DecentEnlil's Experience

compie time and faster See More

Top Pro

Easy to learn

While some of the more complex aspects of Go take a bit to pick up, it is very easy to get a junior programmer with zero knowledge of Go to building impactful applications in very short time. 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

Formatter

Top Con

Deferred functions are poor substitute for exception handling

Top Pro

Readable code

Top Con

Weak type system

Top Pro

Minimalism

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

Rich standard library

Top Con

Build system forces to put sourcecode in one folder

Currently the build system forces you to put your sourcecode in one folder called the "GOPATH". This cannot be changed in any way. See More

Top Pro

Statically linked binary

Top Con

Structural typing

Top Pro

Ease of cross compilation

Top Con

Promotes obfuscation, just like C/C++

Top Pro

Easy import system

Top Con

Error handling

Top Pro

Testing support included

Go includes a simple yet powerful framework for writing tests and benchmarks. Added plus: Examples that double as test cases and (runnable) examples in documentation - no more outdated code examples in the documentation! See More

Top Pro

Midway between C and Python

Top Pro

Meaningful error messages

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 Pro

Almost C like performance but safe

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

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 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 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 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 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 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 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

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

See All

score 18 · Answer 12

Julia

Top Pro

Nice regular syntax

Julia code is easy to read and avoid a lot of unnecessary special symbols and fluff. It uses newline to end statements and "end" to end blocks so there is no need for lots of semicolons and curly braces. It is regular in that unless it is a variable assignment, function name always comes first. No need to be confused about whether something is a method on an object or a free function. Unlike Python and Ruby, since you can annotate the types a function operates on, you can overload function names, so that you can use the same function name for many data types. So you can keep simple descriptive function names and not have to invent artificial function names to separate them from the type they operate on. See More

Top Con

Young language with limited support

Julia was released in 2012. Due to it's short existence, there is a limited amount of support for the language. Very few libraries exist as of yet, and the community is still quite small (though growing quickly). See More

Specs

Current stable version:1.0

Site:julialang.org

Platforms:Windows, Linux, Mac, FreeBSD

Type Model:Dynamically Typed

Top Pro

Python interop

Julia's PyCall can use Python modules about as easily as Python can. See More

Top Con

1-based array and column major

This design probably comes from Matlab, but makes it unnatural to interface C and C++ and python. See More

Top Pro

Fast speed and dynamic-typed

Top Con

Too strongly rooted in the array-based paradigm

Julia, like Matlab, R and NumPy, favours implicit vectorisation over explicit looping/mapping. Although this is popular particularly among non-programmers (scientists, engineers...), it tends to contravene robust program design. If everything is an array, it becomes hard to track what the indices mean. For larger projects, it is necessary to write proper abstractions; Julia does support for this, but it's not sufficiently encouraged. See More

Top Pro

Almost as fast as C

Julia runs almost as fast as C code. See More

Top Con

Significant whitespace

[x - y] is different than [x -y]. The former is a one-element vector with the element computed by the difference of x and y. The latter is a two-element vector containing x and negated y. See More

Top Pro

Great standard REPL

Out of the box Julia has a very good Read-Eval-Print-Loop, which both completes functions and types, as well as completion based on history of previous statements. It integrates well with the shell and has an excellent online help system. See More

Top Pro

Written in itself

The Julia language is written in itself to a much larger extent than most other languages, so a budding programmer can read through the depths of the standard library and learn exactly how things work all the way down to the low-level bit-twiddling details, which can be englightening. See More

Top Pro

Strong dynamic typing

Dynamic and high level, but does not isolate the user from properly thinking about types. Can do explicit type signatures which is great for teaching structured thinking. See More

Top Pro

C interop

Julia can call C functions directly (more or less). See More

See All

score 44 · Answer 13

C#

Top Pro

Helps with catching bugs early because it's statically typed

Being a statically typed language, it helps a lot with catching potential bugs in compile-time. See More

Top Con

.NET stack lock-in

The tooling, the libraries, the frameworks etc. mostly is either created from and / or for Windows / Microsoft. Crossplatform development with C# is not fluent and until recently not official. See More

CapableVerminus's Experience

The sexiest language out there. Love LINQ, Lambdas, Anonymous types and functions, etc. Also, the dynamic type - I can pretty much do anything I need with C#. Type safe function pointers? Use delegates or the newer Func<> / Action<> types. It's the Swiss army knife of modern day languages. See More

Specs

Current stable version:7

Platforms:Windows, Linux, Mac

Top Pro

Delegates

Methods can be passed as first class programming entities known as delegates. Compared to early C languages, the syntax for passing methods is intuitive. See More

Top Con

Lack of compile-time metaprogramming

The programmer is stuck with language features that are already implemented. Some problems, that can be easily solved in dynamic languages or languages with metaprogramming features have to be hacked around. Example : INotifyPropertyChanged invocations. See More

HonorableBythos's Experience

Pain in the ass to work with. Even pure C is better than this AIDS-tier language. See More

Top Pro

Extension methods

Extension methods provide the ability to add methods to existing classes, even when you don't have access to its code. See More

Top Con

Suffers from excessive syntactic sugar - 12 different ways to do everything

Top Pro

High-quality tooling available

Visual Studio, ReSharper and nDepend are only few of examples of high-quality tools that are available for C# developers. See More

Top Con

Expensive tooling

Visual Studio and ReSharper are quite expensive, especially for personal use. Visual Studio Community is an official version of Visual Studio and free for personal use and companies with up to 5 employees. However, Visual Studio Community is not as powerful as the full version (that is, Enterprise). See More

Top Pro

Async-await

C# invented the async-await pattern. Asynchronous programming is a must-have for any scalable web server or responsive mobile application. You can't simply freeze your app while you request that background image as you can't simply fire up a hundred thousand threads on your web server to deal with all the requests. What you do in these situations is use asynchronous programming. The problem is that, until C#4, async was really hard to get right. Now, with async-await, developers are able to write code just as they did with synchronous code. The language handles everything for you. See More

Top Con

Complex syntax

Too many syntactic constructs to learn before it becomes usable. See More

Top Pro

Solid Reflection

You can get type information during run-time, like how many methods a class has or what are the names and values of the fields of an object. See More

Top Con

Dependecy on IDE

Most people learn and depend on VisualStudio to write C#. The result is people learn how to use an IDE and not the concepts or fundamentals of good programming. This isn't necessarily a knock on the language itself, but it is frustratingly difficult to do things in C# when not using VS. See More

Top Pro

RAD: rapid application development.

Productive as hell. See More

Top Con

Nullable references by default

Top Pro

LINQ

Language INtegrated Query provides declarative SQL-inspired syntax for querying data from a variety of sources. Databases, Web resources, and in memory collections can be queried using the same syntax. This syntax drastically reduces the number of lines of code required to work with collections. See More

Top Con

Lack of compile-time reflection

There's a lack of compile-time reflection, forcing type reflection to runtime, evne for cases that could easily have been evaluated at compile-time; thus decreasng performance a lot, considering reflection is expensive. See More

Top Pro

Modular

With .NET Core and Nuget, you get only what you asked for. No dumb libraries hanging around making your executable larger. See More

Top Pro

Good performance

C# is Just-In-Time compiled to target the runtime hardware architecture. This can make it very quick if you can stomach a small startup delay. See More

Top Pro

Properties

Get and Set methods feel counter-productive. C# resolves this by making the notion of a "Property" part of the language itself. Auto-properties enables developers to write properties just like if they were fields, with its get and set acessors automatically implemented. The syntax for accessing properties is also cleaner: they work just like if you were accessing a field. See More

Top Pro

Awesome IDE for Windows

On Windows, Visual Studio is the recommended C# IDE. It provides a very flexible GUI that you can rearrange the way you want and many useful features such as refactorings (rename a variable, extract some code into a method, ...) and code formatting (you can pick exactly how you want the code to be formatted). Visual Studio also highlights your errors when you compile, making your debug sessions more efficient since you don't have to run the code to see the mistakes. There's also a powerful debugger that allows you to execute the code step-by-step and even change what part of the code will be executed next. In addition to giving you all the line-by-line information you'll need in a hassle-free manner, Visual Studio has stuff you can click on in the errors window that will take you to the documentation for that error, saving you several minutes of web searching. In addition to all of this, Visual Studio has an intuitive, intelligent, and helpful graphical user interface designer that generates code for you (the best of WYSIWYG, in my opinion), which is helpful for new programmers. Being able to create a fantastic-looking UI with one's mouse and then optionally tweak with code helps make programming fun for beginner developers. Visual Studio also has the best code completion --Intellisense is every bit as intelligent as the name says it is. It, as well as VS's parameter hinting, is context-, type-, user-, and position-sensitive, and displays relevant completions in a perfectly convenient yet understandable order. This feature allows a new programmer to answer the questions "What does this do?" and "How do I use it?" right then and there rather than having to switch to a browser to read through extensive documentation. This allows the programmer to satisfy their curiosity before it is snuffed out by several minutes of struggling through exhaustive documentation. And for the more adventurous and text-ready developer, Microsoft does the best job of ensuring that everything, from interfaces and wildcard types down to Console.WriteLine("") and the + operator, is well-documented and easy to understand, with relevant and well-explained usage examples that manage to be bite-size yet complete, simple yet truly helpful. The reference site is easy to navigate, well-organized, clean and uncluttered, up-to-date, and fresh and enjoyable to look at, and every page is well-written with consideration for readers who are not C# experts yet want to read about changing the console background color. The best part? It's free! Visual C# Express contains all of the features described above, at zero cost. If you are a student, you can probably get Visual Studio Professional from your university, which also includes tools for unit testing and supports plugins. See More

Top Pro

Supports some functional features

C# is primarily object-oriented, but it also supports some features typically found in functional languages such as lambdas, delegates and anonymous classes. Methods can be treated like any other object, and the Linq query system operates on monads with lazy evaluation (though it hides this with a lot of syntactic sugar). You don't need to use these features to code in C#, though, so you can start with OOP and then learn about them. See More

Top Pro

Reified generics

Types used as generic parameters are retained within the runtime. This allows for better program optimization and reflection when using generic types. See More

Top Pro

Value types

In C#, the developer has the power to allocate objects on the stack through the use of structs. In other languages where everything is a class (reference type), the max one can do is hope the compiler will be able to do escape analysis. See More

Top Pro

Built-in tuples

C# 7 adds support for tuples built into the language. Instead of explicitly using generic Tuple classes, the developer is able to use parenthesis to represent a tuple. Tuples can also have named properties, so that instead of writing "Item1, Item2, Item3", you writed "Price, Quantity, Name". Tuples can also be deconstructed into variables. See More

Top Pro

Attributes / Annotations

C# supports attributes that enables the developer to write declarative code. The developer can also write custom attributes. See More

Top Pro

Expression-bodied members

C# supports expression-bodied members. When a function or property member is very short, you can write it inline, using the short-hand (fat arrow) operator. See More

Top Pro

Portable

C# can not only run on Windows, but is also officially supported on a lot of Linux distros and also on Mac, Android and iOS. C# enables you to build a single codebase and target all of those OS at once. See More

Top Pro

Type inference

The var keyword makes it possible to infer the type of a variable. No need to repeat types on both sides of an assignment. See More

Top Pro

Pattern matching

C# 7 adds support for basic pattern matching. See More

Top Pro

Default parameter values

Default parameter values enable the developer to have optional parameters. See More

Top Pro

Organized, meaningful namespaces

In a language like Java, for example, you have java.util. "util" conveys no meaningful information about what types you will find in there. On the other hand, C# namespaces were carefully thought-out in order to make it easy for the developer to navigate through the Base Class Library and to find the types they need. You will find TcpClient under System.Net, HttpClient under System.Net.Http, encryption-related classes under System.Security,Cryptography, File under System.IO, generic lists and dictionaries under System.Collections.Generic. See More

Top Pro

Object initializator

C# supports object json-style object initialization. See More

Top Pro

Generators

C# supports iterators and generators through the use of the yield keyword. See More

Top Pro

Methods can return more than one value

C# supports pass-by-reference through the keyword ref. A method can also have out parameters, which are parameters that will be outputted to the caller. This way a method can return more than one value. See More

Top Pro

Very high demand in the industry

Top Pro

XML Documentation

Developers are able to document their code with XML tags like <summary>, <params> and even <b></b> or <br/> and then generate documentation pages through tooling. See More

Top Pro

Support for dynamic typing

Although C# is statically typed, it does support dynamic typing. The dynamic keyword creates a dynamic object, which behaves exactly like you would expect from other dynamic languages like JS or PHP. See More

Top Pro

Great introduction to object-oriented programming

Object-oriented programming is the most widely-used paradigm. C# offers support for common OOP features such as classes, methods and fields, plus some features not found in competing languages like properties, events and static classes. C# code is much more readable thanks to the syntactic sugar it offers. You can truly concentrate on your code, not on the way it's implemented. See More

Top Pro

F# and VB interoperability

As F# and VB all compile to CIL (Common Intermediate Language) and all use the .NET Framework, C# is able to work with those languages seamlessly. See More

Top Pro

C/C++ interop

C# is able to call native C/C++ code. See More

Top Pro

.NET BCL

The .NET Base Class Library has everything covered. From basic things like collection, to utilities and/or advanced stuff, like System.Net.Http (for Http requests), System.Drawing (for drawing on the screen), System.Security (for everything security, including cryptography, JWT, etc.) and more. See More

Top Pro

Best language for Windows programs

C# is clearly the best choice for Windows programs. The .NET framework contains everything you need to build great-looking apps, without having to learn the confusing Win32 API or download a ton of external libraries. C# can also be used to build Windows 8's "modern" apps. See More

Top Pro

ASP.NET

ASP.NET Core is a blazing fast framework for building Web Applications and Web APIs in C#. ASP.NET Core ranked as the fastest mainstream framework in the TechEmpower Round 13 plaintext benchmark. With ASP.NET Core, you can build MVC apps or REST APIs, as well as micro-services and even stateful web apps. ASP.NET Core comes equipped with Authentication and Authorization, and has also good community support, with libraries like OpenIddict, which implements the OpenId Authentication protocol in C#. See More

Top Pro

NuGet

NuGet is package manager, primarily for .NET ecosystem. See More

Top Pro

Great language for Unity game engine

Unity provides a selection of programming languages depending on preference or knowledge - C#, JS, Boo and UnityScript. C# is arguably the most powerful with better syntax and stronger language structure. It allows using script files without attaching them to any game object (classes, methods inside unattached scripts that can be used at any time). There are more tutorials and information for C# than UnityScript and Visual Studio can be used to code for unity in C#. Additionally, learning C# allows using it outside of Unity as well unlike UnityScript. See More

Top Pro

Supported on many platforms

C# can be used for Windows apps, Linux apps, OS X apps, Windows 8 "modern" apps, websites, games, iPhone apps, Android apps, Windows Phone apps, and more. If you want to create a cross-platform application, you can share most of the code and write one GUI for each platform. See More

Top Pro

Incredibly Well-Engineered Language

Where other languages invoke the feeling of being a product of organic growth over time, C# just feels like an incredibly well-designed language where everything has its purpose and almost nothing is non-essential. See More

Top Pro

.NET is a great toolbox

C# runs on top of the .NET framework, which provides many libraries containing classes used for common tasks such as connecting to the Internet, displaying a window or editing files. Unlike many other languages, you don't have to pick between a handful of libraries for every small task you want to do. See More

See All

Answer 14

F#

Top Pro

Clean succinct 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 Con

Not really cross platform

Though the community sites are touting F# can be cross platform through use of Mono, the reality is that it is more of a hack to replay on larger mono applications in production. See More

What are the best (productivity-enhancing, well-designed, and concise, rather than just popular or time-tested) programming languages?

78 Options Considered

Elixir

My Recommendation for Elixir

My Recommendation for Elixir

Very friendly functional language

Slow

Amazingly robust and fluid multi-processing

Some design choices may seem strange

Compiler errors usually explain why that's an error

Dynamically typed

BEAM VM and OTP library

Single threaded

Great for concurrency

Great documentation

Part of the best web full-stack framework currently available

Easy to download libraries

Powerful metaprogramming

Syntax is similar to Ruby, making it familiar for people used to OOP

Full access to Erlang functions

Dynamically typed

Nim

My Recommendation for Nim

My Recommendation for Nim

Statically typed

Community is too small

Runtime speed

Still in pre 1.0

Compiles to C or JavaScript

Async/await features

Awesome syntax

Powerful metaprogramming

Open source

Garbage-collected

Easy to integrate with another languages

Easy to read

Strict typing

Has built-in async support

Really crossplatform

Type interferencing

Multi paradigm

Built-in Unicode support

Supports UFCS (Unified Function Call Syntax)

Great metaprogramming features

Has built-in unittest module

Compile-time execution

Python

My Recommendation for Python

My Recommendation for Python

Comes with extensive libraries

Bad parallelism

Clear syntax

Arbitrary semantic quirks

Multipurpose

Language fragmentation

Easy syntax. Easy to learn, hard to master

Harder to catch bugs because of its dynamic type system

Emphasis on readability

Bad performance

Sequences

Improper closures

C Interop

Slow to run

Generators

No access modifiers

All objects including functions are first-class objects

Not good for mobile development

One right way to do things

Limited support for functional programming

Decorators

Significant whitespace

Default parameter values

Slower language updates

Good language for beginners

Sacrifices principles for beginner-friendliness

Lots of tutorials

Speed can matter

Good documentation

Mandatory indentation

Very similar to pseudo-code