Bugs are great learning opportunities. So how do we make sure we learn as much as possible from the bugs we fix? A method I have used for more than 13 years now is to write down a short description of the bug, the fix, and the lessons I learned.
Way back in 2002, I came across a blog post (that I unfortunately can’t find again) that described this method. I have used it ever since, and I believe it has helped me become a better software developer.
Every time I fix a particularly tricky or interesting bug, I take a few minutes to write down some facts about it. Here is an example of a typical entry: Continue reading
When I graduated from university with a degree in Computer Science, I wanted to continue and get a Ph.D. But I also wanted to work as a software developer, so I worked for five years in industry before going back to do a Ph.D. I spent one year as a Ph.D. student before deciding that I liked professional software development better. Even though this was many years ago, I think some of the lessons I learnt still apply. Continue reading
I just finished taking the course Software Security from the University of Maryland via Coursera. It was a relatively easy course (at least if you know C) that gave an overview of the following areas: buffer overflows and other memory attacks, web security (including SQL injection, CSRF and XSS), secure design, static analysis, symbolic execution, fuzzing and penetration testing. The instructor, professor Michael Hicks, was one of the more pedagogical lecturers I have listened to, and the whole course was quite enjoyable. Continue reading
Here is my list of heuristics and rules of thumb for software development that I have found useful over the years:
1. Start small, then extend. Whether creating a new system, or adding a feature to an existing system, I always start by making a very simple version with almost none of the required functionality. Then I extend the solution step by step, until it does what it is supposed to. I have never been able to plan everything out in detail from the beginning. Instead, I learn as I go along, and this newly discovered information gets used in the solution.
I like this quote from John Gall: “A complex system that works is invariably found to have evolved from a simple system that worked.”
I recently finished the Coursera course Computational Investing Part 1 by professor Tucker Balch at Georgia Tech. The focus of the course is on portfolio analysis and selection. Almost all the analysis uses the daily closing prices of stocks as the starting point. The concepts are not particularly difficult, and the programming exercises give you good hands-on experience with the different analysis techniques. The assignments are in Python using several tool kits for time series analysis (NumPy, Pandas and the QuantSoftware ToolKit). Continue reading
What is the half-life of programmer knowledge? It is quite common with claims that the half-life is something like 5 years. In other words, half of what you know about programming will be obsolete in 5 years. A similar sentiment is: “Programming sucks, because what you knew a few years ago is useless now”.
At first, this seems plausible. After all, there is a steady stream of new programming languages and technologies coming out. However, I think it is wrong. Programming knowledge is much more long-lived than some people realize. Continue reading