Autonomy as a Programmer

One of the things I think matters more to any programmer - and to any

other similar works - it's the crafting and making use of one's

autonomy. To have autonomy is a immense valuable tool, specially

considering that while programmers, one of our many facets is to act as

a detective. It's not rare to find ourself facing problems that demands

a investigation work, dealing with legacy projects, reading

documentation, crawling bug tickets, reading blogs, RFCs, papers, etc.

Now, most of this work is easily dealt with and almost automatically

when we have access to two important things: (1) documentation of the

project, all their proposal solutions and decisions, i.e. when the

project is built around public tools so you can reach out to a human

being and ask questions, read how and why something was did that way (2)

source-code of the project and it's surroundings.

This is one of the biggest wins that comes from the foundamental rules

of free software, as proposed by Richard Stallman: (1) right to use a

software freely (2) right to access the source-code and the right to

study it (3) right to share copies of the program (4) right to share a

modified version of the project. The access to the source code (the 2nd

right) allow us to easily comprehend what happens inside that program,

why it behaves like that and to understand if that behavior is erratic

or well known.

I've realized that has became an habit of mine, when dealing with some

weird situation or unexpected behavior of some library or some project,

to stop, clone the project in `~/sources` and to open the source-code

and search the origin of that behavior. Combine that with tools like

`git`, this search is even more simple and efficient, considering that I

can simple type `git grep` and search for keywords, throw a `git blame`

or `git log` on that file and find out the commit that introduced that

thing. Understanding _what_ was changed and _who_ made it.

It ends up, that most of the time I don't even need to lookup the

project's site, read their documentation or other sort of information.

All the data I need is there, right in front of me. The process of

building autonomy, as I see it, is to not depend strictly on

StackOverflow, or some project issues, or even the mailing list when I'm

placed under a different situtation. With a little knowledge and desire

to scratch one's own itch you'll start to build autonomy and it'll be

the most valuable tool under your toolbelt, moving you out of the

comfort zone and you'll even learn a little bit of the guts of the tools

you use daily.

--

The post "Autonomy as a Programmer" was published in January 10, 2021.

Back to the home page

The content of this site is under the terms of Creative Commons CC-BY-SA. The

code is available under GPL-3.0.