sevensoft

InfoQ catching up with the easyb team

Ken Brooks — Tue, 23 Sep 2008 04:23:00 +0000

Craig Wickesser from InfoQ pinged the members of the easyb dev team recently in preparation for an article about BDD and bringing it to the masses.

The focus of the article is on easyb. It references Rod’s excellent JavaWorld article and then goes on to dive into a brief Q&A with the easyb team.

If you want some inside information on where easyb is headed, then Behavior-Driven Development for Everyone by Craig is hot off the presses today and is a must read.

pretty print your behavior

Ken Brooks — Sun, 21 Sep 2008 00:00:00 +0000

Our favorite BDD tool is about to get some upgrades that give you that warm fuzzy feeling inside. Just like waking up on a cold winter day to the wonderful smell of baking cookies. Yummy!

Html reports you say? Well hello Mr. Fancy Pants!

All the goodness you’ve come to love about the existing easyb reports have now come to life in living color. In order to enable them, you’ll just need to configure another report in exactly the same way as other reports.

via ant in your easyb task:

<report location="target/easyb-report.html" format="html" />

or on the command line:

c:>java org.disco.easyb.BehaviorRunner my/path/to/MyStory.groovy -html ./target/easyb_report.html

Currently available are a Summary, Specification List, Stories List, Specification List Plain, Stories List Plain.

The Summary you saw just above. It will show you an overall summary, and summaries at the specification and story level. Any failed behavior count will be highlighted in red and pending behaviors will be highlighted in a wonderfully peaceful reminder color of purple.

The Stories List provides all of that that but takes it a couple of steps further. All of the elements of the stories (any scenarios, givens, whens, thens, etc.. ) will show up when the story name is clicked on and for any failures you’ll get an eyeful of failure messages along with part of the relevent stacktrace.

More of the same for Specifications list.

Since all we had prior to easyb 1.0 was a text only format, we got sentimental and included a stripped down, nearly text only, format here as well. Ok, so we didn’t really get sentimental, we actually thought this is really where the rubber meets the road when it comes to bringing stakeholders and developers together. As part of your build you can now publish these reports and share them with those interested parties. Makes BehaviorDrivenDevelopment truly, uh, easy!

All of this and more is waiting for you in easyb 1.0. Just like those tasty warm cookies, its still in the oven and I’ll bet you can’t wait to get your hands on it.

Keep an eye on the following sites for more announcements about the availability of 1.0.

an easyb storm is brewing

Ken Brooks — Sat, 20 Sep 2008 04:40:00 +0000

The press on easyb has really picked up in the last few weeks. I think the development world at large is about to catch onto the super fun way of BehaviorDrivenDevelopment via easyb. For those of you who haven’t heard, easyb is a BDD tool for testing your code but it has a slick DSL (Domain Specific Language) that makes it ridiculously easy to specify and ensure the intentions of the code you are testing. Best of all, its written in groovy so its usable in your existing jdk5+ jvm.

Here are a few posts I know about, feel free to ping me with others you know about.

Behavior-driven development with easyb
Java Emerging Technologies Conference 2008 (JET 2008) - Easyb is one of the topics for presentation
Is easyb easy?

SSL - security by confusion

Ken Brooks — Wed, 10 Sep 2008 03:41:00 +0000

Being a developer, I have to admit that transport security is not usually something I put much thought into. I secure the application itself (authentications, authorizations, and prevent attacks directly to the site like sql injection, xss, etc..). However, when dealing with the external world we are faced with securing the transport when sensitive data is involved.

Developers know enough to utter the phrase SSL when this becomes a concern. Seems like a common problem that needs to be solved so I would assume that there is a very simple solution. Some place i can go to for a basic tutorial, pick up a toolkit and off I go.

Not exactly.

Not even remotely close. I’m sure that 6 months from now it will all seem so easy and I’ll find this post to be just silly. But right now I’d have to say that I was more frustrated by looking for good sources of information on SSL than just about anything I’ve researched in the past 5 years.

