Accurate Programming: Thinking about programs in terms of properties

Accurate programming is a practical approach to producing high quality programs. It combines ideas from test-automation, test-driven development, agile programming, and other state of the art software development methods. In addition to building on approaches that have proven effective in practice, it emphasizes concepts that help programmers sharpen their understanding of both the problems they are solving and the solutions they come up with. This is achieved by encouraging programmers to think about programs in terms of properties.

💡 Research Summary

**
The paper introduces “Accurate Programming,” a pragmatic methodology that builds on established software development practices—test automation, test‑driven development (TDD), and agile programming—while emphasizing the explicit formulation of program properties. The authors argue that thinking of programs as collections of mathematical properties enables developers to improve both the accuracy (closeness to intended behavior) and precision (repeatability under unchanged conditions) of software.

A central claim is that property‑based testing (PBT) provides a lightweight yet powerful bridge between informal testing and formal verification. By defining properties—statements that must hold for all inputs—developers can automatically generate thousands of test cases using tools such as ScalaCheck. This approach dramatically expands test coverage beyond manually written unit tests, exposing edge cases and hidden bugs that would otherwise remain undiscovered.

Scala is chosen as the host language because its strong static type system and functional programming features allow properties to be expressed succinctly and type‑safely. ScalaCheck, the accompanying library, offers a declarative API (Prop.forAll) that evaluates user‑defined properties against randomly generated inputs. The paper walks through a concrete example: implementing a function that returns the larger of two integers. After presenting concrete examples (e.g., max(3,5) = 5), the authors define several properties such as max(a,b) >= a, max(a,b) >= b, symmetry (max(a,b) == max(b,a)), and the exclusivity condition (max(a,b) == a or max(a,b) == b). Running these properties through ScalaCheck yields automatic verification of hundreds of random cases, illustrating how property definition precedes implementation and serves as living documentation.

Beyond testing, the authors discuss how property‑centric thinking reshapes the “hacking” process—rapid, experimental coding cycles. Traditional hacking often discards previous code versions and lacks systematic test records, making debugging and reasoning difficult. By contrast, when each hack is accompanied by explicit property specifications, the test suite becomes a persistent artifact that captures the developer’s intent, tracks regressions, and facilitates communication within teams.

The paper also positions Accurate Programming relative to formal methods. Formal verification provides mathematical proofs of correctness but is typically expensive in terms of tooling, expertise, and time. Property‑based testing offers many of the same confidence benefits at a fraction of the cost, and the properties themselves can serve as a foundation for later formal proofs if needed. This “bottom‑up” strategy—starting with small, well‑specified components and progressively integrating them—aligns with both effective testing practices and the eventual goal of full formal verification.

Practical guidance is provided for setting up the Scala/ScalaCheck environment, including installation steps, a minimal “Hello World” property test, and troubleshooting tips. The authors stress the importance of concrete examples as communication tools, arguing that they bridge the gap between abstract specifications and human intuition. By systematically creating examples, defining corresponding properties, and automating their validation, developers gain a clearer mental model of the problem space, reduce reliance on ad‑hoc intuition, and establish a minimal yet extensible test suite that evolves with the codebase.

In conclusion, Accurate Programming advocates a disciplined yet accessible workflow: articulate program behavior as mathematical properties, use property‑based testing to automatically validate those properties across a wide input space, and treat the resulting test suite as living documentation. This approach improves code quality, enhances developer reasoning, streamlines communication with stakeholders, and lays the groundwork for eventual formal verification—all while fitting comfortably within existing agile and TDD practices.