SpecFlow 1.5 introducing Step Intellisense in VisualStudio

SpecFlow is aiming at providing pragmatic BDD for .NET.

SpecFlow 1.5 comes with Intellisense for step-completion in VisualStudio 2010:

When you are writing feature files, you get Intellisense after Given/When/Then/And/But keywords.
As usual you can trigger Intellisense with Ctrl-Space.

The feature is switched off by default. You have to enable it under Menu –> Tools –> Options then choose SpecFlow. In the Editor Settings set 'Enable Intellisense' to True:

SpecFlow can be downloaded from GitHub.
SpecFlow 1.5 comes with various improvements and fixes. The full changelog is here.

Keep your specs flowing!

follow me on twitter, I need some friends :-)

SBB Developer Day 2010

Last Tuesday I was invited to give a Talk at the SBB Developer Day.

Here is my Prezi: Automated Testing: The Developers Viewpoint

Automated Testing: The Developers Viewpoint on Prezi

The SBB Developer Day is a full day conference that SBB organizes for their IT staff. Most part of the day is organized in three parallel tracks. All together there were about 170 people attending the conference.


I really enjoyed the program of the conference and the other presentations. I found the quality and the experience of the conference very positive, which is remarkable for a pure "in-house" conference.

I had an interesting short conversation with @grabnerandi from Dynatrace about combining continuous performance testing. He had some very interesting ideas about the lower right quadrant of the Agile Testing Quadrants.
Andy gave a very interesting presentation about "The Top Performance Problems in modern Applications".

follow me on twitter, I need some friends :-)

Rewrite It!

For a lot of projects a throw-away prototype would be the right thing to do... but people are very afraid of throwing away software.

This idea of throwing away your project can even be taken further than prototypes! TekPub has proven that, read it here:

• Architecting TekPub - Moving from ASP.NET MVC to Ruby on Rails
• Upgrading Tekpub with Rails 3

It seems that TekPub has been completely rewritten two times since going into production about a year ago (and several times as spikes before and after going into production).

This is the very realization of some interesting concepts:

• Deliberate Discovery
• Build Less
• Race to Running Software
• Ship It
• Rework

 

Compare that to your corporate legacy enterprise project ... sure it can't be compared, but why? Couldn't a rewrite be more effective than the uncontrolled growth we all observe in legacy applications?

It would mean that you also have to keep your enterprise applications slick and lean. Why is that so hard in corporate IT?

The challenges in rewriting legacy enterprise application are probably the missing stakeholders, the missing original goals and the lost knowledge of the current teams. And those rewrites that are attempted often end up in a gigantic technically driven framework monstrosity... probably because that is easier to do than thinking about business value.

This seems to be an omnipresent pattern and leaves the sour question if corporate IT is really the place you want to be ... especially if you compare it to the seemingly challenging and adventurous parallel universe of web startups.

follow me on twitter, I need some friends :-)

Quotes of the Week: Domain Driven

Domain Driven Design is impossible with a classic three layer architecture where DTOs are being shared across layers.

- Greg Young
DDD Exchange 2010

If everyone agrees that it's obviously correct:

• that the system has layers
• the one at the top is a website
• the one at the bottom is a database

...then you probably don´t have much of a domain!
Note that adding an ORM layer does not magically create a domain!

- The Keith Braithwaite, Nothing New under The Sun

 

follow me on twitter, I need some friends :-)

Quick Note: Deliberate Discovery

Interesting thoughts in Deliberate Discovery (and the matching blog-post) by Dan North:

Ignorance is the crucial constraint in software projects

Second-order ignorance: you are usually ignorant of how ignorant you are!

Embrace your ignorance

Optimize for learning, delivery will take care of itself

Get anything into production early

TDD might not be the best thing when you don't know what you are doing: Spike-and-stabilize - deferred test-driven testing

 

... I am awaiting the podcast.

Quick Tip: Demoing Selenium with Firefox on OSX

Whenever I prepare a presentation that contains a demo with Selenium for web automation, I am fighting with the same stumbling blocks again and again.

Also see my post Quick Tip: Running Selenium on OS X Snow Leopard.

Another thing is the offline-mode of Firefox: If you don't have internet connection during your presentation, selenium-server will start firefox, but firefox will drop into offline mode from which selenium cannot run its browser automation.

Here is a way around this:

1. Create a Firefox profile which will then be used by selenium:

Start Firefox with the profile manager: /Applications/Firefox.app/Contents/MacOS/firefox-bin -ProfileManager -no-remote