My problem is that I wanted to use 2 way SSL. My criteria for what I needed to know was relatively simple. Find a place to define the general concepts of SSL. I now know some of these to be part of that domain: keystores, certificates, certificate authorities, certificate chains, self signed certs. At the beginning of this journey I didn’t even know what those were, I truly didn’t know where to start. I didn’t even know enough to ask what I should be asking about.

Every place I turned seemed to be an outlet for people obviously far smarter than I, because invariably I ran across reams of documents about low level encryption algorithms. Honestly, I’m not compelled to be intimately familiar with all the details of cryptography or PKI, I just want to know where the durn ON button is for security. Even my trusty old friend wikipedia let me down in this area. (http://en.wikipedia.org/wiki/SecureSocketsLayer) It almost seems as tho the industry has agreed that the way to stop hackers is in the strength of confusion, whereas I would have thought it would have been the strength of the encryption.

There were 3 pages that seemed to help out in putting the puzzle together.

http://www.faqs.org/docs/Linux-HOWTO/SSL-Certificates-HOWTO.html
http://www.eclectica.ca/howto/ssl-cert-howto.php
http://java.sun.com/j2se/1.5.0/docs/tooldocs/windows/keytool.html

In a future post I’ll try to lay out a high level picture of the landscape (so hopefully others will not have to go thru the same expedition I did) and I’ll also be giving step by step instructions on setting up 2way ssl, using self signed certs for development testing, in a Weblogic 10 environment.

Executable Documentation - EasyB style

Ken Brooks — Mon, 04 Feb 2008 21:45:00 +0000

One of the challenges of maintaining and enhancing an existing system is that the documentation goes out of date probably before you even finish it the first time. Whenever someone has a question for me about how does something work I usually refer to the location of truth. That would be the code itself, which is always the most up to date source of documentation. So the closer to the source you get the better chance your documentation has of standing the test of time.

Unit Tests helps in this area in that they can outline the assertions we are placing on our code. That too must stay up to date because it is also close to the code. Unfortunately unit tests are often more complex than the code they are testing and ultimately end up not being very good sources of documentation either.

There has to be a way to build human (possibly even business person) consumable documentation that stays in sync with the truth.

Enter EasyB.

EasyB is a BDD testing framework written in groovy and java. It provides what we like to call executable documentation. This is achieved by taking TDD, all sopping wet with techy mess, and throwing it in the evolutionary dryer with a nice fabric softener. Out from the other end pops a nice fluffy testing framework that can not only provide up-to date documentation about the application every time it is built, but can even bridge the gap between business requirements and developer interpretation.

It has two supported ways to write specifications. Behaviors and Stories. Its just a matter of personal taste on which you use for each component in your project. Behaviors often are shorter and good for utilities. Stories are more verbose and usually map to a series of interactions.

Behaviors look like this:

it "should return null for null input to trim", {
  ensure(StringUtilPartial.trim(null)) {
    isNull
  }
}

it "should return the string without whitespace at either the end", {
  StringUtilPartial.trim(" somestring ").shouldNotBe null
  StringUtilPartial.trim(" somestring ").shouldBe "somestring"
}

Stories look like this:

scenario "appending string to empty string buffer", {
  given "an empty string buffer", {
    stringBuffer = new StringBuffer()
  }

  when "a string is appended", {
    stringBuffer.append("somestring")
  }

  then "the buffer should contain the string appended", {
    stringBuffer.toString().shouldBe "somestring"
  }
}

scenario "appending string to existing string buffer with existing data", {
  given "a string buffer with an initial value", {
    stringBuffer = new StringBuffer("abcd")
    originalStringBufferValue = stringBuffer.toString()
  }

  when "a string is appended", {
    stringBuffer.append("somestring")
  }

  then "the buffer should contain the original value plus the appended value", {
    stringBuffer.toString().shouldBe(originalStringBufferValue + "somestring")
  }
}

What you have just witnessed is that we have tested our code and written documentation at the same time. That documentation will evolve right along with the code its testing and nobody has to be the low man on the totem pole and write documentation.

All well and good, but what we wrote above still wouldn’t be what a business person would consider documentation. Too much techy goobledeegook in there. Easyb has another trick up its sleeve especially when dealing with the story based specifications. When I ran the story above a report is generated and here is what the contents look like:

  Story: string buffer
    scenario appending string to empty string buffer
      given an empty string buffer
      when a string is appended
      then the buffer should contain the string appended
    scenario appending string to existing string buffer with existing data
      given a string buffer with an initial value
      when a string is appended
      then the buffer should contain the original value plus the appended value

What?! Where did that english documentation come from? Shhh.. don’t tell your developers that they wrote it.

Check out easyb at easyb.org and join the group to keep up on the latest developments. The current release of easyb is 0.6 and some of the syntax presented above (shouldBe for example) is in the trunk and not a release yet.

Simplicity and Consistency (Part 2: Consistency)

Ken Brooks — Sat, 26 Jan 2008 22:53:00 +0000

Maintaining consistency within a shop is one of the easiest things to do and one of the best ways to save time and reduce errors.

Consistency comes in many flavors.

Languages used
Tools used (build systems, scm)
Code standards
Processes (code reviews)
many more.

One thing that wastes a tremendous amount of our time is context switching. Context switching happens when ‘being in the zone’ is interrupted, forcing you to drop what you were working on and get up to speed on a totally different topic. By having consistent set of items from any or all of the above categories the context switching is reduced.

Keeping your list of languges and tools to a minimum goes against what we as creative people (known as developers) thrive on. We love to learn new languages and we love to use the newest and shiniest toys available. Unfortunately, introducing new languages and tools most often serves to complicate our environment and eat up more of our precious time. Unless a plan is put into place to consolidate multiple tools or replace existing tools then what you end up with is having to support each. That costs usually outweighs the benefit.

I’m all for “using the right tool for the job”. However, it seems hard enough to find good developers for one language, much less those that know, or are willing to learn, ‘the right tool’.

Of course, all of this is different for each shop. Many of the problems I mention may not affect small startups. They might only have one application and thus only one language, one build system and one SCM. If you come from the enterprise world or a company that has been around for a long time then you probably can relate.

Take a look around next time you are at work and take stock. Do you already have too many tools? Do you notice a trend of new tools being consistently added? Do you notice your productivity waning?

Simplicity and Consistency (Part 1: Simplicity)

Ken Brooks — Fri, 25 Jan 2008 00:20:00 +0000

Any intelligent fool can make things bigger, more complex, and more violent. It takes a touch of geniusâ€”and a lot of courageâ€”to move in the opposite direction. â€”Albert Einstein

This speaks volumes. The mission statement for the group I’m part of at work is ‘Simplicity, Consistency’.

Simplicity is difficult. It is probably the hardest thing to achieve in development.

A developer usually goes thru a maturity process in stages. See if any of this sounds familiar.

Developer produces very little code. They struggle to get anything done
Developer produces alot of code as they become familiar with the language of choice
Developer produces alot of code but now does it fast!
Developer produces the right solution in very little code.

Q: Why would I want to spend time simplifying if I can rip thru the code at lightspeed?

A: The code you are writing is probably going to be around alot longer than you think. That means that many people will probably have to open it up and understand it. The less lines of code you write, the less they’ll have to digest and the meaning of the code is usually not obfuscated. (Now, to be fair, I’m not saying that making code terse for the sake of being clever is a good thing. That is probably my biggest gripe with perlisms. They are terse at the expense of clear meaning.) The easier it is to understand, the faster you can change it and the likely hood that your changes will be successful will go up.

In my years of development one thing remains quite constant. It usually never fails that when a challenge is presented, the best answer invariably turns out to be the simplest. However, its usually the hardest to arrive at.

So next time someone tries to use lines of code written or some other ‘objective’ way of measuring your developer and codebase maturity perhaps you should rebut that you value those that spend more time on less lines of code than less time on more lines of code. It will save you time and money in the long run.

Launchy 2 and batch files

Ken Brooks — Wed, 26 Dec 2007 14:16:00 +0000

I feel crippled when I work on windows. The reason is that I rely on QuickSilver on my mac so much. The closest thing I’ve been using (and I think I’ve tried them all) is Launchy. While not living up to the lofty bar set by quicksilver, launchy has worked relatively well for me in my windows (read: work) life.

Today I saw a notification that Launchy 2.0 was out and decided to upgrade. Shame on me because I didn’t do any reading about it first. Normally I wouldn’t figure this to be an issue. Just download it, install it and move on. However that little miss cost me an hour or so of time.

Launchy was rewritten and as a casualty of that all existing configurations (directories to be scanned, custom commands, etc..) paid the ultimate price. Gone. So just be warned that if you plan on upgrading to 2.0 you should probably jot down your configurations.

Another change, which I don’t want to waste the brain cycles on figuring out why, is that I used to be able to start a .bat file that we use to set environment variables and so on. That would open up and stay in the command prompt. Since the upgrade it opens the batch file, runs it and then exits the shell. Hrm… not exactly what I hoping for.

I created a workaround that actually provides a little more functionality than before. There is a plugin called runny or runner bundled with launchy and we can leverage that.

Open up launchy
Right click and choose options
Select the 4th tab ‘Plugins’
Click on ‘Runner’ in the left pane
Click the + to add another command to be run
give it a name (the shortcut you will refer to it as when invoking launchy)
put C:\WINNT\System32\cmd.exe or C:\Windows\System32\cmd.exe in the program column
put /K pathtobat\batfile.bat $$ in the arguments column
click ok

Now when you invoke launchy you can give it the short name and hit enter, or give it the short name, hit tab and then pass additional arguments to your batch file..

easyb plugable functionality

Ken Brooks — Sun, 23 Dec 2007 20:36:00 +0000

if you aren’t familiar with easyb (http://easyb.org), then do yourself a favor and pay that site a visit to learn the basics of this great bdd framework for java.

one of the strengths of easyb is its domain specific language that allows us to write behaviors and stories that act as executable documentation. we also have a way to allow you as a user to extend that by writing plugins.

here are the steps to do so:

implement Plugable on our plugin classes (optional)
create the following file META-INF/services/org.disco.easyb.core.delegates.Plugable
package it all up into a jar and make it available on the classpath

lets start with our class, write any java/groovy class that exposes a public method and (for readability) implement the org.disco.easyb.core.delegates.Plugable interface.

now, create a file named org.disco.easyb.core.delegates.Plugable and when you package everything into the plugin jar put that file into the META-INF/services directory. the contents of the file need only be a list of classes (fully qualified) that optionally implement the Plugable interface and expose public functionality you wish to mixin to easyb.

package your classes and the property file into a jar file (outside the scope of this article) and make sure that jar file is available on the classpath when easyb stories are run

three steps, thats it? seem too simple! thats what easby is all about.

So whats happening under the covers? when easyb encounters a method call in the story that it can’t resolve it then goes thru the list of classes found in the META-INF/services/org.disco.easyb.core.delegates.Plugable file. Each class is then inspected to see if it contains a method that can handle our call. If it finds one then everything is golden and the call is made, if not then a MethodMissing exception is thrown.

If you wish to see an example of this completely implemented then checkout the easyb source and look in the plug-ins dir for easyb-dbunit. This mixes in dbunit functionality into easyb.

The thrill is gone

Ken Brooks — Sat, 30 Jun 2007 20:11:00 +0000

… or is it?

Always seems like our industry goes in dry spells of NBT (next big thing) or something with just a general wow factor about it.

I haven’t really seen anything recently that tickled my fancy. That all changed this morning and my wife and little girl were packing up and about to head to Ocean City, MD. I figured I would hit maps.google.com because we were going there but was also going to take a detour to see some relatives. Normally that means I have to map two routes. One from my house to theirs, and then one from theirs to the beach. Not anymore. I mapped the route to the beach and then something possessed me to hover over the route as if I was going to drag it around to create a detour. It did!

Now that is something completely wow to me, seeing that recalculate like it did on the fly and then update the directions in the left nav.

Oh, and the beach is great, since I knew you all were really wondering. Blogging this from the balcony of the Lankford hotel right on the boardwalk.