Apr 29 2011

NHJUG TDD Talk – Slides And Video

As I mentioned in a previous post, I recently gave a talk on Test Driven Development at the April NHJUG meeting. A few people have asked me for the slides so here they are. I experimented with recording the talk as well so you can see the results of that experiment as well.

At a high-level, the talk centered around the following topics:

  • What is TDD?
  • The developer workflow
  • In depth, live coding demo of the developer workflow
  • Some tips for test implementation, maintenance, and refactoring
  • Mocking
  • Lots of great interactive discussion from the audience!

The talk was a long one clocking in at over 2 hours so I appreciate everyone who hung in for the duration. There is a bunch of content in the slides that we didn’t talk about so you may find some interesting stuff in there even if you attended the talk.



NHJUG Talk on Test Driven Development from David Ehringer on Vimeo.

While the talk was over two hours in length, this video captures just the first hour or so. So a bunch of topics as well as some of the great discussion are unfortunately not included in the video but you can see the slides above.

0:45 – Background
4:40 – Agenda
6:15 – What is TDD?
8:40 – TDD Workflow
22:25 – TDD Workflow Demo
56:15 – Measuring TDD: Test Coverage, Code Quality, and Other Tools

Apr 21 2011

xml-matchers – Hamcrest Matchers for XML

I recently published a small, open source project that I’ve been messing around with for probably close to two years now but never got around to cleaning up and publishing. It’s called xml-matchers and is a collection of Hamcrest matchers for matching against XML documents. I primarily created it for testing but I’m sure you could find other uses for it. The project is hosted at Google Code: http://code.google.com/p/xml-matchers/.

The matchers allow you to do things like:

Source xml = ...
assertThat(xml, hasXPath("/mountains/mountain"));
Node xml = ...
String xml = "<mountains><mountain>K2</mountain></mountains>";
String xmlWithSpaceWrappingText = "<mountains><mountain>\n\tK2\n\t </mountain></mountains>";
assertThat(the(xml), isEquivalentTo(the(xmlWithSpaceWrappingText)));
Schema schema = w3cXmlSchemaFromClasspath("org/xmlmatchers/validation/example.xsd");
String xml = "<person private=\"true\"><name>Dave</name></person>";
assertThat(the(xml), conformsTo(schema));

Continue reading

Apr 19 2011

Presenting On TDD At The April NHJUG

It has certainly been a while since I’ve written anything here. Hopefully I have a bit more time to write soon.

In the meantime, I’m doing a talk on TDD at the April NHJUG in April 26th. Find out details of the time and place here. Come check out the talk if you are in the area. If you can’t make it, the NHJUG generally meets every month and has had some great speakers.

In my TDD talk, I’m planning on going into more detail than the other presentation I’ve posted, which had a lot of introductory material geared toward a less technical or more novice crowd. Depending on the audience, the plan of now is to still do a brief overview but will dive more quickly into the workflow of TDD. There will definitely be live coding to demonstrate this. I’ll also go into patterns, design tradeoffs, maintenance, and other topics. I’d also like to touch on how TDD fits into the continuous delivery lifecycle, again with some examples. If you are attending and have anything specific you’d like to discuss or have questions about, let me know and I’ll try to include something.

Nov 14 2010

Overview Of TDD Presentation

Being the TDD proponent and enthusiast that I am, I’ve given my share of the requisite “What is TDD?” presentations. I’ve promised to share some of them but have never gotten around to it. So here is one I’ve given two or three times over the past year. I know there are a couple typos so please ignore them. Otherwise, feedback is always welcome!

The presentation is also available on Slideshare at http://www.slideshare.net/dehringer/test-driven-development-5785229.

Nov 7 2010

Parameterized Tests in JUnit 4.x

Parameterized tests is one of the features that have come along in the JUnit 4.x releases that I don’t find myself using very often but when I do, I find tremendously useful. In a nutshell, parameterized tests allow you to run the same test over and over again using different values. I’ve found this approach very useful when you are testing a function and have a table of data defining the input value(s) and the expected result. That being said, parameterized tests can be used for testing more than just pure “functions.”

This post walks through a detailed example of using JUnit’s parameterized tests.

Continue reading

Sep 4 2010

Processing Files In Place With Groovy

