From Game Cheats to C Shell: Matheus’s Journey Into Programming
A CoderLegion Developer Story featuring Matheus
Interviewed and edited by Mehadi Hasan, Community & Editorial Team at CoderLegion
Matheus has been interested in computers since childhood. What started with playing games, experimenting with cheats, and carefully watching his father repair a computer eventually turned into a deep interest in programming, Unix, Linux, shell scripting, and low-level software.
Today, his interests span languages such as C, Objective-C, Smalltalk, Java, C#, JavaScript, Python, and Shell. More recently, he has been working directly on C shell, forking tcsh and experimenting with new features and changes to the shell's parsing and execution behavior.
His journey isn't really about following one technology.
It is about curiosity.
It Started With a Computer and Game Cheats
Matheus's interest in computers began before he was thinking seriously about programming.
One of his earliest memories involves playing games with cheats on a computer equipped with an Intel MMX processor.
Whenever something went wrong with the computer, he would ask his father to fix it. But he wasn't simply waiting for the computer to work again.
He watched closely.
"I used to pay close attention to the process, so I could reproduce myself."
That habit of watching how things worked would eventually become an important part of his approach to programming.
Instead of simply using technology, he wanted to understand how it worked and reproduce what he had seen.
Discovering Programming Through Game Servers
Matheus's programming journey properly began around 2013 or 2014.
At the time, he was hosting servers for games.
Those games included scripting languages that allowed players to write their own programs and modify the behavior of the game.
That was one of the first opportunities for Matheus to discover that software could be something he could actually change and build himself.
Around the same time, his interest in Linux and Unix began to develop.
The two interests gradually came together.
He started experimenting with shell scripting and quickly became fascinated by what could be accomplished from the command line.
"I played with shell scripting for a long time, until I met the C programming language, around 2021 and 2022."
His exploration of different technologies wasn't driven by a particular career plan.
It was driven mostly by curiosity.
"The reason I've explored many different technologies is mainly due to curiosity. I think my baggage is never enough, so I tend to learn every technology I can."
That curiosity has remained one of the defining characteristics of his programming journey.
Why Unix, Linux, and the Shell?
Matheus describes himself as a Unix and Linux enthusiast, but the part of the ecosystem that attracted him most was the shell.
For him, the shell isn't simply a way to launch programs.
It's a powerful programming environment.
"I think what mostly attracted and kept me interested in Linux and Unix is the shell."
Through shell scripting, he learned many different techniques and ways of solving problems.
The simplicity of the environment also gave him room to experiment.
"I like to think the shell is a great tool."
That interest eventually led him much deeper into understanding how shells work and, eventually, into modifying one himself.
From Shell Scripting to C
Shell scripting became an important part of how Matheus learned and practiced programming.
But learning C introduced a different way of thinking.
One of the interesting differences for him was the presence of pointers in C.
Coming from shell scripting, pointers were initially somewhat counter-intuitive.
Shell scripting doesn't have pointers in the same way C does.
But Matheus eventually came to appreciate how powerful they can be.
In fact, his curiosity went far enough that he began thinking about whether pointers could even be implemented on top of a shell.
That kind of experimentation reflects a broader pattern throughout his journey: rather than simply accepting how a technology works, he likes to ask what else might be possible.
Rethinking the C Shell
Today, Matheus is experimenting directly with C shell.
He is working on a fork of tcsh, exploring fixes and new features while rethinking parts of the shell's behavior.
One of his current projects focuses on one-line control structure parsing.
The goal is to make certain control structures work on a single line in a way similar to Bourne-style shells.
For example, C shell traditionally parses an entire command line before taking further action, which creates limitations around using semicolons and line feeds interchangeably. Matheus's implementation attempts to address that behavior. :contentReference[oaicite:1]{index=1}
He has also worked on other changes to the shell, including function declarations, variable assignment from pipes and redirections, comments in interactive sessions, and other fixes and features. :contentReference[oaicite:2]{index=2}
For Matheus, this isn't simply about using an existing shell.
He wants to understand its internals well enough to change them.
The Challenge of Parsing a Control Structure
One of the most challenging parts of his current work has been implementing one-line control structure parsing.
His first approach was to implement the mechanism through built-ins.
But he quickly realized that this would be dangerous and ineffective.
So he changed his approach.
Instead of handling the feature through built-ins, he moved the implementation into the post-parsing execution stage, where the command line could be reparsed and executed.
The implementation involves recursively analyzing the structure of commands and determining the opening and enclosing blocks of control structures.
Matheus describes the process as a set of recursive functions that analyze the parsed structure.
His recent CoderLegion article describes the implementation in more detail, including the use of new parsing and execution modes and a circular linked list for relevant command nodes. :contentReference[oaicite:3]{index=3}
It's a good example of how his curiosity has evolved.
What started with using software has become an interest in understanding and modifying the machinery underneath it.
Testing: You Can't Always Test Your Own Software
For Matheus, testing is an essential part of software development.
But he has also learned an important limitation:
The person who writes the software may not be the best person to test it.
"A developer by themselves may not be able to play the role of a tester."
A developer knows what they intended to build.
That can make it difficult to see all the unexpected ways another person might use it.
Matheus doesn't consider himself a tester.
He considers himself a developer whose goal is to produce a program.
Of course, he tests everything he develops himself.
But he doesn't assume that his own tests are enough.
Instead, he often asks other people to test his software because they can approach it from a different perspective.
"I'm unaware of the many possibilities of use."
That lesson is especially relevant to the kind of software he is currently building.
When you change something as fundamental as a shell, there can be many behaviors and edge cases that the original developer simply didn't anticipate.
Programming Isn't as Hard as It Looks
After spending years learning different technologies, Matheus has arrived at a surprisingly simple conclusion:
"Programming isn't as hard as thought."
Even subjects that initially appear intimidating can become manageable once you spend enough time with them.
That doesn't mean programming requires no effort.
For Matheus, the difficult part isn't necessarily that programming is impossibly complicated.
It's that understanding something requires time, experimentation, and persistence.
The intimidating subject becomes less intimidating once you start working with it.
The Hardest Part: Deciding How to Solve a Problem
One of Matheus's biggest challenges isn't learning a programming language.
It's deciding how to solve a problem.
"To solve a problem. This has always been challenging for me."
When planning an implementation, he isn't always sure that the solution he's considering is the best one.
There may be another approach that he hasn't thought of yet.
That uncertainty can make it difficult to begin.
Over time, however, he has developed a practical way of dealing with it.
If he has a reasonable solution, he believes it is often better to implement it rather than remain stuck trying to find the perfect approach.
"If you have a solution, put in practice, even if this isn't the best."
And if a better solution becomes apparent later, the software can be reimplemented.
For Matheus, moving forward can be more valuable than remaining paralyzed by uncertainty.
Learning From Other Developers
One of the things Matheus enjoys most about software development is the opportunity to learn from other people.
Building software alongside other developers exposes you to different approaches and different ways of thinking.
"They might have better solutions, and you can aggregate their knowledge."
Even though he doesn't currently work as part of a team, he still enjoys sharing software and ideas with other developers.
For him, open source and developer communities aren't just places to show what you've built.
They're places where knowledge can move in both directions.
You contribute something.
Someone else contributes an idea.
And your understanding becomes a little larger than it was before.
Matheus joined CoderLegion in January 2026 and has since shared articles and projects around programming, shell development, testing, Pascal, C, and open source. His recent posts include work on C shell and one-line control structure parsing. :contentReference[oaicite:4]{index=4}
His experience so far has been relatively quiet in terms of comments and engagement.
But that hasn't changed what he wants from the community.
"I'm not only seeking for engagement, but also for contributions."
For Matheus, the value of a developer community isn't simply the number of reactions a post receives.
He wants to expand his network, exchange knowledge, and contribute to other developers.
That's also why feedback matters to him.
A developer can build something alone, but other people can see possibilities, problems, and solutions that the original developer may have missed.
The Advice He Would Give to New Developers
For someone just beginning their programming journey, Matheus's advice is straightforward:
Don't give up.
"My best advice is to never look down and give up."
Programming is a journey, and according to Matheus, it requires dedication and discipline.
There will be moments when a problem seems impossible.
There will be technologies that look intimidating.
There will be times when you aren't sure how to implement something.
His advice is to keep moving.
And when you're stuck, don't be afraid to look for help.
One resource he particularly recommends is books.
"In my experience, I found books to be excellent guides when stuck."
For Matheus, learning isn't about reaching a point where there is nothing left to discover.
His own journey demonstrates almost the opposite.
From game scripting to shell scripting, from Unix and Linux to C, from programming languages to open-source shell development, curiosity keeps pushing him toward the next thing he wants to understand.
Curiosity Is the Common Thread
Looking at Matheus's journey, there isn't one programming language or framework that defines it.
The common thread is curiosity.
It started with watching his father repair a computer.
Then came game servers and scripting.
Then Linux and Unix.
Then shell scripting.
Then C.
And now, instead of simply using a shell, Matheus is working on the shell itself.
His journey shows that learning doesn't always follow a straight path.
Sometimes the best reason to learn a technology is simply because you want to understand it.
And sometimes that curiosity eventually leads you much deeper than you expected.
About Matheus
Matheus is a passionate computer programmer based in Brazil.
His programming interests include C, Objective-C, Smalltalk, Java, C#, JavaScript, Python, and Shell. He has a strong interest in Unix and Linux and is particularly interested in shell scripting and developer tools.
On CoderLegion, Matheus has shared work around C shell, testing, Pascal, C programming, and open source. His current work includes experimenting with and extending tcsh, including one-line control structure parsing and other shell improvements.
You can follow his work on his CoderLegion profile and his GitHub.
About This Developer Story
Developer: Matheus
Series: CoderLegion Developer Stories
Interview format: Q&A
Interviewed and edited by: Mehadi Hasan, Community & Editorial Team at CoderLegion
This story was created from Matheus's own answers and experiences shared during the CoderLegion Developer Stories Q&A.