In the profile manager: Create a new profile. I called it 'selenium'. Remember the path to this profile directory that is displayed in the wizard. In my case the path is: /Users/jbandi/Library/Application\ Support/Firefox/Profiles/qd79pvsv.selenium

Then start the selenium server with the new profile:
java -jar selenium-server.jar -firefoxProfileTemplate /Users/jbandi/Library/Application\ Support/Firefox/Profiles/qd79pvsv.selenium

2. Configure the profile to not use offline mode:

Start Firefox with the selenium profile (i.e. by running selenium without internet connection).

Enter about:config in the location bar.

Create (right click) a new boolean preference network.manage-offline-status with the value false.

This worked for me with Firefox 3.6.12, Selenium 1.0.3 on OSX 10.6.5.
There is a lot of info on the net about setting the preference toolkig.networkmanager.disable' to false. This did not work, I think this is only valid on Linux. Also the extension 'StayInOnlineMode' did not solve the problem.

A trick for better demos with selenium is executing these commands on startup (in my case from java):

selenium.getEval("window.moveTo(140, 25);");
selenium.getEval("window.resizeTo(1000, 600);");
selenium.setSpeed("1000");

This places and resizes the automated browser window and slows down the automation, so that the audience can actually see what is going on.

However I did not manage to bring the browser window automatically to the front, it always starts in the background and I have to bring it to front manually (any tip would be appreciated).

follow me on twitter, I need some friends :-)

Quotes of the Week: Downfall of Agile in the Real World

Scrum is easy, as easy as explaining push-ups... the challenge is the practice!

- rhundhausen,
proscrumdev brussels

I don't read agile books. They are a waste of time!

Agile books out there are just people telling stories about stuff. Stories are great -- love to hear them. But I can't trust the authors of most of these books to tell honest stories and learn honest lessons from them. Instead they have a theme.

The problem is, real life doesn't have a theme.

- Agile Ruined my Life

 

Agile development's primary tenants is to value people and interactions over processes and tools.

The principle sponsors of the Agile 2010 conference are "Agile" tool vendors.

Somehow, we've walked in a circle - yet again.

- Scott Bellware, User Stories are Temporary

 

follow me on twitter, I need some friends :-)

Getting started with NoSQL

For some time I am looking at the NoSQL movement and I am not quite getting what it is and why it is better at solving certain problems.

There is a lot of fuss and not very competent information out there.

Recently I was listening to SE-Radio Episode 165: NoSQL and MongoDB with Dwight Merriman. This is a very good source to get started to comprehend NoSQL. I can fully recommend it.

This series of posts on the MongoDB blog are a good read: On Distributed Consistency. These concepts are essential to get what NoSQL is about.

Ayende does also a good job on explaining RavenDB in episode 84 of Herding Code.

follow me on twitter, I need some friends :-)

Oracle vs. Google reminds me of Matrix Revolutions

Ha ha ha ...

All that talk, predicions, more talk and conspiracy theories around the Oracle vs. Google lawsuit and it's meaning for Java reminds me somehow of the time right after Matrix Revolutions when everybody was speculating about the plot of the third movie Matrix Reloaded. (Why can Neo control the sentinels in the real world, why can Smith take the body of a real human, what did the architect really mean ...)

There were actually people that spun up plots for Reloaded that were much better* than what finally turned out to be the disappointing end of the trilogy. I guess the same is true for the current wild theories where Java is heading ...

... somehow I suspect that the same that happened to Matrix Revolutions will happen to all the fuzz and expectations about where Java is heading: A year from now nothing will have changed substantially (Revolutions was not worthy to be connected to the first Matrix movie) and nobody will talk about it any more.

Much ado about nothing!

*search for neo2083

follow me on twitter, I need some friends :-)

Book Review: Azure In Action

I was doing a review for "Azure in Action" by Manning.

This book is the perfect guide on your journey into the Cloud.

If you are a .NET developer you should definitely read this book. Cloud computing is becoming a major topic for the future and the Microsoft Azure Platform is the way to go for .NET developers.

Even when you are not going to write a Cloud application in the nearest future, you should have an idea of the principles and concepts that come with the Cloud.

Also some of the concepts of programming for the Cloud and their difference to traditional programming can be very enlightening and can provide you a new perspective, that is also applicable in non-cloud projects.

I can recommend this book also for developers that are not developing for the .NET platform. So far this is the best book I have seen for explaining how programming for the Cloud works and discussing the underlying concepts.
The book shows concrete examples hot to architect and build applications for the Cloud. This is valuable knowhow, even when you build your Cloud applications on another platform than Azure.

