;; -*- mode:lisp;coding:utf-8 -*-
(("writing"

  ("writing code"

   ((:a1 "Basic")

    "I can produce a correct implementation for a simple function,
     given a well-defined specification of desired behavior and
     interface, without help from others.")

   ((:a2 "Basic")

    "I can determine a suitable itnerface and produce a correct
     implementation, given a loose specification for a simple
     function, without help from others. I can break down a complex
     function specification in smaller functions.")

   ((:b1 "Intermediate")

    "I can estimate the sapce and time costs of my code during
     execution.  I can empiricallyh compare different implementations
     of the same function specifrication using well-defined metrics,
     including execution time and memory footprint.  I express
     invariants in my code.  I use stubs to gain flexibility on
     implementation order.")

   ((:b2 "Intermediate")

    "I use typing and interfaces deliberately and productively to
     structure and plan ahead my coding activity.  I can design and
     implement entire programs myself given well-defined
     specifications on external input and output.  I systematically
     attempt to generalize functions to increase their reusability.")

   ((:c1 "Proficent")

    "I can systematically recognize inconsistent or conflicting
     requirements in specifications. I can break down a complex
     program architecture in smaller components that can be
     implemented separately, including by other people.  I can use
     existing (E)DSL or metaprogramming patterns to increase my
     productivity.")

   ((:c2 "Proficient")

    "I can reliably recognize when under-specification is intentional
     or not.  I can exploit under-specification to increase my
     productivity in non-trivial ways.   I can devise new (E)DSLs or
     create new metaprogramming patterns to increase my productivity
     and that of other programmers."))

  ("refactoring"

   ((:a1 "Basic")

    "I can adapt my code when I receive small changes in its
     specification without rewriting it entirely, provided I know the
     change is incremental.  I can change my own code given detailed
     instructions from a more experienced programmer.")

   ((:a2 "Basic")

    "I can determine myself whether a small change in specification is
     incremental or requires a large refactoring.  I can change my own
     code given loose instructions from a more experienced
     programer.")

   ((:b1 "Intermediate")

    "I can derive a refactoring strategy on my own code, given
     relatively small changes in specification.  I can change other
     people's code given precise instructions from a person already
     familiar with the code.")

   ((:b2 "Intermediate")

    "I can estimate accurately the effort needed to adapt my own code
     base to a new specification.  I can follow an existing
     refactoring strategy on someone else's code.  I can take full
     responsibility for the itnegration of someone else's patch onto
     my own code.")

   ((:c1 "Proficent")

    "I can reverse-engineer someone else's code base with help from
     the original specification, and estimate accurately the effort
     needed to adapt it to a new specification.")

   ((:c2 "Proficient")

    "I can reverse-engineer someone else's code base without original
     specification, and estimate accurately the effort needed to adapt
     it to a new specification."))

  ("embedding in a larger system"
   ((:a1 "Basic")

    "")

   ((:a2 "Basic")

    "")

   ((:b1 "Intermediate")

    "")

   ((:b2 "Intermediate")

    "")

   ((:c1 "Proficent")

    "")

   ((:c2 "Proficient")

    "")))

 ("understanding"

  ("reusing code"

   ((:a1 "Basic")

    "")

   ((:a2 "Basic")

    "")

   ((:b1 "Intermediate")

    "")

   ((:b2 "Intermediate")

    "")

   ((:c1 "Proficent")

    "")

   ((:c2 "Proficient")

    ""))

  ("explaining/discussing code"

   ((:a1 "Basic")

    "")

   ((:a2 "Basic")

    "")

   ((:b1 "Intermediate")

    "")

   ((:b2 "Intermediate")

    "")

   ((:c1 "Proficent")

    "")

   ((:c2 "Proficient")

    "")))

 ("interfacing"

  ("exploring, self-learning"

   ((:a1 "Basic")

    "")

   ((:a2 "Basic")

    "")

   ((:b1 "Intermediate")

    "")

   ((:b2 "Intermediate")

    "")

   ((:c1 "Proficent")

    "")

   ((:c2 "Proficient")

    ""))

  ("mastery of the environment"

   ((:a1 "Basic")

    "")

   ((:a2 "Basic")

    "")

   ((:b1 "Intermediate")

    "")

   ((:b2 "Intermediate")

    "")

   ((:c1 "Proficent")

    "")

   ((:c2 "Proficient")

    ""))

  ("troubleshooting"

   ((:a1 "Basic")

    "")

   ((:a2 "Basic")

    "")

   ((:b1 "Intermediate")

    "")

   ((:b2 "Intermediate")

    "")

   ((:c1 "Proficent")

    "")

   ((:c2 "Proficient")

    ""))))
ViewGit