Spartan programming gathers many techniques discussed in the literature, adding some of its own, into a unique coding style whose main objective is minimal use of various elements of the programming language which may contribute to complexity. This programming style relies on strict self-discipline, avoiding some of the opportunities offered by the underlying language, geared at achieving the programming equivalent of laconic speech.
Spartan programming is not directly concerned with readability, at least not in its subjective and cultural-dependent sense. In fact, spartan programs will bring much misery to anyone preferring long, verbose programs.
In certain ways, spartan programming is a coding style, just like the Linux kernel style guide. But, spartan programming is more than just a technical coding style, in that is has a single underlying, unifying principle---minimalism and simplicity taken to extremes.
The coding guidelines began with a dozen or so printed pages, "a little book of style", which the author handed out to computer science students in the Hebrew university of Jerusalem. The term "Spartan Programming" was coined in 1996, when the author gave a tutorial on "Spartan C++" at the TOOLS (Techniques of Object Oriented Languages and Systems) scientific conference, held in Santa Barbara, CA USA. The guidelines were taught under this name in numerous Technion courses since then.
Spartan programming strives for simultaneous minimization of all of the following measures of code complexity:
- Horizontal complexity, that is, the depth of nesting of control structures, just as the total line length.
- Vertical complexity, that is, module length in lines.
- Token count
- Character count
- Parameters, that is the number of parameters to a routine or a generic structure.
- loops, that is the number of iterative instructions and their nesting level.
- conditionals, that is the number of < code java inline> if</code> and multiple branch < code java inline> switch</code> statements.
The latter two are related to, but not the same as cycolomatic complexity
On the one hand, the Babylonian tower principle states that there is a limit to the number of abstraction levels that a software system may have. On the other hand, the seven plus minus one or two principle sets a limit on the number of subcomponents that may constitute a super component. The spartan programming approach makes it possible to erect slightly higher software towers, by stretching the capabilities of basic modules further. Simple, spartan like modules, make a stronger foundation.
The main techniques offered by the discipline are:
Frugal use of Variables
- Minimizing the number of variables, by inlining variables which are used only once, grouping related variables in a common data structure, and by using advanced programming constructs such as foreach loops (< code java inline> for (</code> Variable< code java inline> in </code> Collection < code java inline>)</code>), and < tt>< b> WITH</tt> and other chaining constructs in supporting languages
- Minimizing the visibility of variables and other identifiers. That is to say, defining these at the smallest possible scope.
- In C++ one would thus prefer variables defined in a block to those defined in a function scope; function scoped variables are better than class scoped variables, i. e., fields; and fields are not as desirable as variables defined in the file scope. Further, variables defined in the file scope are better made < code cpp inline> static</code> so that they are not visible in other files.
- Minimizing the accessibility of variables, by preferring greater encapsulation, e. g., < code java inline> private</code> variables, to < code java inline> public</code> variables.
- Minimizing the variability of variables, that is striving to make variables < code java inline> final</code> in Java, < tt> const</tt> in C++, etc., and by using < code java inline> nonnull</code> annotations or restrictions, whenever the development environment or programming language supports it.
- Minimizing variables' name length, by applying the generic names technique.
- Minimizing variables life time, by preferring ephemeral variables to longer lived ones, and by avoiding, as much as possible, persistent variables (i. e., files and the such).
- Thus, in C, one should prefer < code cpp inline> auto</code> (that is stack) variables to < code cpp inline> static</code> variables. Heap storage on the other hand, although potentially shorter lived than < code cpp inline> static</code> data, is considered inferior, since heap management requires extra code.
- Minimizing the use of arrays, and replacing these by collections provided by standard and of-the-shelf libraries.
- Minimizing the number of parameters each modules takes
- Minimizing the interaction possible through these parameters, by preferring input parameters to output parameters, output parameters to input-output parameters, input-output parameters to parameters passed by reference, and parameters passed by reference to parameters passed by name.
Minimal use of Control
- Minimizing the use of conditionals by using specialized constructs such ternarization, inheritance, and classes such as Class Defaults, Class Once and Class Separator
- Simplifying conditionals with early < code java inline> return</code>.
- Minimizing the use of looping constructs, by using action applicator classes such as Class Separate and Class FileSystemVisitor.
- Simplifying logic of iteration with early exits (via < code java inline> return</code>, < code java inline> continue</code> and < code java inline> break</code> statements).
Careful use of Screen Space
- Applying K& R Formatting Style for making an efficient use of screen space.
- Removing unnecessary parenthesis and braces
- Keeping routines short by appropriate modular decomposition
Worked Out Examples
- Applying spartan programming techniques to a C File
- Applying spartan programming techniques to a Java function
- Appling spartan programming techniques to a yet another Java function
The following represents a not-so-small sample of spartan programming code in Java.
- Class Position
- Class Tag
- Class Stopper
- Class CSVLine
- Class CSVWriter
- Class MultiMap
- Class Statistics
- Class Graph
- Class Tab
Classical Data Structures
Spartan programming suggests encapsulating control with appropriate abstraction mechanisms. The following Java classes:
- demonstrate spartan programming,
- demonstrate how control can be encapsulated in classes, and
- are useful to anyone practicing spartan programming