When it comes to programming languages to learn, we have plenty of options to choose from. According to Wikipedia, there are more than 700 languages in the world including the esoterics. Obviously, you don’t have to learn all of them. But in the wild, we use multiple programming paradigms. So you should learn at least one programming language of each paradigm. Today, I present you 6 kinds of programming languages you should learn.

6 Kinds of Programming Languages to Learn

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.

Procedural Programming

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.

Object-Oriented Programming

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.

Functional Programming

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

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.

As an example, JavaScript does not allow classes and uses prototype objects to create new classes. Lua also does not have classes and uses prototype-based objects. Some may argue that new ES6+ allows you to create new classes with the class keyword but it is nothing but syntactic sugar over prototype-based classes.

Scripting and Systems Programming

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.

Mobile and web being the biggest market of software, most programming jobs and projects are for these two markets. As a programmer on the frontend, you will mostly work with the API of your platform and the platform you are building for. Every web developer must know JavaScript (ES6+). There is no choice here. Even if you prefer some transpiled languages like TypeScript, you must get familiar with JavaScript.

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.

Database and Query Languages

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:

    • HTML
    • CSS (optionally some preprocessor like sass or less)
    • JSON
    • Markdown
    • Lints
    • Package managers
    • Frameworks (optional but highly recommended)
    • Version Control Systems
    • Algorithms and data structures (you already use many of them without knowing)
    • Design Patterns (maybe you already use many of them without knowing)
    • Architectural Patterns (follow the standards set by community like PHP-FIG)
    • Test Driven Development
    • Continuous Integration Tools
    • Testing Frameworks
    • Containers
    • Hypervisors
    • HTTP, FTP, SSH
    • Linux and sh (preferably, bash or zsh)
  • 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.