Table of contents
In recent years, Many novel programming languages have emergerd, and new concepts continued to appear. I always wanted to learn about various new programming languages, and it would be nice to master one more language if it is prospective. Therefore, this article summarizes my understanding of some popular modern languages and their various characteristics. If you are also interested in trying a new language, then I hope this article can help you~
For the popularity of languages, we can refer to TIOBE rankings, Github rankings and StackOverflow rankings. I won’t go into details in this post about the language features, since they’re still evolving over time. And for the same reason, the comments on each language only reflects my impression on each language listed here.
This post focuses on general programming languange. For Domain-Specific Languages (DSL) like SQL, I won’t include them cuz you have to learn them only when needed.
In terms of the history of the programming languages, there’s a very interesting picture below (source here), if you’re interested in the details, you can refer to the wikipedia pages about the history and the timeline (highly recommend the second one!), or refer to this website.
Features of a modern languange
Before the summary, first I should introduce some programming concepts for a better understanding of the languages. The comparison in depth of the concepts can be also found in wikipedia. Here the introduction is also very brief, you can search these keywords for further information.
- Object-Oriented: This should familiar to you if you have attended any class about programming. Object-oriented programming usually means that the core logic of the code is built around “classes”. A class contains a definition of an object and some associated methods, an derived class can be used to simplify the code.
- Dynamic / Static Types: Static typing requires the program to specify the type of each variable while for dynamic typing that’s not a requirement. These two options are trade-off between the flexibilty and the safety of the program. A similar naming of this choice is strong / weak typing. In weak typing languages, there’s a concept called “Duck-typing”, which means we only care about what interface the object/type provides, rather than ensure that the object has a specific type.
- Meta-Programming / Generic Type: Meta-programming means that we can generate code with some “meta” code, a representative case is the template in C++. Meanwhile, generic types are similar to meta-programming, but it won’t generate code explicitly, it’s just some code supporting types as parameters.
- Imperative / Declarative / Functional: In imperative Languages, you instruct the program, step by step, to do something; In declarative Languages, you only tell the program what you want to do; In functional Languages, the function is the first-class citizen and the program will achieve the goal by call functions sequentially. The functions usually can be stored in variables as well.
- Parallelism: Parallelism means that the program supports running multiple code blocks in parallel (including processes, threads and coroutines)
- Data Science: Some programming Languages are designed for data scientists, which mainly features the built-in support for high-precision and high-dimensional data.
- Test-driven Development (TDD) / Design by Contract (Doc): These are two different paradigm for building the program. Test-driving means that the target of coding is to passing some tests, while design by contract means the program has to meet some constraints during coding. Support for tests and contracts are not critical for programming languages, but in modern complex programs, they can drastically improve the efficiency and safety of the development.
- Virtual Machine / Intermediate Language: A few languages support cross-platform compatibility through languange virtual machine, which will convert the intermediate codes to machine codes. The representatives are JVM, CLR and LLVM.
- Garbage Collection (GC): Garbage collection is a feature built in some languages’ runtime. With this feature, you don’t need to worry about the lifetime of variables, since the garbage collector handles the deconstruction for you.
Now I will lists the 1-line comments of the mainstream programming languages selected from the rankings mentioned above.
Why to choose this languange in (about) 1 sentence
- C: All time god which is closest to assembly languange with little dependency and high performance. The ABI written with C can be called from most other languages
- C++: One of the most powerful Languages with full support of object-oriented programming and meta-programming, and full compatibility with C
- C#: Full of syntax sugar and faster than Java. The recent advancements in open-source provide more resources.
- D: Aiming at replacing C++ with many modern features including design by contract
- F#: Functional version of C#
- Fortran: Old but blazing fast language, even faster than C
- Go: Fast compilation with great coroutine support and produces single file executable without dependencies
- Groovy: Dynamic typing version of Java built by Apache, similar goal to Ruby
- Haskell: Representative of functional language
- Java: Widely used in server applications with tons of available packages, equipped with garbage collector
- Julia: Science-computing oriented languange with builtin support to n-dimensional tensor and fast speed. Has the potential to be the next Fortran
- Kotlin: Java with modern syntax sugar developed by JetBrains, compile to Java or JS
- Matlab: Designed for engineers and scientists with many engineering packages. The Simulink package has no alternatives by now.
- Objective-C: Any pros?
- Perl: Suitable to be used as scripting or glue language, with great string processing utilites.
- PHP: Server-oriented languange that can be embedded into HTML, flexible and simple
- Python: Very flexible with everything being an object. Great readability and interoperability with C/C++. Tons of available packages
- R: Designed for statistics with rich domain-specific packages
- Ruby: Chained calling, sugar syntax and as flexible as Python
- Rust: Memory safety ensured in language level. No garbage collector means that it’s fast!
- Scala: Scala is like C++ on JVM, while Kotlin is like C# on JVM
- Swift: Replacement for Obj-C developed by Apple. Similar to Java
- Vala: Aiming at replacing C/C++ in GUI programming in Linux (Elementary OS). Compile to C = fast speed.
- Visual Basic: Builtin support by many Microsoft software
Why to avoid this languange in (about) 1 sentense
- C: No modern language features, unsafe and hard for object-oriented programming
- CoffeeScript: No compelling feature, Typescript might be a better choice
- C++: Templates are very hard for debugging, slow compilation. Many modern features are implemented based on templates and std libraries, which are not elegant
- C#: Confusing runtime standards, frequently changing API and sometimes break backward compatibility
- D: No sponsor = poor eco-system
- Dart: Again, typescript might be a better choice
- F#: I don’t know who is using it, C# is good enough
- Fortran: Old syntax and no modern language features
- Go: No generics, don’t allow unused variables and modules
- Groovy: There’re better alternatives outside of JVM Languages
- Haskell: Learning it is like learning to be a mathematician
- Java: Verbose, not as elegant and fast as C#
- Julia: The package manangement is very hard to use. The syntax is also hard to understand
- Kotlin: Slow to compile. No big problems other than that, but there’re better alternatives outside JVM
- Matlab: Proprietary languange owned by Mathworks and you have to install a big Matlab software to run the code. Python and Julia are good enough to replace Matlab (if you are not a Simulink user)
- Objective-C: Only used by Apple, hard to read
- Perl: Hard to read, too flexible and slow. Python is better
- Python: Bad performance, single threaded (caused by GIL)
- R: Even worse than Matlab
- Rust: The compiler is too strict sometimes, and it’s hard to manipulate strings in Rust
- Ruby: Bad performance, usually used only by backend engineers
- Scala: Harder to learn than Kotlin, and worse interoperability with Java
- Swift: Only a good choice for iOS and OSX development.
- Typescript: Only a good choice for Web development
- Vala: Only used by Gnome and ElementaryOS, very small community
- Visual Basic: Don’t use it if you can!