It’s time for another post after a very long break! Today’s post is all about understanding the different terms around programming languages and their different types.
Ever since I started to learning how to code, I’ve been bombarded with more or less cryptic jargon like never before in my life. Surely, it’s nothing less than what I expected, but still it has sometimes felt like certain blog posts and online courses should come with a dictionary for us coding rookies.
Inspired by my own learning experience, this post is all about the jargon around the different types of programming languages and paradigms. A programming paradigm is simply a way to classify programming languages into groups based on their characteristics. So, in case you’ve ever wondered what sets a first-generation language apart from a fourth-generation one, keep reading!
Here’s a little overview of all the items in this little glossary of different terms and concepts around programming languages. See something you’re not familiar with – pick it and click it!
Table of contents
- Assembly language
- Compiled language
- First-generation language
- Second-generation language
- Third-generation language
- Fourth-generation language
- Fifth-generation language
- General-purpose language
- High-level language
- Loosely typed vs strong typed language
- Low-level language
- Machine language
- Markup language
- Natural language
- Procedural language
Assembly languages are close to machine languages and only provide little abstraction, making programs very fast and easy on the memory. They are translated into machine language by a program called assembler.
Most often assembly languages only contain a limited number of commands, making it rather easy to learn them.
Even though the command themselves are fairly limited and therefore easy to learn, writing a program in assembly language can be very time-consuming and difficult to manage. Moreover, at the same time the developer needs to be extremely careful not to make any mistakes while typing their code.
Additionally, a specific assembly language only works on one type of CPU, as each type has its own assembly and machine language.
Compiled programming languages are used to create code that can be executed directly on your computer’s processor. Using a compiled language has one major advantage against interpreted languages: programs written in compiled languages tend to run faster.
Relating to the point above, a compiler is the tool which needs to be used to run programs written in a compiled programming language. Whenever you need to run a piece of code written in a compiled language, you need to use a compiler to do that for you. It simply transforms the code into machine code, which your computer can then execute without any additional applications or translation procedures – hence as an .exe file, for instance.
The first generation of programming languages refers to any low-level language that is basically a machine language. In other words, a program written in a first-generation language can be directly run by a computer without using a compiler first.
Second-generation languages are low-level assembly languages. They are easier for you and me to read than pure machine language programs, but still difficult to understand and master, let alone write complex programs and manage them efficiently.
Third-generation programming languages were the first ones to be machine-independent. This was something new after the first two generations of languages, where programs had so far been written specifically for a certain type or CPU, for instance. In other words, you can write programs for several different types of devices with them and use a compiler to run your programs.
The fourth generation of programming languages takes the concept of abstraction to the next level, making the code written in them resemble human language. Therefore, they are easier for us humans to read and interpret, making writing entire programs by yourself comparatively easy and fast.
However, this abstraction comes at the cost of slowing your programs down and using up more memory, since they have to be compiled into machine language for a computer to be able to run them correctly.
Fifth-generation languages contain visual tools for developing programs with them. One good example of them is Visual Basic.
A general-purpose programming language is designed to be used for creating all sorts of different programs. Once you learn one language of this type, you have the tools to use your skills for various different projects. For instance, pick Python as your first programming language and you can write games, do data mining, or write complex web apps from scratch.
High-level languages resemble human language more than low-level languages. This makes them somewhat easier to read (especially for coding newbies) as the code you write with them is more abstracted than with low-level languages. However, in order to run a program written in a high-level language, it needs to be compiled into machine language first.
Loosely typed vs strong typed language
With a loosely typed programming language, you can define and declare a variable, but you don’t need to specify its type. The opposite to this type of a language is a strong typed language, where you need to classify the type for each of your variables.
These are essentially languages where the code you write resembles actual machine language and instructions. In other words, low-level languages don’t provide much abstraction of programming concepts. This sets them apart from high-level languages.
One major benefit low-languages offer is that you can create programs that run very fast and that don’t take up too much memory. The minimal amount of abstraction saves a lot of time for the developers at the smallest possible cost to efficiency and performance.
On the other hand, the low level of abstraction means that you need a deeper understanding of the language, its dynamics, and machine language.
Also referred to as machine code, machine language is simply a collection of binaries or bits. These are then read and interpreted by computers. Quite simply, they are the lowest-level programming language of all, consisting only of numbers.
Hence, out of all languages in the world, machine language is the only one that a computer can understand. Therefore, any computer program that you write in any programming language needs to be turned into machine language first. After that, your computer can execute it normally.
Markup languages are designed and developed to process and present text. For example, the code you write in HTML defines the structure, content, and styling of text on your website. To specify the formatting in HTML, you use different tags inside your code, such as:
All human languages are referred to as natural languages in computer science. One major challenge in computer science is to make it as easy as possible for us humans to interact with computers and develop computers and programs that can understand natural languages. (Siri, you listening?)
Of all programming language generations so far, the fourth-generation ones are the closest to natural languages.
Procedural languages follow a set of instructions or commands in order. These sets of commands build up functions, or routines, that simply consist of individual computational steps that the program executes.
Simply put, a pseudolanguage is any programming language that first needs to be compiled into machine language in order for a computer to be able to understand it and run your program.
Summing it all up
These are just a few of the terms I’ve been explaining to myself quite a few times now during the past months. If you’re just starting with coding, I hope you found an answer or two to any questions you might have. Especially early on, some of the jargon may feel a bit overwhelming – I know how that feels! But trust me, it gets easier with time.
As usual, if you have any questions or ideas, please feel free to comment below! Alternatively, contact me directly anytime and share your thoughts!