This is the second entry in the Best Practices Gone Bad series of posts. One principle that a lot of developers have been holding to lately is DRY. In The Pragmatic Programmer, Hunt and Thomas state the DRY principle as: Every piece of knowledge must have a single, unambiguous, authoritative representation within a system. This… Read More »
In the last post, we had begun streamlining novice Ned’s problem. Our current solution has some problems. The most annoying is the need to type a password for each server that we are going to write to. High-level Description We are using scp to do the copy, so the login is controlled by the SSH… Read More »
In the last post, we spent a small amount of time understanding a problem faced by our hypothetical novice programmer, Ned. As a reminder, let’s revisit Novice Ned’s breakdown of the problem. Launch FTP Connect to the host Log in with the foobar user and password Change to the appropriate remote directory Put each of… Read More »
In an earlier entry, I covered the first thing a programming novice needs to know: how to break down a problem. A short while later, I was talking with a guy at our local Perl user group and he presented me with an actual novice problem he was fighting. After some thought, I realized that… Read More »
As I said in the last entry, you can separate computer users by their user interface preferences. In that entry, I made the argument that a text-based interface (TUI) is better than a graphical interface (GUI). Since that isn’t inflammatory enough, I’m now going to argue that GUIs are better than TUIs. A Short History… Read More »
One of the ways that you can separate groups of computer users into groups is by their preferences in user interfaces. A few decades ago, most computer interfaces were simple text. The display hardware didn’t support fancy graphics, and the processors weren’t fast enough to do the calculations needed for reasonable graphics. As computers and… Read More »
While I was at YAPC::NA this year, I got a chance to catch up with a few old friends and talk with some really knowledgeable people from other parts of the Perl programming community. One such discussion started when Rob Kinyon told me that exceptions are fundamentally flawed by design and should never be used.… Read More »
The comments from Ian and rlb3 have made me think a bit more on what I said last time about Chronistic Coupling. One thing I didn’t make perfectly clear is that I’m not advocating avoiding Chronistic Coupling at all costs. Any real system will require some amount of Chronistic coupling. The key design point is… Read More »
Many programs have a need to store program state to disk at various points. An approach used by many of these programs is to serialize the objects representing the program state directly to disk (or a database). Back in 2004 (XML-Serialized Objects and Coupling), I described a coupling problem caused by automatically serializing objects to… Read More »
I was listening to an older episode of Software Engineering Radio where they interviewed Martin Odersky on Scala (Episode 62). In the interview, Odersky made a comment about closures being the literals of functional programming. This statement struck me as surprising. The more I thought about it, the more interesting and subtle the concept became.… Read More »