Ultratestable Coding Style

http://blog.jessitron.com/2015/06/ultratestable-coding-style.html

by luu • 11 years ago

83 68 11 years ago

blog.jessitron.com

For a filesystem integration, perhaps you can generally rely on the documentation being correct. There are lots of integrations (main cause of side effects) where this is not the case, for example if you are integrating with APIs or with a SQL database. For these cases I would want to have more than an umbrella test to check that my assumptions about the integration are correct.

kabdib• 11 years ago

Race conditions in file systems are fun. So are edge conditions around partially written data (for instance, Windows NT will transactionally guarantee a file's existence, but not its content).

developer1• 11 years ago

Testing the filesystem? This talk is interesting as hell, outlines how FoundationDB goes about testing unusual failures in systems like the filesystem and the network stack: https://www.youtube.com/watch?v=4fFDFbi3toc . Crazy beyond all belief.

erikb• 11 years ago

This agrees with the general conclusion that you can't just write tests for code, you must also write testable code.

Why it is ultra testable I didn't get, though. To me it looks like what you should do in normal mode not ultra mode.

Ensorceled• 11 years ago

Considering Boris Beizer was giving seminars on designing and coding for testability in the 80's ... yeah, not ultramode.

kojoru• 11 years ago

This is very similar to awesome Gary Bernhardt's Boundaries: https://www.destroyallsoftware.com/talks/boundaries

Watch it if you still haven't

eterm• 11 years ago

Thanks for this link, that's a great talk, in fact it deserves its own submission as I rate it better than this article.

BerislavLopac• 11 years ago

It's here, but rather unappreciated: https://news.ycombinator.com/item?id=8093389

serve_yay• 11 years ago

Fantastic, thank you!

tmoertel• 11 years ago

Take this idea to the limit and you end up with free monads:

http://www.haskellforall.com/2012/07/purify-code-using-free-...

pekk• 11 years ago

Even if that takes the idea to the limit, does that make the code any easier to understand?

chowells2• 11 years ago

No, it makes it more flexible (in ways including testability) without adding any cost in understandability.

bweitzman• 11 years ago

In some sense yes. If I see that a function has type `Teletype ()`, I can be certain that it is composed of solely teletype actions. Compare to `IO ()` where anything can happen. Of course you still have that issue when implementing `run :: Teletype a -> IO a`, but at least it's localized to one spot.

I think there is sort of a hole in the logic about testing though, since the article talks about testing `runPure` not `run` which is almost useless unless `run` is implemented in terms of `runPure` which introduces its own can of worms because you have to consider how things like laziness, streaming, etc. come into play in the pure version, which is a step in the wrong direction IMO.

What the article says about reasoning is important, but I feel like it's misleading to say that it comes from the using the free monad. It's really about the Functor instance. The fact that `ExitSuccess >> m = ExitSuccess` is a result of the Functor instance for TeletypeF not using (and not being able to use) the `f` parameter in the `fmap f ExitSuccess` definition.

If you don't want to use a free monad, you could also use a type class / monad transformer like `MonadTeletype` which defines the actions of the teletype can perform. Then you write all your teletype functions with a signature like `MonadTeletype m => .... -> m a`. You still get the guarantee that no arbitrary actions are there but you don't have the complexity of the free monads which can be a little daunting for newer Haskellers.

chii• 11 years ago

understanding it requires that the reader have some presupposed knowledge on the subject. I suspect to a non-programmer, an OOP decomposed program is just as hard to read as the free-monad version.

But the code is indeed easier to verify for correctness, due to the purity. I wish this style of programming is more prevalent, but alas, it's more difficult to write this way...there aint no free lunch

pron4• 11 years ago

Or their imperative counterpart in this case -- mock objects (in their more narrow definition, i.e. as opposed to fakes/stubs). Although mocks also often provide a good querying mechanism over the operations they capture.

chriswarbo5• 11 years ago

Well, the author's example is actually an applicative.

Monads are only needed when the output of one action determines the next action to take. If you already have a list of which actions you're going to take, you don't need a monad.

jheriko2• 11 years ago

this just falls out of writing code cleanly and properly. if you are doing something so complicated with inputs and outputs thatit becomes unclear what is happening and where things need to go in and go out then you just haven't used enough functions and classes to split up the responsibilities.

if you write clean, data driven code i can't imagine this ever being a problem you need to solve.

jerf• 11 years ago

"If you use the solution given in the article, I can't imagine why you'd ever need the solution given in the article"?

Dewie35• 11 years ago

There is always that one guy who gets offended over how obvious something is to him.

jheriko2• 11 years ago

its more that its not about writing code to be testable. its about writing code well to start with for n reasons.

ignorabilis9• 11 years ago

Mocks, stubs, shims, etc. are usually just hiding the fact that the code to be tested is terrible, even in OOP languages.

Furthermore side effects have nothing to do with testing one's code. Why? Because you have to test your own logic, not I/O or something else. I/O is already tested by someone else. So you actually don't care where the data comes from - the filesystem or a hardcoded string - you care if the output is correct after the respective transformations are applied to the input.

And when you think about it testing shouldn't be that needed at all. In the OOP world, where state and identity are helplessly tied together and we are not working with values, but with references to values, tests might be a necessary evil.

In the land of Functional however writing tests shouldn't be needed, at least in theory. Why? Because if you write small composable functions you should be able to test them right in the REPL. Corner cases? You have to think about them right from the start. TDD forces you to do so - then why shouldn't you when you have the immense power of a REPL? Once a function is ready you are not supposed to change it much. If you do you should change the inner workings and not the input/output. If you need to change the i/o most probably you need a different function. But what is more important is that if you needed to change the i/o and had tests for this function you would actually need to change the tests as well, which is more work (double? triple?) and no added value.

awinder• 11 years ago

Honest question: how do you validate business rules are adhered to without defect in FRP and how does FRP differ from OOP in that regard?

15155• 11 years ago

Stolen from Wikipedia: "FRP is a paradigm using the building blocks of functional programming." I doubt OP was referring to FRP.

In any case: in a functional programming language, you'd just unit test the building blocks (functions). Assuming every function is pure and total, these unit tests should be succinct and mirror your business logic quite closely.

marcosdumay• 11 years ago

Not with unity tests, that's a certainty. Unity tests do not test business logic.

Yes, when people say that no tests are needed, it's hyperbolic. Tests are always needed, but you do not need to test all corner cases, just the ones created by business logic.

maehwasu• 11 years ago

I write fairly large backend systems that are continuously growing and facing evolving requirements. I follow those principles, and have yet to write a single test. It's just so much more robust to separate I/O code from other code, and verify that the building blocks of the system work.

I do this in Clojure, but am looking to migrate to Haskell soon to enforce this even further.

ignorabilis9• 11 years ago

+1 for Clojure.

I suppose you will be migrating to Haskell because it is a PF language. What would you miss most from Clojure once you migrate?

trjordan• 11 years ago

I disagree that I/O can be totally decoupled. The API that I/O functions generally adhere to is too weak for your application: on error, what do you want to happen? This pushes "I/O" functionality back into your logic, and that requires testing.

In this specific example, if you write the first file, but fail the second, you might want to undo the write to the first file. Or write another file to say you failed. Or write to a log. These sorts of things are important, and mocks can be a good way to fake it.

ignorabilis9• 11 years ago

You should be testing your own code and not catching exceptions. I/O will either return an error or the string you need. There is no third option. So put aside the I/O - concentrate on testing the string transformations and on testing the logic that handles the error.

Btw in functional languages catching exceptions is not idiomatic, it breaks the functional approach.

In this example you are not supposed to test undoing the file. Undoing (deleting) is what I/O does and this part is tested by someone else, somewhere else. You only need to test the arguments that are passed to that specific I/O function. If they are correct your program is correct. If they are hardcoded you shouldn't be testing them at all.

You may want to write a log. Again, test what you are about to pass to an I/O function. Don't test if the file is actually written. If you supply the I/O function with the correct arguments and the function fails to write the file, the issue is not in your code - search for it elsewhere.

stcredzero2• 11 years ago

Once a function is ready you are not supposed to change it much. If you do you should change the inner workings and not the input/output.

This presupposes that you will always come up with an adequate design, and that you won't have to refactor this library of functions. For large enough systems, this is almost never the case. For sizeable systems in production, you will always come up against things you haven't thought of before.

Granted, proper factoring of your functions in the first place is going to help a lot. (Small composable functions.) However, if you claim that you can code such that you never ever have to change your mind about function signatures, never have to propagate changes across the system, even in large production systems, then you're either not seeing something, or you have some technique which you should be selling or basing a consulting practice around. (And/or, maybe I have something new to learn.)

EDIT: I have written projects in Clojure, including a multiplayer game server. This is the experience I'm basing this comment on.

ignorabilis9• 11 years ago

In the previous post I started with in theory. What this means is that theoretically things can go like this and in practice they have gone for me until now (with Clojure, so +1 for you too :)). It doesn't mean that it will work for everybody or even for me in the future.