The book is written in a light way that makes it an easy and enjoyable read. The style is entertaining with little amusing jests spattered throughout the chapters. Nevertheless the light style is never distracting from the real goal to provide valuable technical content.

As I said before, I think the book is very interesting, because it not only explains the technology/API but also the concepts and principles behind it.
Two examples of this are:

Thorough discussion about the different storage options in the Cloud (Table Service, BLOB storage, SQL Azure, local storage, CDN). The book provides good guidelines when to choose what and shows the implications on the architecture and the design of the system.

The clear differentiation between web-apps (web-roles), storage and background processing (worker-roles, queues) and how to architect scalable applications with this separation.

follow me on twitter, I need some friends :-)

Building the Gherkin on OSX

Update 2011-09-01: Updated changes of github repositories and changes in rake build.

Recently I wanted to build the Gherkin project to reproduce a certain behavior we observed in SpecFlow.
These were the steps that were necessary to build the Java version of the Gherkin parser on OS X:
Ragel installation:
I am using MacPorts. Installing Ragel is a breeze:

sudo port install ragel

rvm installation
I figured that rvm is the best option to install JRuby side by side of other Rubies.
I followed the installation instructions of rvm.

JRuby installation
... again a breeze with rvm:

rvm install jruby

Switch to JRuby

rvm use jruby

Clone gherkin:

git clone http://github.com/cucumber/gherkin.git

Clone cucumber:
To build gherkin you need the cucumber sources lying beside your gherkin sources.

git clone http://github.com/cucumber/cucumber.git

Required gems:
You need some gems to build gherkin:

gem install rspec json term-ansicolor rake_compiler awesome-print builder

(other gems like rake, bundler were already installed ...)

Java dependencies:
The rake build needs json-simple lying in your local Maven repository

cd java
mvn clean compile

The maven compile step of the maven build will fail, but it will download the json-simple dependency into your local repository.

Executing the rake build:

rake clean
rake jar

Executing the java build:

cd java
mvn clean compile test

All tests should pass. Now you can open the java project in your favorite IDE.

Things technical and not so technical ..

Check out This Developers Life, the podcast by Rob Conery and Scott Hanselman.

They “tell stories technical and not so technical”.

This is great entertainment with a cool soundtrack. I enjoyed the first episodes very much on my latest travels …

Top 24 Agile Web Testing Tools

According to the book Agile Testing there is a certain kind of tools called Agile Web Testing Tools. The book does not contain a precise definition.
My definition of Agile Web Testing Tools contains the following characteristics:

• Lightweight (not needing heavy infrastructure or installation nor difficult licences)
• Can be run on any developer workstation and can be easily integrated in a continuous build
• Programmatic API for web automation
• Integrates with common test automtation frameworks (JUnit, NUnit ...)

I don't fully agree with the "Agile" prefix, but I guess that is an attempt to differentiate those tools from heavier multi purpose tools like Borland SilkTest, HP QuickTest (formerly Mercury) or Visual Studio Team System Test Edition.

Following from the characteristic of hose tools is the fact, that they are rather developer focused. They approach functional web testing from the unit-testing perspective and strive to be as close to the existing programming artifacts (the tools have a programming API, tests are written as code, tests should be runnable as part of the normal build, no special management tools are necessary ...)

The current situation around this type of tools is quite entangled, some tools are extending or complementing others, some are competitors and new ones are sprouting out of others...

The following post tries to get some order and structure in the landscape of those Agile Web Testing Tools.

The first imortant distinction is between out-of-browser (headless browser) and browser automation tools.

• Out-of-browser tools do not run the test against a real browser but use some kind of browser-simulation/emulation. This simulation/emulation can usually be run in-process, embedded inside an automated test.
• Browser automation tools drive a real browser to access the application under test.

The browser automation tools then can be divided between browser-remoting tools and in-browser tools.

• A browser remoting test-driver controls the browser from the outside through some programmatic API.
• An in-browser test-driver is a test execution runtime that runs inside the browser (usually as JavaScript). This runtime then accesses the application under test from within the browser.

Some confusion is currently created by a third kind of tools. These tools are wrappers or abstractions over concrete test-drivers. They try to give a common programming model for automated functional web tests. This way the same tests should be runnable on a headless browser or on a browser automation driver.


Headles browsers:

HtmlUnit (Java)
HtmlUnit is a headless browser that runs in in memory and is implemented in Java. HtmlUnit is the base for a lot of other libraries/tools.
HtmlUnit itself uses Apache HttpClient, a library for from Apache.
HtmlUnit includes Rhino as JavaScript runtime. Unfortunately Rhino is not used in any browser, so if you test JavaScript using HtmlUnit the results may differ significantly from those browsers.

