| 61 Recommended Products | Recommendations | Site | Current stable version | GZipped size |
|---|---|---|---|---|
| #1 Clojure· · · | 155 | 52 | www.clojure.org | 1.8.0 | 5.7Mb, requires JAVA |
| #2 Haskell· · · | 155 | 63 | https://www.haskell.org/ | – | – |
| #3 Common Lisp· · · | 51 | 25 | – | – | – |
| #4 Scala· · · | 147 | 75 | scala-lang.org | 2.12.3 | – |
| #5 Racket· · · | 58 | 18 | – | – | – |
| #6 Smalltalk· · · | 104 | 30 | http://pharo.org/ squeak.org cincomsmalltalk.com cuis-smalltalk.org | 6.1 | 38MB |
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).
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.
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.
Con Confusing error messages
Clojure's error messages more often than not are very confusing. They usually involve stack traces that do not thoroughly explain where the error was caused or what caused it.
Con Dynamic types
You can put anything in. This makes reasoning about code after a time has passed very hard.
Con Tied to the JVM and it's limitations.
Some language constructs were obviously created as workarounds for JVM limitations. This makes the language much less elegant than it could have been. Also, the JVM has a very cumbersome FFI.
Pro Forces you to learn pure functional programming
It is pure and does not mix other programming paradigms into the language. This forces you to learn functional programming in its most pure form. This avoids you falling back on old habits and learn an entirely new way to program.
Pro Open source
All Haskell implementations are completely free and open source.
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 concre...
Con Difficult learning curve
Haskell lends itself well to powerful abstractions - the result is that even basic, commonly used libraries, while easy to use, are implemened using a vocabularly that requires a lot of backround in abstract mathematics to understand. Even a concept as simple as "combine A and B" is ofte...
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...
Con Symbols everywhere
Haskell allows users to define their own infix operators, even with their own precedence. The result is that some code is filled with foreign looking operators that are assumed to be special-case syntax. Even for programmers who know they're just functions, operators that change infix preceden...
Pro Very Powerful REPL with SLIME
SLIME (Superior Lisp Interaction Mode for Emacs).
Pro Carefully designed for interactive use
Almost all aspects of the language are designed with interactive/repl use in mind.
Pro Condition/restart system
It is easy to recover from errors. Error resolution can be determined by the user at the REPL.
Pro Immutable values
The immutable values make it perfect for working with concurrency
Pro Multiparadigm
Scala supports both Functional and Object Oriented styles of programming. Beginners can learn both paradigms without having to learn a new language, and experts can switch between the two according to what best suits their needs at the time.
Pro Type inference
Scala offers type inference, which, while giving the same safety as Java's type system, allows programmers to focus on the code itself, rather than on updating type annotations.
Con Can be intimidating for beginners
Scala is an industrial language. It brings functional programming to the JVM, but not with a "start small and grow the language" perspective, but rather a very powerful language for professional programmers.
Con Static type system inherits cruft from Java
The type system is too complicated yet still less powerful than Haskell's.
Con Way too complex for beginners
Even for seasoned programmers it's a difficult language.
Pro Free Resources to Learn
Includes several free online books and great documentation.
Pro Racket was designed to teach functional programming from the start
Racket is based on Scheme (LISP Family) and is very similar to Clojure. So there are a ton of (). The reason it is easier to learn is that it is not trying to be "Pure" if there is even such a thing in terms of Functional Programming. The great thing about Racket is it has everything incl...
Pro Realm of Racket is an excellent entry-level guidebook
Realm of Racket teaches the big-bang approach for managing world state. It does so by walking the reader through the development of small games. There are few guidebooks that are as useful and entertaining.
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.
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 g...
Con Not common
Smalltalk and its implementations are no longer popular languages to use. Available jobs are scarce (but do exist), and online communities are relatively small. There is little to no modern books or resources made for the language, although older, very good books do exist.
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 so easy.
Con Non-standard arithmetic ordering
Since every operation is considered a message sent sent is a specific order, all arithmetic operators have the same precedence. E.g. 2 + 3 x 4 translates to 2 + 3, and the result is multiplied by 4, giving an answer of 24 (instead of the correct answer - 14). Once you are learn this, it can easily...
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....
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...
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 ind...
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.
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.
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.
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.
Pro Great for concurrency
Leverages the existing Erlang BEAM VM
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
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,...
Pro Python interop
Hy compiles to Python's abstract syntax trees. Python can import Hy modules, and Hy can import Python modules.
Pro Easier to read
Distinguished between arrays (or vectors) and function calls by using [] and (), respectively.
Pro Copyfree and open source
Uses the MIT (expat) license.
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.
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.
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.
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,...
Con Asynchronous I/O is not (yet) a part of the core language
The issue of asynchronous I/O is still being discussed as a language feature, and not yet in the implementation phase. See the RFC on GitHub here.
Pro Simple syntax
Scheme syntax is extremely regular and easy to pick up. A formal specification of the syntax fits onto just a few pages; it can be introduced informally in a paragraph or two. Students are not distracted by remembering how to write if statements or loops or even operator precedence because every s...
Pro Great, well known textbooks
There is a set of very strong textbooks introducing CS and programming using Scheme. These books are available for free online. The most famous example--and one of the most famous CS books full stop--is Structure and Interpretation of Computer Programs usually known as SICP. This book introduces f...
Pro Great at teaching fundamental programming ideas
Scheme teaches the important, fundamental ideas immediately without the distraction of unnecessary syntax or language features.
Con Little Market Search
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.
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 Sch...
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.
Pro Great and simple way to learn Purely Functional Programming
You can try to apply some functional programming ideas in other languages that have an imperative basis, but you haven't seen the real power unless you tried it in the environment of purely functional programming. Elm is a simple language with great learning resources and easy graphical output,...
Pro High-level Functional-Reactive Code
Build animations, games, and interactions with an incredibly small amount of terse, readable code.
Con Poor tooling
There are editor plugins, but neither of them support basic features yet like navigate to referenced definition show expression type
Con Missing syntactic sugar ('where' clauses, pattern guards)
Elm is missing a lot of syntactic sugar that Haskellers may consider core, such as 'do' notation, 'where' clauses, pattern guards, and operator sections.
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.
Pro Understanding of basics
Because of the verbosity and easy syntax, Pascal language is relatively easier to be learned and understood, even for someone who has no programming knowledge. It's said that Pascal code —if written well— is like reading pseudo code.
Pro Easy
Pascal / Object pascal was used in schools during the 2000's to teach kids the basics of object oriented programming.
Pro Clear syntax
procedure test(); begin DoSomething(); end;
Con Niche language
Most use of this language will be found in jobs supporting legacy code. It will be hard to find things to do with this language outside of that niche.
Con No language standard
After the Wirth era, practically there is no official Pascal language standard. Delphi used to be the dé facto standard especially for industry, but today Free Pascal is starting to get better support. However, there are some other Pascal language variants such as Smart Pascal, Oxygene (from RemObj...
Pro Really crossplatform
The same code can be used for web, server, desktop and mobile.
Pro Strict typing
Checks your code at compile time.
Pro Multi paradigm
Imperative, OOP, functional programming in one language.
Con Still in pre 1.0
Not very stable and has a rather small community.
Pro Very easy to integrate with C and C++
One of the best features of Lua is its very well designed C API. This is very useful if you have an existing C library you need to integrate with Lua or quickly get a Lua script running on the C side of the game. Finally Lua plays so nice with C that if you need to optimise for speed you can re-w...
Pro Fast
Lua's performance compares very well to other languages, If performance needs to be further improved you can: Implement critical parts in C Use the LuaJIT compiler. The LuaJIT compiler is a drop in replacement for the stock compiler and provides significant performance improvements....
Pro Portable
Lua can be built on any platform with a ANSI C compiler. Other than that, Lua is extremely small. For example, the tarball for Lua 5.2.1 is only 245K compressed and 960K uncompressed (including documentation). When built on Linux, the Lua interpreter built with the standard libraries takes 182K...
Con Easy to make mistakes when declaring variables
When writing a function, if a programmer forgets to declare a variable, that variable will be declared at global scope. The code will seem to run fine at first, but if another function uses a variable with the same name, but fails to declare it, it will create subtle, incredibly difficult to find b...
Con Some concepts may not be applied to other "mainstream" programming languages
Lua features a prototye-based inheritance model. While this is also used by Javascript, it's not used by many other mainstream languages, and so some of the concepts learned while learning Lua won't be very applicable to other languages. Another thing that makes Lua different from other pr...
Con Batteries not included
Lua is so small mainly due to many of the components not being included in the core package. A lot of people need the functionality provided by the Lua module management system LuaRocks and libraries such as Penlight.
Pro Concise syntax
F#'s syntax tends to be terse while remaining very readable and easy to understand without being a chore to write.
Pro Easier transition from other paradigms
Since F# is not a purely functional language, it lends itself to being more easily picked up by programmers that have experience with other paradigms.
Pro .NET Interoperability
Since F# runs on the Common Language Runtime or CLR, it has access to the entire .NET Framework, as well as libraries written in other .NET languages such as C#, VB.NET, and C++/CLI.
Con I wish it had ad-hoc polymorphism (á la Type Classes)
You have generics, you have interfaces, you have inheritance, you have a lot of things at your disposal but you don't have Type Clases. They can be emulated using some clever constructs but there's nothing like having the real thing.
Pro Exceptionally simple and scalable multithreaded and concurrent programming.
Simply prepend a function with go to execute it concurrently. Utilizes channels for communication between goroutines which aids to prevent races and makes synchronizing threads effortless. The maximum number of threads to use may be defined at compile time, even if that is limiting goroutines to r...
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.
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.
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 doi...
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 int...
Pro Clean syntax
Ruby has a very clean syntax that makes code easier to both read and write than more traditional Object Oriented languages, such as Java. For beginning programmers, this means the focus is on the meaning of the program, where it should be, rather than trying to figure out the meaning of obscure cha...
Pro A large ecosystem of tools & libraries
Ruby has a large ecosystem of tools and libraries for just about every use. Such as ORMs (Active Record, DatabMapper), Web Application Frameworks(Rails, Sinatra, Volt), Virtualization Orchestration(docker-api, drelict), CLI tools(Thor, Commando), GUI Frameworks(Shoes, FXRuby) and the list goes on.
Pro Widely used
Ruby is one of the most popular languages for developing web sites. As a result, there's an abundant amount of documentation, sample code, and libraries available for learning the language and getting your project up and running. The most popular features are just 'gem install' away. A...
Con Its ecosystem is limited outside of web development
If you're looking to host, generate, manipulate or secure a website, Ruby is your language. There's also some great support here for infrastructure as code work via Chef. However, it just doesn't have the depth and breadth that Python does. Things like native UI development, high per...
Con Meta-programming causes confusion for new developers
The ability for libraries to open classes and augment them leads to confusion for new developers since it is not clear who injected the functionality into some standard class. In other words, if two modules decide to modify the same function on the same class can introduce a number of issues. Main...
Con Monkeypatching
Requiring a library can change the rules of the language. This is very confusing for beginners.
Pro Built from the ground up with concurrency and distributed computing in mind
Erlang has strong roots with the telecom industry in which concurrent processes are normal. It's designed to be concurrent, to be used for distributed computing and to be scalable.
Pro Fault-tolerant
Fault tolerance means that a system has the property to continue operating even though one or more components have failed. For Erlang systems, this means that the system is kept running even if for example a user has to drop a phone call rather than forcing everyone else to do so. In order to ach...
Pro Upgrade code without stopping the system
In a real-time system it may not be possible to stop the system in order to implement code upgrades. For these cases Erlang gives you dynamic code upgrade support for free when using OTP. The mechanism is very easy to understand and works as follows: Start the app Edit the code Recompi...
Con Useful in only one niche
Erlang is not really a general purpose language. It has a very special and well-defined niche where it towers above everything else. It's specialized in scalability and in distributed applications. Which is not necessarily a bad thing per se, but it still lacks and falls behind other languages...
Con Eccentric syntax
Erlang's syntax may feel very strange to 99% of programmers who have never used it. This is because it does not share any similarities or common syntax definitions that are found in all the other languages that are used today.
Pro Actively developped functional programming language at the forefront of research
Functional programming is based on the lambda calculus. OCaml is in its functional parts almost pure lambda calculus, in a very practical manner: useful for many daily programming tasks. The acitve development makes improvements to the type system like generalized algebraic data types (GADT) or pol...
Pro One of the best for writing compilers
OCaml is compiled to native binary, so it's amazingly fast. Being a member of ML-family languages, it has expressive syntax for trees, and has great LLVM support.
Pro Sophisticated and easy-to-use package manager
OPAM is a package manager for OCaml, which is really easy to use, just like npm. It creates a .opam folder in home directory. The documentation is great as well, and you can switch between multiple versions of OCaml for each project. You can also package your project and publish it on OPAM reposi...
Con Strong focus on *nix systems, lacking native support for MS Windows
Lacks native support for Windows systems.
Welcome to the Slant Community
Stop spending hours researching
Slant is written by a community helping you be informed. Let us know what you’re passionate about to get an awesome personalized feed.