Hi Dev.to!
Today marks a significant milestone in my software development journey. For a long time, I worked in the high-level web development ecosystem using Python and Django. It was a great and interesting start, but I realized I’m more drawn to deeper systems—understanding how things work under the hood.
I want to understand how networks handle bytes, how operating systems manage processes, and how to write software that is fast and resource-efficient. That’s why I’ve decided to switch entirely to systems programming, networking technologies, and Linux internals.
My primary languages will be Go and Rust. I’ve moved away from my old setup and configured a clean environment on Windows 10:
- Windows 10 + WSL 2 (Debian) for a full Linux experience right in the terminal.
- VS Code with WSL integration.
- Docker for future infrastructure scaling.
As a quick sanity check, I just compiled and ran my first "Hello, World!" in Go inside WSL.
It’s a start!
I’m a first-year Software Engineering student, but my learning won't be limited to the university curriculum.
Over the coming year, I aim to: - Master low-level fundamentals like memory management, pointers, and asynchronous I/O primitives.
- Build several MVPs—ranging from simple, straightforward tools to serious, useful applications.
- Eventually, I want to move into developing security agents for the Linux kernel using Rust by my third year. I plan to document my entire journey here on Dev.to, sharing my wins, ideas, and mistakes. I’d really appreciate your support, advice, and any constructive criticism. Here is my GitHub, where I’ll be posting my code and projects: https://github.com/arkpil60. There isn't much there yet, but that’s just for now. Are there any tips or common "pitfalls" worth knowing about? I’d be interested to read about them.
Top comments (1)
The pitfall nobody warns you about: the syntax of Go or Rust takes a week, but what actually breaks is the design habits your old language made implicit. In Go the trap is writing Python with braces — pointer-heavy structs and interfaces invented before any implementation exists. In Rust it's giving up and reaching for Rc> everywhere because the borrow checker feels like an adversary.
What worked for me was the boring path: take a small tool you already maintain in Python, rewrite it, then run them side by side and profile the difference. You learn more from one garbage-collector-versus-ownership memory profile than from any book. Which of the two are you starting with, and did you pick it for the language or for the kind of problem it lets you work on?