There are attempts to run a IKVM-ported version of HtmlUnit under .NET:

• See this blog post by SteveSanderson
• There is the watin-html project 

HttpUnit (Java)
An alternative to HtmlUnit, but the last release is from 2008. This project seems to be dead.

Webrat (Ruby)
A browser simulation for testing ruby web applications. Primarily used for testing Rails, Merb or Sinatra applications.
Because Webrat is a browser simulation, it is faster than in-browser testing solutions. The drawback is, that it does not handle JavaScript at all.
Webrat also can be configured to run on top of Selenium. In Selenium mode the tests are run with selenium against a real browser, but the same webrat API can be used as in the browser simulation mode.
In Selenium mode Webrat takes care of running the java selenium server.
Webrat is wildely used in combination with the Ruby testing libraries Cucumber and RSpec.

Rack-Test (Ruby)
A library that mocks http-request for Rack applications. Rack-Test is usually used in combination with Ruby web framworks like Rails, Merb or Sinatra.

JSFUnit (Java)
JSFUnit is a test framework for JSF applications. It is designed to allow complete integration testing and unit testing of JSF applications using a simplified API.
JSFUnit tests run inside the container. They have to be packaged and deployed with your application.
JSFUnit is built on top of Cactus (a java in-container testing framework)



Browser Automation Tools

Watir(including FireWatir and SafariWatir) (Ruby)
Watir is a driver for IE, Firefox, and Safari. Watir runns on Windows, Mac and Linux. Obviously IE and Safari are only available on Windows respectively Mac.
The IE and Firefox drivers are stable.
Technically IE is driven thorough the COM-Interop. Firefox is driven through a Firefox-Plugin.
The Safari driver is experimental.

Watij - WebSpec (Java)
Watij was Initially a port of Watir to Java.
It seems to have become a project of its own. The latest release is called WebSpec and features a new and unique API.
Implemented in Java it runs on Windows, Mac and Linux and supports remoting of IE, Mozilla and Safari.
There is also a JRuby API for it.

WatiN (.NET)
WatiN is a port of Watir to .NET. Implemented in .NET it offers a browser automation API.
It runs on Windows and supports remoting of IE.
The newest release also supports remoting of Firefox through a Firefos plugin.
Latest release is from December 2009, which is a bit scary...

Selenium (Standalone, Integrating with Java, .NET, Ruby and more)
Selenium is a very sophisticated web-testing solution.
It is an in-browser test driver. It automates the browser to run the test steps. This automation is run from within the browser itself. The runtime for automating the browser is actually a JavaScript library that is loaded  into the browser. This runtime then automates the browser interactions which are executed in another frame or window.
On the client the Selenium-RC-Server (remote control) is responsible for controlling the in-browser runtime. The Selenium-RC-Server is is implemented in Java. So to run the server, you need Java installed.
Finally your tests written in any supported platform (Java, .NET, Ruby ...) are interacting with the Selenium-RC server.
Selenium supports automating all major Browsers (IE, Firefox, Chrome, Safari, Opera, Konqueror and more). Since the runtime is executed in the browser, JavaScript has to be enabled.
Selenium is very powerful. However it comes with a certain complexity and fragility since you depend on the correct interactions of several involved components.
Selenium also comes with SeleniumIDE, a Firefox Plugin to record interactions with the browser. Note: The interactions recorded in Firefox can also be run against other browsers later.
Another component is Selenium Grid, an infrastructure which enables to run Selenium tests on multiple servers against different browsers in parallel.

Canoo WebTest (Standalone, Java, Groovy)
Canoo WebTest is a free open source tool for automated testing of web applications in a very effective way.
WebTest is built on top of HtmlUnit. Tha means it is an out-of-browser testing tool.
Since it is not an in-browser testing-tool, you cannot be sure that the browser is behaving exactly the same, but HtmlUnit is very mature and has reliable JavaScript support.
Test steps can be written in xml or in Groovy. Those steps then can be easily combined to test scripts. Almost no programming skills are required.
Canoo Web Test integrates with Ant and can be run as standalone tool.
Very nice reports out of the box. If a test is failing you get a screenshot of the last page where the failure occured.
You need Java installed.
Here is a good comparison between Canoo Web Test and Selenium.

CodedUI (.NET)
Visual Studio 2010 comes with CodedUI.
With CodedUI you can create tests that automate the browser.
All the tutorials show how to use CodedUI with a Recorder and with Visual Studio TestManager.
But behind the scenes CodedUI seems to be a purely programmatic API: the recorder generates C# code (although not very readable).
But theoretically the programatic API of CodedUI can be used to write UI-automatin tests from scratch. However I think an abstraction layer on top of CodedUI would be needed to write those tests effectively.