I recently had the need to process a bunch of files and directory structures that were emitted from a generation process that I didn’t have control over.  The basic needs were to delete some files, delete some directories, and to modify selected content of some of the files.  This is a very straight forward, trivial thing to do but I was looking for a solution that was both cross platform and very quick to develop. I also had to deal with a bit of XML and wanted an easy way to parse and modify XML documents in a natural way.   This post shows how to do this using a Groovy script.  I’ve been using Groovy for testing of Java code and other one off random tasks for a couple years now but it still surprises me how fast you can accomplish certain tasks yet keep your code readable and at a relatively high level of abstraction, especially compared to shell scripts, sed, awk.

In a nutshell, the following method will process a file in place.

def processFileInplace(file, Closure processText) {
    def text = file.text

If you know Groovy, this probably doesn’t require any additional explanation. But if you don’t know Groovy, don’t worry. The remainder of this post shows examples of using this method and touches on a few details regarding file and directory deletion.
Continue reading

Jun 20 2010

Writing The Seemingly Trivial Test

Many people have asked how much time and effort they should spend testing the seemingly “trivial” code that they write. When I first started writing tests, I myself wondered about what types of tests were appropriate to write and how much benefit I would get from testing what seemed to be very trivial code. If the code I am writing is so simple that it can’t possibly be wrong, why should I spend time writing tests for it? What value do those tests provide? A classic example is verifying that preconditions are enforced during object instantiation. Continue reading

Jun 11 2010

Android’s Dalvik Virtual Machine

I recently wrote a paper on Android’s Dalvik virtual machine. I’m relatively new to the mobile development space and I was intrigued by some the design decisions that were made. Why couldn’t Android run on the Java platform as opposed to being “Java source code that compiles to the Dalvik executable format.” The JVM as a platform has become something much bigger than Java the language. So why has Google been investing enormously in technologies based on Java the language while building alternative deployment platforms to the JVM (GWT to JavaScript, Google App Engine, and now Dalvik)?Sun had invested enormous amounts of money and energy in the JVM (hopefully Oracle will continue and I can’t see why they wouldn’t especially since they own two of the main JVM implementations), so why start from scratch. Since my knowledge of mobile architectures was, and really still is, somewhat limited, I thought digging into the Dalvik architecture would help shed some light on this question. There is a huge amount information available on the JVM, but there is very little available on the Dalvik VM.  That is to be expected since it is a relatively new platform under rapid development. Given that, I thought I would post the paper as a source for others looking for more information on the subject. You can find it here. Continue reading

Jun 10 2010

Unit Testing Singletons

The Singleton

I would say that I fall into the camp that generally shies away from the use of singletons.  To start, singletons are a form of global state that is to be avoided.  They carry state across the entire execution of the program making both testing and debugging difficult.  It becomes hard to execute tests in isolation because they may modify the state of the singleton in ways that undesirably ties tests to a strict execution order.  Beyond problems with global state, objects that use singletons are highly coupled to the both the way the singleton is instantiated and the way it is implemented.  It isn’t possible to test an object that depends on a singleton without testing (or in someway relying on the behavior of) the singleton as well.   Furthermore, this coupling is hidden from the user of the object.  To correctly interact with the class depending on the singleton, a dependency that is not explicit in its interface, you must often also understand the behavior of the singleton.  In other words, the state and behavior of the singleton can affect the behavior of the depending object as well as transitive side effects. Continue reading

Jun 8 2010

It’s About Time

I know, I’m definitely a few years late to the whole blog scene.  For the past few years (at least), I’ve been saying that I would revamp my website and would include a blog in it.  But I just never seemed to get around to it.  But that was until recently, when I just so happened to browse to my site for curiousity sake, as it had been quite a long time since I had even looked at it.  What I found was quite assuming to me.  The following caption from the top of one of my photography pages really sums it up.

Select one of the albums below to view a scrolling slide show of some of my photography. Please note: they may take a while to load for those with a dial-up connection.

Apparently, I hadn’t touched anything on the site since dial-up was the norm.  So needless to say, it was a bit outdated.  And the pictures of me on the site looked like they were from high school.  And the custom built, circa 2002 guest book had received so much bot spam and the database had grown so large that my hosting provided shut it down.  And…

So that was the motivation to get me going.  I decided that could declare success by just throwing up a WordPress instance and put off a web site redesign indefinitely.

I’m not exactly sure where this thing is going to go yet.  It is really an experiment at this point.  I did create a blog a couple years back but only posted one entry to it before it faded into the archives of Blogger.  Hopefully I’m a bit more successful with this one.  The entries are obviously going to be about software, given the subtitle of the blog, but besides that, they will probably be a combination of comments about things I’m currently thinking about in my work or reading as well as tips and snippets about things I’ve worked through recently.  We’ll see if they capture anyone’s interest.