Has somebody ever told you to start learning programming through languages like Python and JavaScript? "They're easier to learn," they said. "Great for beginners," was a common saying.
Now, I'm not saying that one shouldn't ever need to learn such high-level interpreted language. They can be great for small projects with few requirements as well as for larger projects.
But the issue isn't with what they can achieve, but rather with their limitations, the details they hide away, and what you can't do with them.
Here's an illustration...
Pointers: A Dialogue
Low-level Coder (LLC): Hey, High-level Coder, quick question. Do you know what pointers are?
High-level Coder (PC): Oh, pointers? Yeah, those are like the little sticky notes you put on your screen to remember where your code is, right?
LLC: Haha, not quite! Pointers are more like addresses that tell you exactly where data is stored in your computer's memory.
HLC: Oh, of course! So, pointers are like GPS coordinates, and the computer RAM is like planet Earth?
LLC: Nearly there! They're more like signposts that help you access and manipulate data directly.
HLC: Got it! Pointers are like little signposts pointing the way to your data treasure!
LLC: Oh, umm... that's certainly one way to put it. Pointers do guide you to your data's location in memory.
[2 months later]
LLC: Hey again, High-level Coder.
HLC: (Banging head against keyboard) Oh, hello again. Sorry, just wrestling with this bug.
LLC: Need a hand? Perhaps a pointer to the right path?
HLC: Yep. Pointers, right? More like pointers to burnout. I've spent all week throwing punches at this little guy.
LLC: I understand. But hey, remember when you were just starting, and the analogies we shared. Look how much progress you've made!
HLC: Hey, thanks! Perhaps one day I'll be just as confident as you are.
LLC: For sure. And who knows, maybe we'll both start calling them "memory GPS".
Pointers, static typing and memory management: programming fundamentals that can be harder to grasp later on. Imagine building a house by placing the roof first. Imagine trying to deliver a TED talk without having any knowledge of your chosen subject. Imagine building a Next.js app without having ever touched plain HTML and CSS.
I first made this reflection when I took the CS50x course (an intro to CS and programming), where they taught C. I thought, "Python is pretty much my second language after English. I can do this." So why did it feel so alien?
About a year later, now in C++, the low-level world still felt like... another world. I couldn't say, "Oh, yeah, it's like Python in this way," or, "Of course, but JavaScript does it like this." Instead, I found myself traversing through alien territory in search of clarity.
Sure, the novelty of such "alien communication" filled me with pluck and thrill, but at what cost? It still took much longer to plant my feet in the space rock of foundational concepts. My high-level high-life had turned into a time-consuming headache.
So yes, now I wish I had started first with C, and then Python, Javascript, etc. Hey, even C++ right after C. Forget the smooth-sailing spacewalk: I should have immersed myself in the challenge right from the outset.
Fast forward a while and I decided to try again. But this time, I went with Rust. Owning the title of most admired programming language, Rust is a relatively new language that trumps C/C++ in memory safety and ease of use.
Some may prefer learning C/C++ due to the greater age and community, but Rust makes up for it with a wealth of quality official learning resources.
For example, the Rust "Book" aims to build your knowledge of the language, and stands as the most comprehensive resource for learning Rust out there.
But I wanted to learn quicker than reading a book. Project-based learning (i.e. applying information) is much more effective than remembering syntax. So I knew I wanted to be there as soon as possible.
But, instead of reaching for another Sololearn-style course, I found Rust By Example to be helpful for "absorbing" the language. There was also the Rustlings course - small exercises to help you get used to working with the language.
So, I learnt through Rustlings and Rust By Example for some time and felt I was ready to take on a project.
My first Rust project became this Asteroids clone, using the Bevy Engine.
Getting a small taste of game development through this was a great experience as it had been quite a while since I last made a game.
But if you're wondering where to begin when building a Rust project that uses a certain framework/library, I found it helpful to look through example code. The Bevy Git repository, for one, includes demonstrations of certain features, as well as entire games built with the engine. Fundamentals, conventions, and best practices: all acquired through example code.
The game development experience in Rust with Bevy was phenomenal, and the more Rust code I experienced the greater my appreciation for the language grew. Rust: Safe and simple.
Not long after, I returned to Rust. Introducing markmedium, a command-line utility that publishes a markdown file using the Medium API. Any configuration for the article is parsed from the file's frontmatter. Since it requires the user's integration token, it stores the token in a local file to reuse later.
This project introduced me to the serde library, used for serialisation/deserialisation in Rust. I also learned how to access the filesystem and send HTTP requests.
But, looking back at the source code, I found that I could have done the same job with much fewer lines of Python code. Rust made it feel much more complicated than it was.
This made me re-evaluate what exactly I wanted out of learning Rust. Sure, learning a low-level language has the potential to make me a more well-rounded software engineer programmer person. Although, as said earlier, dynamically typed high-level interpreted languages still have their advantages.
Now I've learned that Rust can be used for a wide range of projects. But I've also realised that it doesn't mean that it should, nor that it has to be. Sometimes some jobs aren't worth the compiler's time.
After the markmedium script, my Rust usage had been dormant. My realisation of what it meant to choose a performant-focused low-level language closed the door on my enthusiasm.
So yes, I went back to coding out little scripts in Python or TypeScript instead of Rust. But using Rust ignited a small flame within me for compiled languages.
So, I started looking into Go (Golang), treasured as a "fast, statically typed, compiled language that feels like a dynamically typed, interpreted language."
Go(lang) is exactly what I needed.
For one, the learning curve with Go is shallower than for Rust. Also, it indeed feels as if I'm writing Python, but with the advantage of greater performance and the enforcement of a single code style.
And with more time and effort, I did start to feel like a person who knows compiled languages. So, if you're beginning your programming journey. If you've worked with interpreters for a while and are looking for something new. If you're looking to expand your skill set. Immerse yourself in the challenge. Learn a compiled language!
Had I abandoned Rust? Well, at the moment, I am working on an article that will serve as an introduction to Rust for those who come from an interpreted language background.
In the future, I plan to create a Minecraft-like voxel game with Bevy.
And that's all. If you have any opinions on the topics discussed today or want to share your own experiences with learning new languages, feel free to leave a comment below.