• Posts
  • RSS
  • ◂◂RSS
  • Contact

  • Programming: Repurposeability

    February 23rd, 2009
    programming, repurposeability  [html]
    How much needs to be changed when you find out the problem you thought you were solving differs substantially from the actual problem? Programmers complain about this all the time, generally when it's not their fault. A manager comes in telling you that some cost you thought was negligible isn't. A client finally sees a prototype and tells you you've conflated two similar but crucially distinct categories. It's easy to say "stupid non technical people -- can't they tell me what they really want from the start?", but its not always someone else's fault, and this fixes nothing.

    Given that we are always constructing models of problems and nearly always must begin before our understanding is total, times when we must repurpose our code are unavoidable. Then this presents a metric for evaluating a programming style or language: repurposeability. That is, when one writes code in this fashion and finds out that one was solving the wrong problem, how much work is needed to repurpose it to solve the problem one should have been solving all along?

    Repurposability is the driving force behind many aspects of good coding style. The avoidance of duplicate code, for example. Say you need to send some debugging output to a file instead of standard output. In java you might have a gui program with hundreds of calls to "System.out.writeln()" that really should be calls to some debug function. So this is a programming style issue. It is also a programming language issue, though. In common lisp one might deal with this problem with a statement equivalent to "in the code called from here, substitute this object for System.out". Similarly in java, you might have hundreds of reads and writes to the object attribute "Foo.bar". The standard arguments for java tell you to make them be to "Foo.setBar()" and "Foo.getBar()" instead, so if you later change your mind you don't have to change all those references to "Foo.bar". The advice is so to maximize repurposeability. But in python one would solve the same problem by using Foo.bar all along and taking advantage of the ability to wrap it in getters and seters later if needed.

    I need to think more about what is needed for repurposeability, but it certainly sounds like a useful metric.

    Comment via: facebook

    Recent posts on blogs I like:

    Governance in Rich Liberal American Cities

    Matt Yglesias has a blog post called Make Blue America Great Again, about governance in rich liberal states like New York and California. He talks about various good government issues, and he pays a lot of attention specifically to TransitMatters and our …

    via Pedestrian Observations November 19, 2020

    Collections: Why Military History?

    This week, I want to talk about the discipline of military history: what it is, why it is important and how I see my own place within it. This is going to be a bit of an unusual collections post as it is less about the past itself and more about how we st…

    via A Collection of Unmitigated Pedantry November 13, 2020

    Misalignment and misuse: whose values are manifest?

    Crossposted from world spirit sock puppet. AI related disasters are often categorized as involving misaligned AI, or misuse, or accident. Where: misuse means the bad outcomes were wanted by the people involved, misalignment means the bad outcomes were wan…

    via Meteuphoric November 13, 2020

    more     (via openring)


  • Posts
  • RSS
  • ◂◂RSS
  • Contact