Every programmer has their favorite programming language. Sometimes it’s the one that feels familiar, sometimes it’s the one that got the programmer through their first project. But the truth is, programming languages are more than just favorites; they are tools, each with strengths and weaknesses suited for specific tasks. As of now I haven’t found “One language to rule them all”, but some have gotten pretty close.
In my journey as a developer, I’ve spent time exploring different programming languages, discovering not just their syntax, but the way each one influences the way I think about coding. Not very surprisingly, the more programming languages you learn the easier it gets. You will notice the similarities and the differences and start to understand the problems a programming language is trying to solve. I definitely have not tried all programming languages, but I did try a mix of modern and older (but still relevant) programming languages. Ill show a short code snipped per language that will show you some key aspect of it.
Python
Python, the programming language that kickstarted my career and my love for programming. Did I choose this as my first language because it’s syntax is similar to English or because it was gaining a lot of popularity at the time? No, the real reason was because the name Python came from Monty Python, a British comedy group (if you didn’t know that already) which I find hilarious.
After learning Python I was immediately able to make real world project that solved business problems. Due to its simplicity Python is very good for rapid prototyping and creating scripts to automate tasks. Thanks to a great many libraries its also very easy to create a website, connect to databases, create graphical user interfaces (GUI’s), and do about anything else.
Because python is a interpreted language it also runs on any system you put the Python Interpreter on. The downside of python is its execution speed, it will still fall short in raw performance compared to traditional compiled languages.
1def greet(name):
2 print(f"Hello, {name}!")
3
4greet("Job")
5greet(66) # also works fine,python does not check types
C
The C programming language one of the most important programming languages in history. It was created in the 1970s and is still widely used today. Over the years, programmers have built countless libraries and tools for it, which makes it very powerful and flexible.
What makes C special is how close it is to the computer’s hardware. Programs written in C are turned directly into instructions that the computer’s processor can understand. This gives C a big speed advantage and makes it the language behind many operating systems, devices, and other critical software.
But with that power comes responsibility. Unlike newer languages, C doesn’t do much to protect you from mistakes. If a programmer isn’t careful, errors in memory handling can cause crashes or create security risks that hackers might exploit. Still C’s influence is huge, and it remains the backbone of much of the technology we use every day.
All of this makes C an excellent choice for constrained environments like embedded programming. What I enjoy about C is the level of control it gives you over memory. That control can be used in positive ways, such as squeezing out extra performance with clever optimizations. But it also comes with the risk of “undefined behavior” unexpected results that happen when you forget to handle memory correctly. With C, you take the good with the bad.
1#include <stdio.h>
2
3int main() {
4 int x = 66;
5 int *p = &x; // pointer to x, a pointer is a variable that points to the adress of another variable.
6
7 printf("x = %d\n", x);
8 printf("p points to address %p with value %d\n", (void*)p, *p);
9
10 *p = 600; // change value through pointer
11 printf("x is now %d\n", x);
12
13 return 0;
14}
Rust
A more modern language I’ve worked with is Rust. Rust was designed with one main goal in mind: safety. Unlike C, it forces you to write code in a way that avoids common mistakes, especially around memory. If your code isn’t safe, it simply won’t compile.
That said, Rust has its downsides. The rules that make it safe can also make it harder to learn, especially for beginners as the syntax is very verbose. The compiler is strict, and sometimes you’ll spend a lot of time just trying to satisfy it before your program will run.
To show why Rust’s focus on safety matters: Microsoft once reported that about 70% of all security issues they deal with are caused by memory safety bugs. These are the kinds of problems that C and C++ make easy to introduce but Rust is specifically designed to prevent.
Potentially Rust can be very interesting for enterprises, although at the moment there are not enough programmers who know it or can program in it compared to the battle hardened C# and Java.
1fn main() {
2 let mut message = String::from("Hello");
3
4 let borrow1 = &message; // immutable borrow
5 println!("Borrowed once: {}", borrow1);
6
7 let borrow2 = &message; // second immutable borrow is fine
8 println!("Borrowed twice: {}", borrow2);
9
10 // let borrow3 = &mut message; // ❌ ERROR: cannot borrow mutably while immutably borrowed
11
12 println!("Final message: {}", message);
13}
C#
C# was developed by Microsoft and is one of the main languages used with the .NET framework. You write your programs in C#, and then the .NET runtime takes care of running that code. Because of this setup, C# and .NET are almost always mentioned together, the language and the runtime work as a pair.
C#/.NET is a very strong choice for enterprise software, especially in environments where Microsoft technologies are already widely used. From business applications to web services and even game development (through Unity), C# has built a reputation for being versatile, powerful, and well-supported.
I have a bit of a love/hate relationship with C#. On the one hand, it makes it easy to build scalable applications thanks to its strong Object-Oriented Programming (OOP) model. With the new .NET MAUI framework, you can even target Windows, macOS, iOS, and Android all from a single codebase. That’s a huge advantage if you want to reach multiple platforms without rewriting your app.
On the other hand, the huge amount of features in C# and .NET combined can feel overwhelming, and it’s easy to get lost in the ecosystem. Personally, I’ve never written a line of C# outside of Microsoft’s Visual Studio. While it’s a powerful IDE, it’s not my editor of choice, and that sometimes makes working with C# feel a bit limiting.
1using System;
2
3class Greeter {
4 public string Name { get; set; }
5
6 public Greeter(string name) {
7 Name = name;
8 }
9
10 public void SayHello() {
11 Console.WriteLine($"Hello, {Name}!");
12 }
13}
14
15class Program {
16 static void Main() {
17 var greet = new Greeter("Job");
18 greet.SayHello();
19 }
20}
Go (Golang)
Another modern language is Go (or Golang), which has become especially popular in the world of cloud computing. Go was designed with simplicity in mind: it compiles directly to machine code, making programs fast and efficient, but it also includes a small runtime that handles things like memory management and concurrency.
One of Go’s strengths is that all the dependencies your program needs are compiled right into the final executable. That means when you ship a Go program, it’s just a single file that can run almost anywhere and there is no need to worry about external libraries or complicated setup. This makes Go incredibly flexible and easy to deploy, especially in containerized environments like Docker and Kubernetes.
I really enjoy working with Go. Its simplicity sometimes makes it feel almost like cheating. While it doesn’t come with as many built-in features as some other languages, Go makes it easy to build what you need yourself. That do-it-yourself approach not only keeps the language clean, but also gives you the chance to learn how different programming concepts actually work under the hood.
1package main
2import (
3 "fmt"
4 "strconv"
5)
6
7func main() {
8 num, err := strconv.Atoi("221b") // try to convert string to int
9 if err != nil {
10 fmt.Println("Conversion failed:", err)
11 } else {
12 fmt.Println("Number is", num)
13 }
14}
Conclusion
As you’ve just read, each programming language has its own strengths and works best for the purpose it was designed for. Of course, in real life we don’t always get to use the “perfect” tool, sometimes it’s simply because we don’t know it well enough yet or because we need to de maintain an existing program. But that’s okay. You can build desktop apps in Go, create mobile apps in Rust, or use Python to create a game.
In the end, especially in enterprise environments, what really matters is solving the problem not which language or tool you used to get there.
If you have any problems that need solving, feel free to contact me on hookprograms@outlook.com to get in touch about possible solutions.
Bonus
In the main part of this article, I focused on the programming languages I’ve worked with the most. But if you’d like to dive a little deeper, here are some short notes on other languages I’ve experimented with:
Assembly: Often called the lowest-level language still readable by humans (before you get to 1’s and 0’s). Assembly is specific to the CPU architecture you’re targeting. If you can read Assembly, you can understand and even reverse engineer any piece of software.
C++: Usually mentioned in the same breath as C. It started as C with classes but has since grown into a massive language with many advanced features. Thanks to its compatibility with C, it’s still used in many performance-critical systems.
HTML/CSS: I mention these together, even though they are different. HTML gives a web page its structure, while CSS makes it look good. Along with JavaScript (which handles the logic), these are the three fundamental technologies behind the modern web browser.
JavaScript: The language of the web. JavaScript is a dynamic scripting language and essential for adding interactivity to websites. For a long time it wasn’t considered a fit for large enterprise apps, but that perception changed with the rise of TypeScript.
TypeScript: Essentially JavaScript with types. By adding type annotations, many errors can be caught before runtime. Thanks to TypeScript, JavaScript development has become more structured, and the language has spread widely into backend and enterprise use. Although I’m not sure that is a good thing.
Lua: A lightweight, embedded scripting language that doesn’t get enough credit. Lua can be integrated into other applications, which makes it great for extending systems and speeding up development. It’s often used in games to let designers and modders (People making Modifications to games) add their own logic.
Visual Basic Script (VBS): Still widely used in enterprises, especially inside Microsoft Office for macros where its called Visual Basic For Applications (VBA). VBS can also be used to automate tasks on Windows and other apps through its COM objects. Be careful when using it at as there is a roadmap to phase out VBS on windows.
Java: Still hugely popular in enterprises, partly due to its object-oriented nature and massive ecosystem. Personally, I like the JavaFX library, which makes it possible to build nice-looking desktop apps for Windows, macOS, and Linux.
SQL: Some people debate whether SQL is really a “programming language,” but I believe everyone should know at least a little SQL. Even a simple database query is a valuable skill, not just for programmers but for anyone working with data.
GDScript (Godot): GDScript is the scripting language built specifically for the Godot game engine. It’s designed to feel familiar to Python users, which makes Godot easier to learn compared to engines like Unreal (C++) or Unity (C#).
Zig: A newer systems programming language often seen as a modern alternative to C. Zig gives you fine-grained control over memory without hidden behaviors. It’s still evolving, but if it matures into a stable 1.0 release, it could be worthy as a successor to C.