Lately I’ve found sat­is­fac­tion in fol­low­ing a min­i­mal­ist lifestyle. Having a lot of stuff isn’t all it’s cracked up to be and more often than not dis­tracts me from how I really want to spend my time. My desk has been described as “spar­tan” and led to more than one men­tion that a clean desk is a sign of insan­ity. (Is it really? That’s a dis­cus­sion for another day.)

The idea behind min­i­mal­ism is that you only keep what you need, and any time you con­sider adding to your col­lec­tion of things, ques­tion whether it’s actu­ally needed. Anything beyond what’s nec­es­sary is clut­ter; more­over, it’s a dis­trac­tion that requires energy to main­tain. This idea applies to per­sonal orga­ni­za­tion and con­sumerism, but also to development.

Python is a great lan­guage for aspir­ing min­i­mal­ists. The Zen of Python could eas­ily dou­ble as the zen of min­i­mal­ism given minor edits. “There should be one — and prefer­ably only one — obvi­ous way to do it” is min­i­mal­ist gold.

It’s easy for code to get messy. Our brains don’t think like com­put­ers (if yours does, you might be an autonomous robot), and ideas trans­lated into code often come out jum­bled. Add more than one brain and the jum­ble grows expo­nen­tially. But if we build in some time to revisit and ques­tion how we wrote some­thing, we can improve read­abil­ity, main­tain­abil­ity and often the per­for­mance of our code.

For exam­ple, dur­ing a recent refac­tor of my own hastily-written code, it took me mul­ti­ple glances — and scrib­bling down a truth table — to real­ize that this:

if len(list1) > 0 and len(list2) > 0:
    setting1 = True
    setting2 = True
else:
    if len(list1) > 0:
        setting1 = True
    else:
        setting1 = False
    if len(list2) > 0:
        setting2 = True
    else:
        setting2 = False

is log­i­cally equiv­a­lent to this:

setting1 = (len(list1) > 0)
setting2 = (len(list2) > 0)

I’m sure the first way made sense as I was writ­ing it; I was prob­a­bly adding con­di­tions one at a time as they were needed. But I should have gone back before com­mit­ting my changes and noticed some­thing like that.

During the same refac­tor, a more broad set of changes reduced six Django views down to two, elim­i­nat­ing redun­dant data­base calls, mak­ing it eas­ier to imple­ment a Django form and remov­ing almost all need to store data in ses­sion. Refactoring felt good, but it should have been done that way in the first place. Keeping a min­i­mal­ist men­tal­ity from the start would have made my refac­tor­ing unnecessary.

And so I’ve lately been slow­ing down as I code. I run through a men­tal check­list as I go and proof­read every changed line a few times before I com­mit it. It may take more time now, but I can save my team time later if the code is eas­ier to mod­ify and main­tain. I’m con­tin­u­ally ask­ing myself ques­tions like these:

• Is every vari­able in this func­tion nec­es­sary? Is any­thing redundant?
• Could a list com­pre­hen­sion replace this loop?
• Could an inline con­di­tional replace this if/else block?
• Does an exist­ing library or mod­ule already do this?
• Could I use or extend a util­ity func­tion to han­dle this?
• Can these sim­i­lar data­base calls be reduced into one trans­ac­tion with­out being confusing?
• Can some sim­ple func­tional pro­gram­ming reduce a few lines of code?

Tell me what you think. Can you apply any of these ques­tions to your code? Is there any­thing I’ve missed? I’d love to hear what’s work­ing for other min­i­mal­ists out there.