Search for a command to run...
Software engineer based in Singapore
Welcome to my website, where I write mostly on tech-related content to share the things I learned from people and from building projects using different tools.
My interests are in tech, traditional finance, cryptocurrency.
No comments yet. Be the first to comment.
In this series, I explore systems programming with rust.
A follow-up to this article can be found here CodeCrafters is an amazing community built by Paul Kuruvilla that contains project challenges for real-world software systems that are used widely(redis, git, docker, SQLite). Each project comes in the fo...
Dig into the NextJS bundle
Bridging AMD64 and ARM64
Dig into JS bundle to find useful stuff
Tradingview script alert + webhook -> API server -> Telegram
From an almost fully automated pipeline to a fully automated pipeline
I have spent the past few weeks learning Rust through the official book: The rust programming language, and enjoyed the experience. It is written by Steve Klabnik, one of the former contributors of Rust.
I started learning Rust in 2019, left it, and only came back to it recently.
I have been doing high-level web development for 3 years, and I wanted to work with technology at a lower level.
Besides being the most-loved language for consecutive years, Rust is designed to match the performance of C++, while providing memory safety, which is a safeguard for programmers against making such mistakes.
Interestingly, it is able to do so without the use of a garbage collector, through a concept known as ownership, and this is one of the unique selling points of Rust.
As mentioned, the book is well written and covers everything you need to get started with Rust - data types, control structures, error handling, tests, packaging, concurrency, mini-projects.
Here are some of my favourite chapters:
The concept of ownership is new and is Rust's unique selling point. The idea is that any heap-allocated data can only have 1 owner, so that freeing up the memory is straightforward.
This new way of approaching memory deallocation is new and takes time to get used to.
Pattern matching using the match keyword enforce exhaustibility, i.e. Rust makes sure we handle every possible pattern, otherwise the program won't compile.
Together with pre-defined enums such as Option, working with complex conditionals and variables that may or may not contain a value becomes a simple task.
Building on enums and pattern matching, handling recoverable errors is a joy with the Result enum, which contains the Ok variant if an operation succeeds, and the Err variant if it fails.
For uncoverable errors, simply use the panic! macro.
Smart pointers are pointers that behave like references, but with additional capabilities such as dereferencing coercion, cleaning up resources after they are no longer needed.
Using a smart pointer such as Rc allows a value to have multiple owners, and they are tracked and deallocated accordingly.
Concurrent programming is important to any large-scale, high-load systems.
The concept of channels(similar to golang) allows threads to pass messages between one another, and mutex to allow threads access to shared resources.
12. An I/O project: Building a command line program and 20. Final project: building a multithreaded web server
These 2 chapters walk through the process of building simple projects using the concepts learned so far and apply them in the context of proper software engineering practices such as SOLID, DRY.
I enjoyed the process of learning Rust. Thinking about how I handle data has made me a better programmer. It also made programming fun again.
I may not use Rust for work anytime soon, but this new way of thinking about ownership has made me more aware of what happens behind the scenes.