Then: Granted, proper factoring of your functions in the first place is going to help a lot. hence -> Once a function is ready you are not supposed to change it much. much not= at all.

And you are absolutely correct - eventually you will have to change some of your functions. And when you need to do so you should focus on the logic and take your time until you understand it completely. Only then refactor the funciton. So the emphasis should be on the developer completely understanding the task and not on the developer finding a cheap way to change the code and rely on tests to catch his errors.

Furthermore if you change the signature of a function, tests are just another place where you need to change the function as well. In practice the tests that you wrote are not doing you any good because you cannot test the reinvented function with the old set of tests.

Sure, tests might catch a few errors here and there at some point. But after all what is more time consuming - maintaining hundreds of thousands of tests or focusing on your single, small, composable function and your problem?

I am part of a team that develops a very large .NET (with C#) product with hundreds of projects in the solution. So far the primary use of tests is to be maintained. They caught a few bugs, true, but nothing that our QAs were not going to see anyway. In imperative OOP land tests are a necessary evil, but with time I started doubting even that thesis.

chriswarbo5• 11 years ago

tests shouldn't be needed, at least in theory

Tests are very useful for distinguishing between "what a function does" and "what you think a function does". Especially when you're building on functions written by others. Types and documentation help too, but if someone's already misunderstood something, such descriptive information might still fit nicely with their incorrect world view.

Personally, I can't live without QuickCheck :)

crdoconnor2• 11 years ago

Writing code to verify code is so much harder than just writing the code

It's not supposed to be easy. Doing it well is really hard and way underappreciated.

Testing side-effecting code is hard. This is well established. It's also convoluted, complex, generally brittle.

It's not necessarily brittle when done right but it's hard, it's convoluted and it's complex.

Before the test, create the input AND go to the filesystem, prepare the input and the spot where output is expected. After the test, check the output AND go to the filesystem, read the files from there and check their contents. Everything is intertwined: the prep, the implementation of the code under test, and the checks at the end. It's specific to my filesystem. And it's slow. No way can I run more than a few of these each build.

This doesn't sound like it would take more than a few hundred milliseconds. That's not slow.

Furthermore, you could definitely run it on multiple filesystems by firing up a virtual machine for each filesystem and running the test. That would be slow, but you don't need to do it often.

mikeash2• 11 years ago

I generally want all tests in total to complete in a few seconds at most. Longer than that and they become a serious impediment to the edit build test cycle, and you either start screwing around with only running some tests routinely, or only run the tests occasionally, neither of which is good.

If a single test takes a few hundred milliseconds then that means you can only run a dozen or so such tests before you hit that problem, which isn't very many. I'd say that a few hundred milliseconds is quite slow in this context.

Alupis• 11 years ago

There's nothing wrong with having a full test suite that runs as part of the nightly build.

Sometimes it's just not practical to impose a hard limit of "a few seconds at most" on your test suite, especially for larger projects. (some projects have test suites that take hours to run, and simply cannot be any quicker unless they were less thorough).

crdoconnor2• 11 years ago

I generally want all tests in total to complete in a few seconds at most. Longer than that and they become a serious impediment to the edit build test cycle, and you either start screwing around with only running some tests routinely, or only run the tests occasionally, neither of which is good.

I don't think that's a problem at all. I usually run one functional test at a time while developing (ideally runtime < 30 seconds) which covers the code that I'm changing.

90% of the bugs that I introduce accidentally will get picked up by that test while I'm refactoring.

In the background (often on a different machine) I will have the full set of tests running constantly. Those might take hours to complete (sometimes a whole night). They will pick up the 5-10% of bugs that slipped through the net eventually, though - which is ok.

This is way better than having a unit test suite that doesn't even come close to mimicing real life usage, and is a PITA to maintain because it's naturally tightly coupled to your architecture (this bites you back when you refactor).

If a single test takes a few hundred milliseconds then that means you can only run a dozen or so such tests before you hit that problem, which isn't very many. I'd say that a few hundred milliseconds is quite slow in this context.

One 500 millisecond test for this particular use case will pick up 90% of bugs. No, that is not going to interrupt your development cycle.

Yes, a full suite of tests that fires up a VM for every different possible kind of filesystem will take hours. That's perfectly ok. You can go get a coffee while it runs.

vosper• 11 years ago

I don't want there to be an edit/build/test cycle - I want my tests to be validated continuously. I want my IDE to point out instantly that I have made a change that breaks 3 of my 10 unit tests, and I want a panel that shows exactly what the output used to be for each test, and what it is now.

Dewie35• 11 years ago

It's not supposed to be easy.
[...] run it on multiple filesystems by firing up a virtual machine for each filesystem

Yeah... I can see what you mean by not supposed to be easy.

michaelfeathers• 11 years ago

I like the IO monad in Haskell because it places a tax on mingled code. It's easier to keep IO at the top level and just call into pure code.

sqeaky• 11 years ago

I read the title as "Untestable Coding Style" and I came to see some bewildering and obfuscated code.

But this is good too.

couchand• 11 years ago

The diagrams are very helpful, but they fall victim to an unfortunately common mistake: labeling the boxes but not the arrows. We know from the text that not every arrow is the same here. Clarify that in the diagram. Label your arrows!

gcb0• 11 years ago

mock the filesystem

it's beautiful in theory. but reality goes like this: "i only have this little method. writing mocks will take 5x more time then the code. i will just test the side effects on the functional tests"

then, a year later, the team added a dozen methods that would benefit from the mock, but since you did the first one in functional only, the team just added the new ones there as well.

the end. (because nobody refactor projects for tests)

pron4• 11 years ago

Only, what the article describes is exactly -- down to a T -- what mocks are (in their more narrow definition, i.e. as opposed to fakes/stubs). They capture your calls to actual real-world interaction and turn them into a list of operations that can later be queried and verified, and they do all that without requiring you to create a new DSL for capturing and describing effects.

The article starts with discounting mocks, and later describes how you should hand-code them each time.

Dewie35• 11 years ago

She seems to want to use a more FP design anyway. In which case the code isn't just testable for her but good, more generally.

chriswarbo5• 11 years ago

They capture your calls to actual real-world interaction and turn them into a list of operations that can later be queried and verified

The author's point is to avoid interleaving logic and side-effects (as much as possible) in the first place. Yes, we can use dependency injection to send mocks deep into the bowels of our application where they get called. Alternatively, we can have the bowels of our application return values, describing what to call, back up to the top of our application. These are exactly dual.

The nice thing about the latter is that every action gets reified into a concrete value, on which we can perform any kind of computation we like. Dependency injection can't do that, since a method call is not a value (it can return a value, but it isn't itself a first-class value).

Mocks allow us to inspect which calls have been made, etc. but mocks are for testing. We can't use those interfaces in our real code. If we use a list-of-actions we can, for example, run optimisation passes before execution.

they do all that without requiring you to create a new DSL for capturing and describing effects.

Mocks do require a new DSL for capturing and describing effects; it's normally called a "public interface", but it is a DSL (an algebra) for describing effects.

pron4• 11 years ago

The author's point is to avoid interleaving logic and side-effects

But with mocks you're not really interleaving side effects. They are the same as generating "effect values", only they use the same API as the actual effect.

The nice thing about the latter is that every action gets reified into a concrete value, on which we can perform any kind of computation we like.

That's what mocks do. They capture calls and turn them into reified values that can then be manipulated and queried.

Mocks do require a new DSL for capturing and describing effects; it's normally called a "public interface", but it is a DSL (an algebra) for describing effects.

Except that API is identical to that of whatever effect API we're using.

A mock is a mechanism for turning effects into values. It just works automatically by means of interfaces (in the language sense) and reflection. It is an imperative construct that achieves -- without extra work -- the very same functional effect the author is striving for.

Ultratestable Coding Style

Related Stories