Loading ...
Sorry, an error occurred while loading the content.

124557BTUF - Big Testing Up Front

Expand Messages
  • Thiago Arrais
    Jan 1, 2007
    • 0 Attachment
      No, you don't need to read the title again, you are not mistaken. It really is
      a T instead of a D (or R, depending on where you come from). BTUF is the
      acronym for Big Testing Up Front. BTUF is basically what happens when
      people try to write all conceivable tests before starting to code. With the
      rise of Test-Driven Development this is an obviously ascending waterfall
      practice.

      Testing is also designing. When you write the tests before the production code
      in good TDD style, what you essentially do is design how the code will look from
      outside. Sometimes it may be hard to resist the temptation to design everything
      before writing a single line of code, specially for those used to
      waterfall thinking.
      For those who can't help doing it, here is some news from yesterday's paper: it
      doesn't work. Even though everybody minimally informed has already heard it,
      this message never gets said enough.

      It doesn't work because designing is infinitely better and easier when we can
      have fast feedback. Software development can be a high feedback bandwidth
      activity. Architects need to wait for the construction team to finish
      the piece and
      film writers sometimes need to wait years for the shooting to finish, but
      programmers can just compile their programs. Giving up this feedback on
      purpose is not the smartest thing to do. Writing all tests for a piece of code
      before starting the proper code is like drawing rectangles and arrows describing
      it in full detail before trying to make the whole think work. The
      over-engineering
      risk is the same because the code isn't there to scream in agony.

      The key to avoid BTUF is to write the tests that you can come up with before
      writing the code to make them green, but make sure _not_ to think too much.
      You can wait to start writing the code after all tests are in place,
      but you don't
      _need_ and neither _want_ to.

      TDD has shown us that design isn't made only of diagrams. In fact, we are
      designing all the time we are developing software. TDD is one of many
      design techniques: one that uses tests. It may be a better tool than arrows and
      rectangles in some situations. But is still just an approach for
      design. BTUF is,
      therefore, just an special case of BDUF where tests are used to determine the
      design completely before writing a single line of code.

      Cheers,

      Thiago Arrais
      --
      Mergulhando no Caos - http://thiagoarrais.wordpress.com
      Pensamentos, idéias e devaneios sobre desenvolvimento de software e
      tecnologia em geral
    • Show all 3 messages in this topic