Lightweight Test Automation Framework (.NET)
For an introduction see this blog-post by Steve Sanderson.
The Lightweight Test Automation Framework is a framework to test ASP.NET applications. It works with WebForms and MVC).
Tests are written in any .NET language, deployed alongside with your application and then run in the browser.
Since test execution is started through the web-interface, running the tests in a automated build is a bit tricky.


Windmill (Standalone, Python)
Windmill is a web testing tool designed to let you painlessly automate and debug your web application.



Wrappers / Abstractions:

Celerity(JRuby)
Celerity is a JRuby wrapper around HtmlUnit.

Culerity (Ruby):
Culerity integrate celerity and cucumber running on ruby
Culerity is a wrapper around Celerity to allow it to be called from MRI
You need to have JRuby installed.

Capybara
Capybara is a DSL for interacting with a webapplication. It is agnostic about the driver running your tests and currently comes bundled with rack-test, Culerity, Celerity and Selenium support built in.
Capybara provides a common API (the DSL) that is then run either on rack-test, Culerity, Celerity or Selenium. The newest addition is a driver that runs on env.js, a JavaScript environment, that runs out of the browser.
It seems to become the de facto choice in combination with Cucumber, replacing Webrat.

WebDriver / Selenium2 (Java)
For an explanation what the relationship between WebDriver and Selenium2 see the Selenium documentation.
WebDriver is another wrapper around other web-testing frameworks that provides a consistent API how to interact with web applications.
WebDriver has been merged with Selenium 2. The resulting situation is not very clear yet...
The project seems promising but is still very much under development.
WebDriver currently provides four different driver implementation: HtmlUnitDriver for out-of-browser testing, FireFoxDriver, InternetExplorerDriver and ChromeDriver for the respective browsers.
WebDriver is mainly a Java project, however a .NET version exists, however it is not very clear which features are supported in .NET.


JWebUnit (Java)
Wrapper around HtmlUnit and Selenium, providing a unified Java API. In this regard the same goal as WebDriver.

Watir-Webdriver
This is watir sitting on top of webdriver. This allows you to use the Watir-API and control any browser that is supported by WebDriver.

Tellurium (Groovy)
Tellurium is a UI module-based automated testing framework for web applications. The approach it takes is to describe the UI declaratively in modules and then formulate test steps against those modules. When the web-site changes you only have to update the modules, not the steps.

MVCContib (.NET)
The MVCContrib projects contains some abstractions over WatiN for testing ASP.NET MVC applications.
These are helpers in MvcContrib.TestHelper.Ui and WatinDriver.
However the documentation of those helpers is poor. The best place is to look at the CodeCampServer project and Chapter 20 in the book ASP.Net MVC 2 in Action.



Other libraries (for homebrew web-testing):

Mechanize
The Mechanize library is used for automating interaction with websites.

Nokogiri
An HTML, XML, SAX, & Reader parser with the ability to search documents via XPath or CSS3 selectors.
Implemented in Ruby.
Usually you don't use Nokogiri directly in your automated web-tests. However this library is used by a lot of the higher level Ruby web-testing libraries mentioned here.

hpricot
Hpricot is a library with a Ruby-API for parsing HTML. It is written in C and therefore very swift.
Hpricot is an alternative to Nokogiri.
As with Nokogiri you don't usually use Hpricot directly in your automated web-tests. However this library is used by someof the higher level Ruby web-testing libraries mentioned here.


I would be interested in your experiences with web testing tools. Do you know other tools that fit the characteristics of  "Agile Web Testing Tools"?

follow me on twitter, I need some friends :-)

Quotes of the Week: Writing Software

We value code that is easy to maintain over code that is easy to write.

- Growing Object
Oriented Software

 

There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies.

- Tony Hoare

Git Quick Tip: Bash completion

Git comes with a script that provides tab-completion for the bash shell.

The script is called git-completion.bash and should be in your git installation directory under contrib/completion/.

On my OS X/MacPort installation of Git it is here: /opt/local/share/doc/git-core/contrib/completion/git-completion.bash

Just include this script in your bash environment with the following line added to your ~/.profile:

source /opt/local/share/doc/git-core/contrib/completion/git-completion.bash

Have fun with Git!

Things that can't be solved by any programming methodology

Below is a great quote from the thread What can't be solved by TDD? on StackOverflow. It is true to any programming methodology, technique or tool.

In my opinion this perfectly highlights what the real problems are in most software projects today (at least in my 10 years experience as a developer/contractor). But usually those are not the problems teams are trying to solve.

 

