💾 Archived View for gemini.eletrotupi.com › ~porcellis › autonomy-as-a-programmer.en.gmi captured on 2022-06-04 at 00:13:12. Gemini links have been rewritten to link to archived content
-=-=-=-=-=-=-
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.
The content of this site is under the terms of Creative Commons CC-BY-SA. The
code is available under GPL-3.0.