Lately, I’ve been doing more thinking, reading, prototyping, and moving, than I’ve actually been writing code. One of the things that got me thinking enough to write this post was the classic syndrome of software developers and engineers to be gripped by the “Not invented here” syndrome.
Some would say that’s because engineers and developers like to create. That’s part of it too, but I think it’s also partially because we only get better if we write things ourselves. The only way to learn about something fully is to actually do it. The problem is, a lot of things that we would learn by doing, has already been done for a while now. Beyond linked lists and parsers, most anything you can think of has already been done. Not that we can necessarily do it better, but doing it is half the fun, and it’s the only way you can get better.
You won’t become a better programmer by passively studying other people’s code. Similarly, you don’t magically become a better writer by reading a lot of books. You become a better writer by.. wait for it.. writing. – Jeff Atwood
So it’s a balancing act between using other people’s code and reusing code to be more productive, and writing your own to learn and reduce dependencies.
Another aspect that compells people to write things themselves is that
I think it’s because code, like math, like poetry, is dense. There are meanings and implications that aren’t literal and aren’t at the surface. There are implications for what gets written at every line, and relies on a culture and context behind it to fully understand it. This is why it’s hard to read math equations, Alexander Pope(first one that came to mind), and much less code.
But that doesn’t mean that there can’t be language constructs to faciliate the ease of reading code. Python does it as a language choice that restricts whitespace. Maybe the computer doesn’t care about whitespace, but people surely do.
I have recently found that iterators with descriptive names actually help in reading code. Instead of a generic for or while loop, it kinda helps to have collect, and inject.
It would be nice if code was self-documenting, meaning that you would be able to tell what the code was doing from what the method names and variables were, rather than the comments around it. It would be nice if method signatures were all you needed to know what to put into a method (and no, static typing doesn’t help completely here). I wonder if language constructs could help out with it, or would we always need to rely on the stylistic tastes and discipline of the individual programmer to write readable code and documentation?
Wilhem has built Annologger, a tool that lets people worship your dentist appointments.