The best 10 programming articles of the last 10 years

These are articles that I've kept around and reread over the years. I love me a readable deep dive, and this list if full of them,

Why Google Source has high uptime

Google Source has tremendous uptime. They manage it by having a super-flexible schema, and code that takes advantage of it.

Things I was definitely wrong about

Here's the inevitable followup to my last post about things I was right about. This is a list of things that I was convinced about when I was younger, but I now I realize I was quite wrong.

Things I was always right about

Some bloggers have strong opinions and are just right all the damn time. Like Joel Spolskey, and Jason Fried. I admire them, but I've never been that guy, or been that confident in my opinions. But damnit, some of my oldest opinions hold up. After nearly two decades of professional programming, I've looked back and thought about the opinions I originally had. Here are the ones that I'm convinced I was always right about.

Can we measure how much more complicated computing is?

25 years ago, a simple question was asked about storage, access times, and economics, and the result was a simple paper. Every ten-ish years since then, an updated paper was written to answer the same question. It's not a terribly good measure of complexity, but it is enlightening.

Soft Skills for Software Architects, a video series by Mark Richards

Mark Richards runs the Developer to Architect website, and puts out a video every Monday. He has helpfully categorized them. I watched all the videos in the "Soft Skills" category and took notes.

Learning about Faults, Errors, and Failures.

I've been reading about failures in distributed computing. A lot of it is thanks to Vaidehi Joshii's Year of Distributed Computing at https://medium.com/@vaidehijoshi . Here's small summary of what I've learned.

Why trying to make accidents rarer can actually make them more common

excerpt from How Complex Systems Fail

Notes on Site Reliability Engineering, by Google

For my own reference, here are notes I took while reading Google's book on SRE.

Using Moose's "before" method modifier to modify parameters

A small trick to make "before" a bit more powerful, a bit more useful, and a bit more dangerous.

One-liner to analyze Python programs

The great benefit of knowing the command-line is being able to write scripts to analyze scripts, all in ~1 minute.

Catches for traditional programmers when learning Python

After a lifetime of programming and compsci education, I've had some issues learning with Python. It screws me up in small ways. It's a wonderful language, but dear god I wish these things were different.

It's easy to dismiss the GoF Design Patterns

The problem of learning Object Oriented Design

The greatest problem in learning object oriented design is in the toy problems. The object oriented solution never looks better than the regular solution.

How to write a program, the wrong way

Learn the right way to write a program the wrong way

It shouldn't be surprising to anyone that...