There are a number of things it can't solve:

1. Can't address poor or incomplete requirements.
2. Can't work as a silver bullet for unrealistic project deadlines.
3. Can't fix poor architecture choices.
4. Can't guarantee a robust development environment, it's only a technique.
5. Won't solve writers/coders block. You'll get stuck on what test to write next.
6. Doesn't fix a poor understanding of the problem domain. It will, however, show that the person doesn't know what to test to someone who is knowledgeable.
7. Won't show you the answer to what algorithm is the "best" to use.
8. Isn't a guarantee that you can push to production from development. It has to go to test unless you're willing to accept the possibility of bugs.

That's all I can think of. About the only way around the things that TDD doesn't address is to have a competent, team-oriented group who want to make good software rather than clocking in/out from 9 to 5.

follow me on twitter, I need some friends :-)

Acceptance- vs. Integration-Tests

One of the funny things as a consultant in the IT industry is, that you see that everybody is fighting with the same questions and problems.
One of those discussions I encounter everywhere is: How many representations of an entity are needed to get data from the DB to the client (sending domain objects to the client? using DTOs? Are mapped classes the domain model? ...)

Another famous discussion is the classifications of automated tests: What are unit-tests, what are integration-tests, what is the difference to end-to-end tests? What are acceptance-tests? What do we need? What is the responsibility of the developers, where do the testers come in? What kind of tests do we write first?

A recent instance of this discussion has popped up on Ted Neward's Blog: Integration testing and unit testing.
Based on the Agile Testing Quadrants I drew a diagram, that explains my understanding of the classification of unit-, integration-, end-to-end tests and acceptance tests:


Unit-, integration- and end-to-end are a classification concerning the scope/granularity of the test. It described how "large" the unit under test is.

Acceptance is a classification that is orthogonal to the scope/granularity of a test. It describes the fact, that the test gives relevant feedback about the specified functionality of the system.
Acceptance tests can be set on on different levels of granularity. This means an acceptance test can be a unit-, integration or end-to-end test.
For instance the implementation of a core calculation logic in an insurance application can be tested on unit level. For this core business logic this can be an acceptance test.

Acceptance tests are usually accessible for the stakeholders in some form. This can be achieved by binding a business readable specification to the test, or by printing a business readable test-trace (see BDD tools: business readable input vs. business readable output).

In real projects acceptance test usually tend to be on the end-to-end scope. In most cases it is necessary to exercises a lot of components to get a reliable impression about a certain functionality of a system.
However if possible, we should prefer smaller scopes also for acceptance tests, since smaller tests are faster, provide more specific feedback, are more stable and better understandable. If we get valuable feedback concerning acceptance from a test on unit scope, we should be happy.

As in many scenarios, trust is the key: If all your acceptance tests are green and the system does not work anyway. This is an argument to go for full end-to-end testing for acceptance tests.

follow me on twitter, I need some friends :-)

An alle Kunden von Cablecom Schweiz: Finger weg vom neuen HD Mediabox Recorder!

Usually I don't blog about non-IT related topics. But I just could not keep quiet about my disappointment with the HD mediabox recorder from Cablecom Switzerland...

Kurzfassung: Die Cablecom HD Mediabox Recorder ist ein immenser Rückschritt im Vergleich zum Vorgänger Cablecom Digital TV Recorder! Das Produkt als Upgrade zu deklarieren ist eine Frechheit. Ich rate allen Cablecom Kunden, welche noch einen "alten" Cablecom Digital TV Receiver benutzen, nicht zu wechseln und darauf zu achten, dass sie nicht ungewollt von Cablecom "upgegraded" werden.

Ich beziehe Telefon, Internet und digitales Fernsehen von Cablecom. Bis vor zwei Monaten war ich ein glücklicher Kunde. Ich war sehr zufrieden mit dem Cablecom Digital TV Recorder:

Vor zwei Monaten habe ich bei Cablecom angefragt, ob ich in das Vergünstigungsprogramm "3 für 2" wechseln kann: Die drei Produkte Fernsehen, Internet und Telefon beziehen und nur zwei bezahlen. Tönt gut. Da ich ja schon alle Produkte beziehe, sollte das ja auch kein Problem sein ... dachte ich ... leider kam es anders.

Ein paar Tage nach meiner telefonischen Anfrage bekam ich ein grosses Paket von der Cablecom. Darin befand sich ein neues Modem und ein neuer HD Mediabox Recorder:

Hmm, das hatte ich nicht bestellt... aber eigentlich egal ...

