| 60 Recommended Products | Recommendations | Price | Site | Current stable version |
|---|---|---|---|---|
| #1 Pascal / Object Pascal· · · | 78 | 31 | – | – | – |
| #2 Swift· · · | 30 | 31 | – | – | – |
| #3 Elm· · · | 176 | 43 | Open Source | http://elm-lang.org/ | 0.18 |
| #4 Python· · · | 520 | 114 | – | https://www.python.org/ | 3.6.1 |
| #5 Kotlin· · · | 74 | 23 | Free, Open Source | http://kotlinlang.org | 1.1 |
| #6 Ceylon· · · | 41 | 14 | Free, Open Source | http://ceylon-lang.org | 1.3.2 |
Pro Clear syntax
procedure test(); begin DoSomething(); end;
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.
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 RemOb...
Con Swift is a moving target
They've released 1.2 so far, and 2.0 is coming soon. Every small update brings adjustments to paradigms (such as how to do type casting) that can be a little frustrating to absorb. Objective C was also constantly updating, however, but not at the same rate these days.
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 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 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 in...
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...
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 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 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...
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...
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, Mave...
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.
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.
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.
Pro Strong static typing, null safe and flexible, almost dynamic type system
The compiler prevents you from using a potentially null variable, unless you check it is not null. Ie. it forces you to check a potentially null value before using it. The type system is strict, but flexible, allowing union and intersection of types, covariant and contravariant types, reified typ...
Pro Designed from the start to generate JavaScript
It brings type safety to JS, allowing to define interfaces to existing JS APIs, yet using the dynamic keyword for flexible calls in the JS ecosystem.
Pro Excellent IDE support
Ceylon has reified generics, so it doesn't loose the type of collections at runtime. This makes autocompletion, debugging, etc. first-class. The Eclipse plugin makes it a full-fledged Ceylon IDE, and an IntelliJ IDEA plugin is in the works.
Con Currently has large runtime
Ceylon 1.2 needs a language runtime of 1.55 MiB, and the Collection library adds another 370 KiB. That's a lot for the Web... Now, this has to be put in perspective: if you use Ceylon to make a web application, these files will be loaded once, then cached by the browser (that's not casual...
Con Lack of physical or electronic books
We should hope Red Hat or anyone interested would take the time and write one. That would strengthen the maturity of the language, but Ceylon is rapidly developing which can make the author's efforts futile because his or hers work will become obsolete soon. The second hindrance is, of course,
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...
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 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 inc...
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 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 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.
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 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 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...
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&#...
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 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 Great standard library
Dart includes a truly comprehensive core library, making it unnecessary to include disparate, external resources for basic functionalities Other than reducing the need to pull in various 3rd-party utilities this also ensures that all Dart code looks and feels the same. Out of the box, the develo...
Pro Great async language support
Dart is a single threaded programming language. So if any piece of code blocks the execution of the program, the program practically freezes. To avoid this Dart makes use of asynchronous operations which let your program run without getting blocked. This is done through Future objects. A Future is
Pro A lot of tools are available to help in developing with Dart
Dart has a lot of tools available which help with developing Dart applications. Some examples of those tools include: pub - package and dependency management and build tool analyzer - static syntax analysis with linter, quick fixes, autocompletion support for easy IDE integration test -
Con Doesn’t generate consumable JavaScript at present
Dart builds to JavaScript but the entire app needs to be built to JavaScript at once for now (that may change in the future).
Con Still many holes to fill while converting code to Javascript
While implementing callbacks, passing a type to any function that gets passed to Javascript causes the dart2js compiler to crash.
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 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 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-...
Pro Great documentation
The official Lua documentation is very helpful and thorough. There are also a large number of online resources or books with lots of helpful information for beginners and advanced users alike.
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...
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 p...
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 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 Static type system inherits cruft from Java
The type system is too complicated yet still less powerful than Haskell's.
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 Way too complex for beginners
Even for seasoned programmers it's a difficult language.
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.
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...
Con Young language with limited support
Julia was released in 2012. Due to its 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).
Con 1-based array and column major
This design probably come from Matlab, but makes it unnatural to interface C and C++ and python.
Pro Provable purity and immutability
The compiler can check that functions don't have side effects, extremely important for functional programming in concurrent scenarios, and can check immutability. Therefore, the compiler will prove that your programs are functionally pure and respect immutable data, if you want it to.
Pro Very fast compilation
D is usually up to 10 times faster than C++. Having a language that compiles this fast means that you are free to write highly optimized code because of the relatively low cost of experimentation.
Pro Static with type inference
For a new user adding types can feel tedious, and takes focus off the meaning of the code, but they are also important for checking logic. D provides static types, and a good system to infer types, so types are checked when calling functions, but do not need to be specified everywhere, making it...
Con Poor adoption even after many years of existence
There's a widely accepted perception of D as a language that has been poorly adopted. Since adoption is driven by perception this becomes a fact. So managers and engineers start becoming nervous in adopting a language that has such a perception among the community and that has been so unsucces...
Con Lack of vision
D is community-driven and lacks the support of any large corporation. While this increases the amount of talent and engineering abilities of the people working on D, it also brings a severe lack of charisma, leadership and vision.
Con All the downsides of garbage collection without any of its benefits
When D decided to implement garbage collection it instantly alienated a large community of developers (C and C++ programmers). For them, the official policy has been: "Don't want garbage collection? Use D with RAII or manual management style!". While true, it's also absolutely...
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.
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 Generics support
You don't have to write same array and dictionary classes hundreds and thousands times for strong type check by compiler.
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.
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.