Note that this article is filled with a lot of jargon and might not be a good article for beginners. If you are a beginner, consider it a roadmap for future but stick to your present roadmap.
Before learning any other paradigm, you should learn procedural programming first. Functions, routines, subroutines etc. are core concepts of procedural programming.
Unlike other kinds of languages, procedural languages have limited syntax. Most of the languages include procedural programming as fundamental building blocks. So you can learn procedural programming in most programming languages. While C is the most widely used procedural language, Golang is a modern procedural programming language.
After learning procedural programming, you are now familiar with the basic syntax of most languages. This includes loops, if-else, switch-case, data types, blocks (functions/subroutines) and operations (arithmetic, boolean). Now you should learn object-oriented programming.
In object-oriented programming, we take the analogy of real-world objects to make our own complex data types. OOP introduces many new concepts like inheritance – extending an already defined data type, polymorphism – a block processing and reacting to different data types, encapsulation – restricting direct access to variables associated with an object and abstraction – hiding information within the object.
There are a lot of modern object-oriented programming languages around. Learning one or two OOP languages is important. C++ and Java are quite powerful OOP languages. Other than these, Python and Ruby are also a good choice.
Choosing a programming language depends more on the project requirements than our personal preferences. Like if you are developing an android app, you would choose Java, Kotlin, or C++ (with NDK).
You can develop in other languages as well if a wrapper (react-native) or some transpiler ( Xamarin) to Android is available. If you are developing a full-fledged software that leverages core functionalities of an operating system, you should get yourself familiar with C++, C# (in case of Windows), Swift (in case of OSX) or Rust.
These languages are compiled and hence uses less memory. You can use any interpreted languages like Python, Ruby or Perl as well but they require an interpreter and hence use more memory.
Choose a language that adheres to the field you are interested in.
As soon as the project turns big, it starts to become a spaghetti. This spaghetti starts to create problems by raising side effects ie. changing one function breaks the other one.
To overcome this, we use pure functions (functions that always return the same result for same arguments) and immutables (variables that can’t be changed after instantiated). Functional programming is often used in modern software development. The best example I can think of is React (JS/native). ES6+ provides good support for functional programming with immutables and React leverages it really well.
Modern languages like Python, PHP and ES6 are trying to implement features of functional programming. But they are way too far from a purely functional programming language like Haskell or Erlang. That is a good thing though because without side effects some operations are really hard to implement.
As a learner, you should learn at least one pure functional programming language to get familiar with the paradigm. I would recommend Haskell to you but it is more of a personal preference here as projects (and market) usually demand object-oriented languages more than pure functional languages. Learn any pure functional language to understand the underlying paradigm and use it in your OOP language of choice.
Prototype-based programming takes object-oriented approach a little further by making inheritable objects. Instead of making new instances of classes, you make instances of objects.
As objects are extendable, you can simply extend an already in memory object with new properties and methods.
You might be thinking that we are talking about paradigms, it is stupid to include scripting and systems programming languages in this list. But as the title says, 5 kinds… we are not actually just taking paradigms into consideration. Market demand, project requirements, skills, and toolsets are also being taken into consideration.
On the Backend, you have a choice. But then it is dependent on project requirement and server configuration. In most cases today, web applications are hosted on cloud hosting. So you can use pretty much any programming language that comes with good HTTP support. From PHP to Rust, there are plenty of choices to choose from.
Mobile development is usually done for Android and iOS. Many languages have libraries, frameworks, transpilers, and wrappers for Android and iOS. Officially supported languages for Android are Java and Kotlin. For the iOS, Objective C and Swift is officially supported. There are other handheld devices like Windows Phone but they are pretty much obsolete in the market as very few people own such devices.
As a software developer, you will face databases at least once in your lifetime. Even if you work on the frontend, as you start working on progressive web apps (maybe you already do) you will face the need for a database. That is why IndexedDB exists. But you probably don’t need to learn a lot of query languages.
While there are a lot of query languages, there are not much query languages needed in the wild. SQL with different flavors like MySQL, MSSQL, SQLite should be good enough for most situations. Other than SQL, people are also going crazy over GraphQL. So learning it won’t hurt.
While you are good enough with one or two query languages, you do need to understand the concepts behind databases especially relational databases and NoSQL.
Programming languages to learn are already covered. But you should also get yourself familiar with the following languages, formats, tools, and concepts:
Also read : 17 programming tips to write better code
This is such an exhaustive list of programming languages but so is modern software development. As a programmer, we have two responsibilities to follow. First is writing good maintainable code, second is learning more. Do not get overwhelmed by so many technologies surrounding you. Just utilize what you learn and learn what you don’t know.