Nur leider ist der neue HD Mediabox Recorder eine völlige Katastrophe im vergleich zum alten Digital TV Recorder.
Hier die mühsamsten Nachteile im Vergleich:

• Anzeigen des TV-Guides dauert ca. 10 Sekunden, während der Zeit wird das laufende Programm nicht angezeigt, weder Ton noch Bild. Faktisch macht das den TV-Guide unbenutzbar! Beim alten Gerät wurde der TV-Guide sofort angezeigt und das laufende Programm hat nicht im geringsten gestockt.
• Es können keine eigenen Senderlisten definiert werden! Das ist besonders mühsam. Die Reiehnfolge der Kanäle kann nicht meiner Vorliebe angepasst werden. Ausserdem werden im TV-Guide immer alle Sender angezeigt inkl. Sender, welche man gar nicht anschauen kann, weil sie in einem Aufpreis-Paket sind (d.h wenn ich das Programm französischen Schweiz anschauen will, muss ich mich immer zuerst an den ganzen Porno-Kanälen vorbei-pagen :-)). Das alte Gerät erlaubte das freie Zusammenstellen und Anordnen mehrere Kanal-Listen.
• Wenn zwei Aufnahmen gleichzeitig laufen, so kann man keine bereits vorhandene Aufnahme von der Harddisk abspielen. Beim alten Gerät war das kein Problem.
• Das neue Gerät zeigt weniger EPG-Daten an: Jahr und Schauspieler werden nicht angezeigt. Das alte Gerät hat diese Daten angezeigt.
• Das neue Gerät ist lauter und wird wird heisser als das alte Gerät.
• Das neue Gerät gibt ab und zu kein Bild-Signal mehr aus. Die einzige Hilfe ist es vom Strom zu trennen und wieder anzuschliessen.

Dem gegenüber hat das neue Gerät nur einen einzigen Vorteil:

• HD Sender können empfangen werden.

Zu Beginn waren mir die immensen Nachteile der neuen Mediabox egal. Ich hatte ja noch die alte Box und benutzte weiterhin diese. Aber nach etwa einem Monat wurde jedoch die alte Box (resp. die Empfängerkarte) leider deaktiviert ...

Telefonische Anfrage bei Cablecom ergab, dass ich nicht mehr auf die alte Box zurückwechseln kann, da dieses Produkt nicht mehr angeboten werde. Ausserdem war mein Wechsel in das "3 für 2"-Angebot einem neuen Vertragsabschluss gleichzusetzten, so dass meine Kündigung erst in einem Jahr wieder möglich ist. Bei meiner telefonischen Wechsel-Anfrage wurde dies nie erwähnt, ich frage mich ob dies rechtlich haltbar ist ... allerdings ist der Wechsel auch dann sehr mühsam ...

Mein Rat an alle glücklichen Benutzer eines "alten" Cablecom Digital TV Recorder: Nicht auf die HD Mediabox upgraden! Die HD-Kanäle sind es nicht wert! Fernsehen macht einfach weniger Spass mit der neuen Box. Und gebt gut acht, dass Cabelcom euch nicht zwangs-upgraded!

Und ich bin nicht der einzige der enttäuscht ist:
http://www.digi-tv.ch/cablecom/5533-der-cisco-hd-mediabox-recorder-thread.html

http://www.hifi-forum.de/viewthread-160-2166-2.html

http://www.englishforum.ch/tv-internet-telephone/74362-cablecom-hd-mediabox-total-rubbish-3.html

Quotes of the Week: Business Assumptions

The reason why business people use the word 'risk' is because they don't want to use the word 'fear'.

- Dan North, Keynote Oredev

 

Corporate Ping-Pong [...] it is driven by the wrong believe that working in batches and specialized silos makes us more efficient. 100% workload equals to 100% productivity. This is plainly wrong.

- Ralph Jocham, Things ought to be simple

 

BDD – Catching On, Moving On?

Lately there seems to be more and more discussion about how to do effective BDD. Examples:

• Imperative vs. Declarative Scenarios (Ben Mabey)
• The Truth about BDD (Uncle Bob)
• You're Cuking It Wrong (Elabs blog)
• You’re almost cuking it… (Antony Marcano)
• Refactoring Given/When/Then (David Peterson)
• Let’s change the tune (Gojko Adzic)

This is an interesting tendency. BDD as a concept seems to become accepted, the topics are not “What is BDD?”, “Why BDD?“ or “Which Tool to use for BDD?” but “How to do BDD more effectively?”.

Does this mean BDD is catching on? … or is this just my ego-centric projection as I get deeper into the topic?

