A programming language designed to be testable [closed]

Question

Is there a programming language that is testable by design or at least exhibit very good properties in terms of testability?

For instance, a programming language designed so that unit testing is a non-optional part of the coding process, or, better yet, a programming language where the program is more or less inferred from the unit tests.

Or if you prefer twisting the question a bit, what imperative programming is bad practice or unnecessary to ensure testability?

What about object-oriented programming? Things like dependency injection and mocking libraries really helped TDD, wouldn't these practices benefit from being part the language design? I've been looking around and languages with rich meta models tend to permit very DSL-like APIs to be written in the target language. These libraries are being built on top of that, why not pull these things into the language itself?

I find that that blog post referenced by James Black has a really good point to it.

Not long ago, I reflected on my testing habits for the past ten years, and I made a couple of interesting observations:

• I feel the need to write tests for the code that I write very often.
• Just as often, that need is thwarted by environmental constraints, so I end up not writing these tests.

Do you agree with the statement that dynamic programming languages make writing tests easier?

Answer 1

Google is working on noop as a language (OOP, Java-based) created to produce code that is always testable.

Noop is a new language that will run on the Java Virtual Machine, and in source form will look similar to Java. The goal is to build dependency injection and testability into the language from the beginning, rather than rely on third-party libraries as other languages do.

The language also explicitly forbids certain constructs that make it harder to test code, like for instance statics.

Answer 2

What programming languages are testable by design?

I'm having a hard time with this question, because I'm not sure what it means for a language to be testable by design. Testing is usually about tools and static analysis, not about language design.

But to the extent that a language can be testable, I'm going to assume that this means the language includes some sort of independent specification that can be tested against the code, and moreover that these specifications have been designed with testing in mind, or at least not only for theorem proving.

By these criteria, I know of three:

• Eiffel, where the "design by contract" encourages you to put preconditions and postconditions in your code, and they are tested. I consider Eiffel a successfully deployed language.

• Racket (formerly PLT Scheme), where some interesting research is going on in contracts and testing; the interesting bits are that when a test fails, the language tells you not only that a contract was violated, but it identifies what part of the code should be blamed. For more information, google for Robby Findler and for "blame". Racket is a research language, but it is an extension of Scheme, which is pretty widely used for a niche language.

• Ana, an extension of Ada done by David Luckham and his students, which supported some testing. As far as I know, Ana never made it beyond the research stage.

In addition to these languages there are myriad languages that have had assertions for purposes of theorem proving. Many of these languages had assertions that were not testable in any efficient way (universal and existential quantifiers will do that to you).