Off-topic introduction
I would like to start by welcoming you. This is the first post on our personal blog. Even if it is a bit off-topic, I would like to mention that our blog will be somewhat more personal and free-form. That is exactly why Silver and I will each have our own blog. We are not very fond of social media in the way it is traditionally used, so do not expect frequent posts.
What I can tell you on my part is that I will probably prefer posting on this blog over my personal social media, so this will probably be the place where you can learn the most about me, mainly how I think and what I spend my time on. My plan is not to use language models (better known as generative text AIs) to write the blog posts, and if I ever do, I will say so explicitly. The reason for avoiding artificial intelligence when writing the posts is simply to keep the main goal, which is to have a more genuine and personal space.
What is this section of the blog about?
First of all, for those who do not know, I am formally a computer scientist; that is what I studied at university. Like anyone, I do not know everything, and in fact I consider myself an apprentice (and will probably keep considering myself one for a long time), so I created this section to document my learning in the field of programming.
I would like to state up front the focus of the learning I will document. My main knowledge is in Java, object-oriented programming and C#. With this knowledge, you could say my current skills are geared towards desktop applications and tools and web backend. Even so, this is not the focus I would like to have as a programmer. What I would like to focus on is mainly low-level programming and applications that are not business-oriented.
I have three main personal reasons:
1. Since my main focus as a computer scientist today is operating system security, understanding how
the tools, processes, standards and structures that operating systems are built on work
makes it imperative for me to understand how vulnerabilities work at the code level.
2. Most of the tools whose code I would like to study are written in low- and mid-level languages such as
C, C++ or Rust.
3. The standards I would like to apply to my code are found mainly in low-level
languages.
The standards I would like to apply when focusing on low-level programming are the following:
1. Open and auditable code.
2. Readable and well-documented code.
3. Secure code that handles failures correctly.
4. Minimalist code, not bloated, with a reduced attack surface.
5. Efficient and portable code that can be used on whatever system the user prefers.
If I had to sum it up bluntly, I would say I am interested in creating software not by paying attention, industrially, only to the visible end result, but by making the code as well done as possible. The idea is to show how I go through this learning without using artificial intelligence, learning the old-school way.
Problems with learning to program in the post-AI era
Over the years, the internet has been filling up more and more with LLM-generated information. This does not mean that the only information we can assume to be 100% truthful is what was written before ChatGPT was released; that claim would be very reductionist. The most reasonable thing is to understand that before LLMs started being used massively, false information already existed, and today there is still true information created with reliable methods and foundations.
Many people who want to make their time as efficient as possible use LLMs as a shortcut to do more in less time. In the short term this gives surprising results, and as everyone will remember, at first it seemed like magic or sorcery. The problem comes when the ultimate goal is personal growth. Obviously, if the goal is to learn something seriously, LLMs can still be quite useful at the beginning, which at first makes it seem that LLMs are capable of teaching us entire fields and not just working directly in them. I said "at first" because the problem with using these tools comes to light the deeper we go into a craft.
The simplest way to illustrate this as clearly as possible is with an example from the very topic this blog covers. If we have a specific goal or task that requires programming, and the ultimate goal is to finish the tool as quickly as possible, then we can use LLMs to "get rid of" the problem immediately. Likewise, we could also learn the target field with LLMs as support. The problem comes when we see that LLMs commit what is famously known as "hallucinations", where the tool makes up information with no basis to support it and is even capable of sophistry and manipulation to defend its claims.
In these cases, "unfortunately", the most realistic way to learn is the conservative way. Studying computer science the conservative way would mean, in short, sitting down to read a book, the man pages, or directly reading our own code or other people's code, and becoming ourselves the "tool" capable of programming.
Throughout this blog, I will show and document my process of learning to program according to the standards set as goals above, without setting a date or a deadline.
Why am I doing this?
It would be a lie to say I am doing this for others' benefit; mainly I am doing it as an interesting methodology to make learning more dynamic. Even so, I think that depending on how this project develops in the future, it may be useful to anyone trying to learn programming in a world where the right answer almost always seems to be relying on LLMs to shorten the process as much as possible.
We live in a time when we can all choose to learn. Anyone who decides to make the most of the tools we have to learn is welcome. I would also like to welcome and congratulate everyone who is able to read more than 5 sentences in 2026.
Note: There may be writing mistakes, whether spelling or structural. That is completely fine; I am not trying to pass myself off as a sage or an intellectual reference. This will be a process meant to be more personal.