If you are interested in learning more about how to apply BDD successfully, watch out for Gojkos next book: Specification By Example.

follow me on twitter, I need some friends :-)

Presentation Patterns: MVC vs. MVP (once again)

Presentation Patterns are one of my classical examples how unsophisticated we still are in our industry. MVC, MVP, PresentationModel, M-V-VM... everybody is supposedly using them but everybody has another concept how those patterns are realized.

This is like the different revolutionary groups in Life of Brian: Judean People's Front, People's Front of Judea, Popular Front of Judea ... they all look the same, they all have the same purpose, sometimes they are even the same people ... but the difference is still more important than everything else!

I blogged about this before: The same but different and Sophisticated Vocabulary: MVC

Today in the .Net web world there is basically ASP.NET Webforms and ASP.NET MVC.

ASP.NET MVC is a clean and opinionated implementation of the MVC pattern.

ASP.NET Webforms does not really imply a presentation pattern. Some people are claiming to do MVC with it, but basically Webforms leave you unguided (if not impeded) with realizing your separation of concerns.

However there is the Web Forms MVP project that presents a Webforms based framework realizing the MVP pattern.

Now we are back to the question what is the difference between MVC and MVP?

In Hansleminutes #202 Tatham Oddie, one of the creators of Web Forms MVP gives a simple explanation for web scenarios:

In MVC the request is handled first by the controller, which then consults/delegates to the model and the view.
In TekPub's ASP.NET 4 series this is called Controller First Execution:

In MVP the request is first going through the view, which signals events/actions that are handled by the presenter. The presenter then consults/delegates to the model:

Back when I was programming Java, I had numerous disputes whether JSF is MVC or not. Now when we look at the above definition, JSF is clearly MVP.
It is often claimed that JSF is MVC, because it is based on Servlets, which were initially a technical realization of MVC (that would mean that any relevant Java based web framework would be MVC).
But in my opinion JSF is clearly not MVC, because in the JSF programming model there is no controller artifact exposed.

follow me on twitter, I need some friends :-)

Quotes of the Week: Overtime

Working weekends to save a project is like torturing people to save a country. As soon as you do it, there's so much less worth saving.

- lunivore on twitter 

Time does not magically convert to work.

- Rework

Workaholics are not heroes. They don't save the day, they just use it up.

- Rework

On TechTalks Mind: New Podcast Episode

Check out our new podcast episode. This time Claudia talks with Willy about requirements gathering in Scrum projects. This is a german episode.

Visit "On TechTalks Mind" or subscribe in iTunes.

follow me on twitter, I need some friends :-)

 

Cassandra Syndrome: Knowing that failure is inevitable, but nobody is listening

Cassandra's doom was to predict what others refused to believe.
While Cassandra foresaw the destruction of Troy, she was unable to do anything to forestall these tragedies since no one believed her.

[Wikipedia]

In death-march projects the developers are often suffering from the cassandra syndrome: They know that the project is doomed to fail, but they gave up on trying to change anything long ago.

In several big enterprise projects I have been in, developers just stopped caring, they gave up on craftmaship.

This is the typical No pigs, just chicken antipattern. The courageous pigs left, the coward pigs broke, the chicken remained ...

A typical pattern for dysfunctional projects I have come across is that there are several layers of hierarchies between the stakeholders of the project and the developers.
These intermediate layers have absolutely no interest in communicating any problems to the stakeholders above. And the stakeholders are completely content with being lulled in the comfort of getting smilies or green traffic lights in their high-level status meetings.
Usually at the point when the smilies stop smiling or the traffic lights get yellow it is too late. The project has gone completely off track and is doomed to fail badly...

Recently I came across another name for this symptom:

The Green Effect:
The higher a status-report goes in the organzational hierarchy the greener it becomes.

The following Dilbert strip illustrates this brilliantly:

When I voiced my Cassandra analogy on twitter, Scott Ambler replied to me:

@jbandi if developers learn to communicate effectively with the business they don't need to be Cassandras

- Scott Ambler, on twitter

Well, in my experience it's not that simple. I consider me as a developer that can communicate (more or less) effectively with the business. But I find me repeatedly on projects where there is absolutely no process established for effective communication between the developers in the trenches and the stakeholders. And establishing such a process is not feasible because of several organizational layers between the trenches and the stakeholders.

follow me on twitter, I need some friends :-)

Quotes of the Week

If you build software from diagrams, it will likely follow good diagramming principles, but rarely follows good software principles.

- ampgt on twitter 

Nothing makes a software system more flexible than a suite of tests. By an order of magnitude more than good architecture and design.

- Uncle Bob, QCon 2010