Subscribe to my feed if you haven’t done so yet. The feed is powered by FeedBurner and should remain stable.

My session was titled “REST: you’re doing it wrong” or “REST, du machst das falsch” in German. It was a significantly revised version of the talk I gave at NRWConf 2011 in Wuppertal. This time I enhanced the story a little bit as well as overhauled the whole presentation. I used imress.js framework to create an HTML5 presentation to be shown in browser – no special slideware needed. I very much like the result, though I gathered somewhat mixed experience achieving it. It was particularly troublesome to arrange all the presentation steps on the canvas while working in pixel units. Maybe some layout plugin or template language would help. The presentation also doesn’t work well in all browsers. From the presenter’s standpoint it ok: it works smoothly in Safari on a Mac, but for publishing online it’s a major drawback: Chrome on a Mac has performance and rendering issues while current stable Firefox is not supported altogether. Anyway these issues will be ironed out sooner or later and I’ll probably stay away of any PowerPoint-inspired slideware from now on.

I started the talk with the ironic tale of the ice-cream maker written by Sebastien Lambla. After that I continued with fundamental architectural decisions made by the creators of the Web and upon which REST as an architectural style is based.

Then I moved to common misinterpretation of REST, like claiming that not using SOAP or using JSON for serialization is already RESTful. After that I introduced Richardson REST Maturity Model and started moving the story towards a RESTful system.

First, I talked about resources and their identifiers. It was also important to mention the distinction between resources and representations. It was then obvious that using URI is inappropriate way of specifying a representation (like the API version or language being part of the URI).

I then mentioned the importance of understanding HTTP mechanisms and assumptions it makes against different methods. The most common pitfall in RESTful systems design is from my perspective to stop on that stage and build a CRUD (Create Read Update Delete) service. Though CRUD certainly has its application domain, nonetheless it’s inappropriate for most of the business systems, as the application logic remains outside of the application – like an Excel spreadsheet, where the user just edits raw data instead of fulfilling business tasks.

The natural step from a system designed out of HTTP methods is a system designed out of resources, where each business task is a resource. This is almost the same principle we use for ages building web applications. Such a system can leverage well-known mechanics of hyperlinks and forms to provide a truly RESTful API.

The HTML5 presentation is available on GitHub pages. You can also be interested in the previous PowerPoint version with speaker notes over at Slideshare.

Update: There is also a ~5.8 megapixel poster of the overview slide in PNG format if the impress.js version doesn’t happen to work for you.

31.08.2011—.NET Coding Dojo at DNUGRR

As a good tradition every other month .NET User Group Rhine/Ruhr organizes a coding dojo in Ratingen. This time we get more interactive and learn TDD as if you meant it altogether in pairs. If you are around and want to join us, you’re welcome!

1–3.09.2011—Software Craftsmanship and Testing

New European software craftsmanship community is emerging and I’m very glad to participate in this two day-long intense community fusion:

This event is about the sustainable creation of useful software in a responsible way.

It consists of two days of highly collaborative interactions, including Lightning Talks (on Thursday evening), scheduled sessions (on Friday), and a self-organized Open Space (on Saturday).

The event will be much like a retreat. We will be there for 48 hours to collaborate and share ideas.

I will present practical experience with Specification by Example, I gathered working with an agile team back in 2010. Gojko Adzic has written THE book about Specification by Example, which I highly recommend. Want to discuss this topic? Register for SoCraTes 2011!

9.9.2011—NRWConf in Wuppertal

It is a great honor for me to be part of this year’s line up of speakers at NRWConf. My session on REST is focused on why is true REST so much different than WS-* and CRUD POX services. Want to avoid common mistakes and leverage the web platform, join me in Wuppertal.

16.09.2011—Professional .NET in Wien

Austrian .NET community hijacked Greg Young for a day to speak about all things CQRS. I just can’t miss such an opportunity to see hilarious Greg speaking, neither should you! As part of the event I will be speaking about NOSQL and why it is becoming even more attractive for separated read and write data models.

2-3.11.2011—prio.conference 2011 in Nuremberg

This year’s prio.conference is focused on cross-platform development and I think that the web platform is currently the closest realization of that vision. That’s why I was so excited, that my talk proposal about “getting REST done right” was accepted. In contrast to my NRWConf REST talk, this one is focused more on concrete examples of how to get things done following the REST way, rather than pointing at failures and pitfalls.

So, next months are going to be tough, but I look forward to meet bunch of interesting people and be inspired and energized by the community!

Yesterday I had a great opportunity to participate in a very enlightening and thought-provoking activity, named Code Retreat, in Düsseldorf! It was smoothly conducted by Daniel Temme and Adrian Bolboaca and hosted by codecentric AG. The idea of the code retreat is very simple: use TDD and Pair Programming technics to automate Conway’s Game of Life in sessions of 45 minutes …but delete all of your code after each session!

What?! Delete code?! But how am I supposed to get the job done?

The point is not to get something done, but to exercise the technics of test-first development and simple design. This looks silly and pointless at first and is indeed really hard.

But it all look pretty simple at first. In the first session my pair and I haven’t even come to the game rules. We started with some examples, that we represented as strings. Then we were writing a parser, that would take string representation of the game grid and provide a two-dimensional array with Boolean flags, indicating life, so that we could feed our examples into the game engine. It seemed a logical top-down approach to me at first, but proved itself meaningless.

After the session we all together discussed any findings and ideas that we got out of the session. Adrian was provoking us with questions like: Why do you need an array? Where this Cell class came from? etc.

So the next session we changed pairs (this is a rule of Code Retreat) and started all over again. This time we focused on game rules, test naming and abstractions, but were still unable to make very small baby steps with our design. Abstractions just spawned out of nowhere (out of our head, actually) and made it right into the code. We discussed it after the session and decided to treat the imaginary design obsession syndrome with a very restrictive diet…

TDD As If You Meant It

Gojko Adzic described this brilliant exercise originally proposed by Keith Braithwaite back in 2009. It’s very simple:

1. write exactly ONE failing test
2. make the test from (1) pass by first writing implementation code IN THE TEST
3. create a new implementation method/function by:
   1. doing extract method on implementation code created as per (2), or
   2. moving implementation code as per (2) into an existing implementation method
4. only ever create new methods IN THE TEST CLASS
5. only ever create implementation classes to provide a destination for extracting a method created as per (4).
6. populate implementation classes by doing move method from a test class into them
7. refactor as required
8. go to (1)

Despite of the simplicity of the rules, it’s very hard to follow them. But it works. Design gets in fact much simpler and it really gets derived from tests.

Conclusion

We did 6 sessions during the day. I programmed 3 times in Java, 2 times in C# and one time in Ruby. Switching languages is great exercise in itself. No matter what language, testing framework or IDE/Editor we used – the most important concern was to understand the problem domain, codify it in tests, and let simple design solve it.

Throwing out code is not only useful as an exercise. I can imagine a Code Retreat workshop as a way to understand a very complex core domain (in DDD sense) in productive development.

After the event I felt exhausted and energized at the same time. I realized that I barely did any TDD before, but I learned where to start and how to proceed my learning. All in all it was the densest coding activity I ever had. Really look forward to participate in another Code Retreat soon and will do my best to organize the next one in Düsseldorf!

Imagine yourself sitting in a racing car having never seen a race and knowing only how to ride a bicycle. Now go on and have fun on a track. Two hours later you already can start the engine and release the handbrake.  Was it fun? Will you come next time to learn how to shift gears? I doubt. Now Imagine somebody took you for a drifty ride. Now it makes sense! Now there is even a point to learn it yourself. The same way I learned to love coding katas: by watching masters (like this one) doing them.

I choose a modified version of the String Calculator Kata: instead of just adding numbers joined to a string, I aimed to implement an arithmetic expression evaluator (“1 + 2” –> 3). My tools for this kata included VS2010, C#, Resharper, xunit.net as testing framework, and Should as a fluent assertions library.

The thing I like most about TDD is that the whole software design emerges out of a consequence of simple decisions. Each design is unique and none is the right one. You can follow my implementation on Github, I’ll just list here most noticeable steps:

The first feature was to evaluate a decimal constant. The simple “double.Parse(expression)” method did the trick.

The next one was a simple addition. The “string.Split(‘+’)” is obvious to extract the arguments of addition, the next step is however that same little design decision that defined the whole solution. Instead of manually juggling array indices I used my favorite .NET API – Linq. So, to add the arguments from a string array I wrote the following:

return expression
    .Split('+')
    .Select(x => double.Parse(x))
    .Aggregate((a, b) => a + b);

Now implementing multiplication was analogous. The resulting code duplication was an obvious smell though. I always forget those fancy functional slang, but the point was to effectively build a pipeline of functions, where each function is applied to the result of the next one in the pipeline. Then the only thing to do is to call that pipeline as a function and pass it the original string expression. The whole solution looks like this:

public class Calculator

{

    private static readonly Func<string, double> Parse = double.Parse;

    private static readonly Func<string, double> Pipeline = Parse

        .Wrap(‘*’, (a, b) => a*b)

        .Wrap(‘/’, (a, b) => a/b)

        .Wrap(‘+’, (a, b) => a + b)

        .Wrap(‘-’, (a, b) => a – b)

        ;

    public double Evaluate(string expression)

    {

        return Pipeline(expression);

    }

}

public static class PipelineExtensions

{

    public static Func<string, double> Wrap(

        this Func<string, double> inner,

        char split,

        Func<double, double, double> aggregate)

    {

        return expression => expression

            .Split(split)

            .Select(inner)

            .Aggregate(aggregate);

    }

}

It definitely doesn’t take parenthesis into account, but it quite elegantly solves four arithmetic operations with operator precedence and more than two arguments and more than one operator per expression. Without using Linq I would probably go with a bunch of if/else statements being than refactored into an expression parser and an expression tree evaluator (which is a way to go for supporting parenthesis). Anyway for the first iteration I implemented all the features I wanted and ended up with very little code, which I don’t mind to throw away if it doesn’t fit anymore. And this is a true virtue of TDD.

The next Coding Dojo at the User Group Rhine/Ruhr will be on 27th April, hosted by MT AG in Ratingen. Follow announcements of the UG or sign up at Xing.

Others confronted with the same problem gave up by writing a public wrapper class exposing a public Key property, binding-ready. Although that solution worked I felt wrong polluting all the queries in my view model because of Silverlight data binding limitations. Another interesting approach proposed by Christopher Bennage on Stack Overflow used a Value Converter to get the Key property of a grouping. Now it looked much better in terms of separation of concerns, but the converter was hard-coded to work with IGrouping<string, MyDomainClass> only. Remember? No cross-assembly private reflection.

I tried to tweak the converter approach with no luck:

• LINQ expression tree code generation didn’t work without Reflection.Emit.
• Casting to IGrouping<object, object> didn’t work without co-/contra-variance in WP7

So after pulling some hair out of my head I found a rather simple solution. The Key property on the interface itself is obviously public. It is indeed possible to use reflection to get the property value if only you use a PropertyInfo from the interface, not from the implementing type.

The resulting universal value converter looks like this:

public class ExplicitPropertyConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value == null ? null : GetPropertyValue(value, (string)parameter);
    }

    private static object GetPropertyValue(object target, string name)
    {
        return (
                from type in target.GetType().GetInterfaces()
                from prop in type.GetProperties()
                where prop.Name == name && prop.CanRead
                select prop.GetValue(target, new object[0])
            ).FirstOrDefault();
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

And the usage from XAML is like this:

<TextBlock
    Text="{Binding
        Converter={StaticResource ExplicitPropertyConverter},
        ConverterParameter=Key
    }"
    />

This is almost the right way from my perspective (the right way would if data binding in Silverlight just worked, but it’s not what Microsoft developers are accustomed to anyway). The converter itself is implemented as a cross-cutting concern, being able to bind any interface property. The only notion of this workaround is in XAML data binding, where it belongs. Of course I wish Silverlight, and especially WP7, was a real thing and not that creepy lame castrated shade of .NET, standing in my way to be more productive. Rant over…

And here comes Heroku. Heroku is a ruby hosting platform in the cloud, which is free for small demands and feature rich, rock-solid and scalable when you need it. So I decided to build and host at Heroku an absolutely dumb HTTP Ruby application that should redirect all the requests to my blog at WP. Thanks Heroku Custom Domains I was able to host my small dumb app for free with my custom domains (shishkin.org and www.shishkin.org).

The application itself is a simplest Rack application:

class Redirect
  def call(env)
    [301, {
      "Location" => "http://shishkin.wordpress.com",
      "Content-Type" => "text/plain"
    },
    ""]
  end
end

run Redirect.new

That’s it! Using simple Heroku documentation I was able to build, test and deploy my little app in minutes. Heroku’s git-based deployment is somewhat cool. It just can’t be simpler given that each Ruby developer probably has git installed already.

As for Rack, I think it’s an awesome framework we really miss in .NET. After being intrigued by Rack’s ultimate simplicity and extensibility I watched TekPub’s episode on Rack and started to watch the Sinatra series. Now I’m intrigued even more  Rob Conery does a great job of getting .NET developers out of their comfort zone and provoking us by showing how simple software development can really be on the other side of the fence.

To summarize, I finally did something productive with Ruby! I solved my real-world problem (not that big for sure), I solved it simple, fast and elegant. And I learned a lot along the way.

Save the date! On Thursday, November 25, 2010 in Düsseldorf Open Space CloudCamp un-conference is taking place. The main theme of the event is Cloud Computing as you may guess And the Open Space format guarantees a lot of fun! The camp starts at 13:00 and will be kindly hosted by employer – MT AG in Ratingen (map). Thanks to MT AG the event is completely free for attendees.

The agenda is not carved in stone yet, but will be something like this:
13:00 Registration, networking
13:30-18:00 TBD (Keynote, lightning talks, open space sessions)
18:00 Networking

So, if you are near Düsseldorf on November, 25 and are interested in Cloud Computing (no matter which vendor or technology you prefer), I really don’t understand why still aren’t you on the attendee list?! An Open Space event is only successful if enough passionate people attend it, please help us make Cloud Camp a success. Register at http://cloudcamp.org/dusseldorf.

And we are waiting for your lightning talk proposals. Mail me: sergey.shishkin [ at ] mt-ag.com.

Update [22.11.2010]: CloudCamp Düsseldorf is postponed to undefined date due to the lack of registrations. Sorry.

Envy me, I spent last weekend in Karlsruhe with some of Germany’s smartest and most passionate .NET developers. Big thanks for that to organizers of the .NET Open Space Süd and all the participants. I feel inspired and am full of ideas again.

The anti-conference started for me with a great functional programming session with @sforkmann introducing Monads. The topic was so great that immediately after the session many attendees started implementing the Maybe monad in C#. And monads accompanied us all the weekend in all sort of jokes

Functional programming continued with a session on Reactive Extensions, where I introduced the framework as a new way of doing .NET events and async programming. After that @sforkmann supported the topic with JavaScript samples and an introduction of IQbservable followed by a great discussion.

Two sessions were focused on software specifications, BDD, and ATDD. I was representing ATDD and FitNesse camp, however to be more effective I should bring more hands-on examples to break through code-centric developer heads Anyways, the “BDD Shootout” session was really inspiring and code-intense. Not a big surprise with people like @agross (MSpec), @sforkmann (NaturalSpec), and @BjoernRochel (XUnit.BDDExtensions).Although the guys were skeptical about a comparison session at first, the session was a real success: win-win-win for all three frameworks

NOS Süd finished with a Coding Dojo facilitated by @ilkerde. After that dojo (my 3rd only) I still have some mixed feelings. I was looking for learning any new design/coding practices but the only major thing I learned was the importance and complexity of selecting members for a development team. After a while it’s not fun anymore to argue about whether we do TDD or BDUF… Still it was very good experience for me, and I think for others who took part. Thank you Ilker!

If Open Space is so great because of the “coffee break”-like experience, imagine the coffee breaks at Open Space! Of course the biggest part of NOS Süd (at least for me) were it’s parties and breaks when I chatted with many bright and passionate folks and it was the most inspiring and enjoyable experience of the weekend!

Another great .NET community event has taken place on last Friday – DotNet Cologne 2010. Big thanks to all the attendees, speakers, sponsors and organizers for making it happen. The event was a huge success. And I even got a chance to speak there about improvements and novelties of Windows Communication Foundation 4.0.

To make it more fun and educating at the same time I decided to do an experiment: use Git–a distributed version control system–in combination with live coding. I took quite a fast coding pace aimed for experienced WCF developers, showing them what’s really new about WCF4. But to make the code samples more accessible for the beginners and to make my coding “traceable” I committed each exercise to a local Git repository right during my presentation and pushed them all in the cloud to GitHub.

A local Git repository makes it really easy to save your coding progress, while code hosting platform in the cloud like GitHub allows you to share and collaborate on your code with others. So now anybody can review the commits history of my live WCF4 demo and easily grasp for example what it takes to call a dynamically discovered service via a generic channel factory.

I liked the experiment myself and also got some positive feedback from the audience regarding the usage of Git. On the downside I ran out of time and had to leave a couple of interesting demos aside, though not because of Git but poor time planning. Lessons learned, promise to improve next time Join me on GitHub. Your feedback is always welcome!

Last time I wrote some GUI code with time dependencies (like refresh data every 10 seconds), I used to extract the timer into an interface with an event and inject that dependency in the presenter/controller/view model. That way the UI logic is kept testable because I can swap the dependency with a test double which triggers the event manually.

Now I think I have a more elegant solution – an Observable from the Reactive Extensions Framework. Take a look at the ViewModel:

Thanks to the generic IObservable<> I can spare an interface. And this is the dependency injection code (no DI-Container in use for simplicity):

The Interval method creates an infinite sequence of events triggered every 10 seconds (line 2). The generated sequence is typed as IObservable<long>, so I need to convert it to a “typeless” IObservale<Unit> in line 3. Unit type comes from functional languages and is supposed to be a typed void. Last thing to do is to tell Rx Framework to raise events on the GUI thread with ObserveOnDispatcher (there is an overloaded ObserveOn method as well). By default events are raised on a thread pool’s thread.

And here is the code to put in a test:

Very simple as well. Subject is a very useful generic class which implements both the IObservable<> and IObserver<>, so you can pass an instance of Subject to a method expecting IObservable<> and then Publish into that sequence thanks to the IObserver<> implementation.

So, if think to write an interface with an event, that you want to pass somewhere as a dependency, think again. Maybe the generic IObservable<> interface will do the trick much simpler. Moreover, client code can leverage the full API of Rx provided through extension methods to IObservable<>, so that the client can for example throttle events or combine them in many different ways. Rx is very powerful.

As the next step I’m thinking of abstracting a clock as IEnumerable<DateTime> instead of writing a custom IClock interface or using a global variable like MyTime.Now or much worse DateTime.Now.

What do you think about time and timer dependencies?

I have already written about a change I was part of last year. Being a coach after two years of product development made me realize what my true passion in software development is. It’s continuous improvement – Kaizen. While being in a product development team you have to measure your pace with the team’s pace and not to run too far ahead for too long – the team should be able to keep up. And you are bound to the technologies of a particular application type – no WPF for a web-service app etc.

After long thoughts I finally decided to go in consulting. WPF wasn’t the main reason, of course I just plan to meet different projects and different teams. This is what should bring me my Kaizen pace, at least in my beliefs. So, since April I’m part of Managing Technology team, looking forward to new projects and new experiences.

And I’m on twitter now

How big is .NET 3.5 runtime? The full redistributable package for x86, x64 and ia64 platforms including 2.0 and 3.0 is about 200 MB. Not a single user needs to download and install it all: somebody already has 2.0 or maybe even 3.0, and nobody is going to install all the supported architectures (x86 etc.) on a single machine. So this huge download is only intended to be distributed on a CD or DVD with applications requiring .NET, when you don’t know in advance what platform you are targeting. If you do know the user’s platform in advance, you can downstrip the package down to some 20-60 MB. Which is pretty good.

Anyways .NET Framework has to be installed using Windows Installer, and it’s a quite invasive way of deploying an application. Can somebody XCOPY-install .NET Framework? I suppose it to be very tricky if possible at all. And we have those copyrights and license agreements saying that Windows Installer is the only legal way to deploy .NET runtime to users.

All this problems might seem illusive, since Microsoft is pushing .NET Framework through Windows Update and starting from Windows XP SP3 and Vista RTM users get at least .NET 2.0 installed. But the e-health market, my company works in, is very conservative (at least in Germany) and users are still running Windows 2000 with windows apps emulating DOS-like GUI. It is horrible! We can not rely on any Windows Updates or even a live and fast internet connection to run the .NET Framework setup bootstrapper. Moreover, our software, a web service, should be deployed as an integrated component into some third party application (almost definitely not a .NET one). And the more complex our deployment story is, the less partners would want to embed our software into their products.

Are there any alternatives out there?

One can turn to virtualization solutions. But instead of hardware virtualization, one can virtualize the .NET runtime. Using Xenocode Postbuild it is possible to compile a managed application into an unmanaged one with embedded fully functioning .NET runtime. The size of an app starts from 11 MB for a simple Hello World App and is from 40 MB in a real world scenario (without deleting unused .NET code, so that reflection can work properly). And this is pretty good, although not cheap.

Here comes Mono

There is also the Mono Project out there, which contains an open source runtime compatible with .NET CLR on binary level. It means that you can run apps compiled for .NET CLR on Mono CLR without recompilation. Mono’s cross-platform nature makes it much simpler in what it means to deploy the runtime. You just have to fulfill the requirements of the LGPL or obtain a commercial license from Novell.

How it works?

So I downloaded and installed the full Mono for Windows package and started to play with it. My aim was to get a minimal subset of Mono to be able to run the Mono’s XSP development web server and its test web site (\lib\xsp\test\).

The result is the following structure of 45 files only 21 MB in size total:

\bin\libglib-2.0-0.dll
\bin\libgthread-2.0-0.dll
\bin\mono.dll
\bin\mono.exe
\bin\run.cmd
\etc\mono\2.0\Browsers
\etc\mono\2.0\DefaultWsdlHelpGenerator.aspx
\etc\mono\2.0\machine.config
\etc\mono\2.0\settings.map
\etc\mono\2.0\web.config
\etc\mono\2.0\Browsers\Compat.browser
\lib\mono\2.0\Accessibility.dll
\lib\mono\2.0\gmcs.exe
\lib\mono\2.0\gmcs.exe.config
\lib\mono\2.0\Mono.Data.Tds.dll
\lib\mono\2.0\Mono.Messaging.dll
\lib\mono\2.0\Mono.Posix.dll
\lib\mono\2.0\Mono.Security.dll
\lib\mono\2.0\Mono.Web.dll
\lib\mono\2.0\Mono.WebBrowser.dll
\lib\mono\2.0\Mono.WebServer2.dll
\lib\mono\2.0\mscorlib.dll
\lib\mono\2.0\System.Configuration.dll
\lib\mono\2.0\System.Configuration.Install.dll
\lib\mono\2.0\System.Core.dll
\lib\mono\2.0\System.Data.dll
\lib\mono\2.0\System.Data.Linq.dll
\lib\mono\2.0\System.dll
\lib\mono\2.0\System.Drawing.dll
\lib\mono\2.0\System.EnterpriseServices.dll
\lib\mono\2.0\System.IdentityModel.dll
\lib\mono\2.0\System.IdentityModel.Selectors.dll
\lib\mono\2.0\System.Messaging.dll
\lib\mono\2.0\System.Runtime.Serialization.dll
\lib\mono\2.0\System.Security.dll
\lib\mono\2.0\System.ServiceModel.dll
\lib\mono\2.0\System.ServiceModel.Web.dll
\lib\mono\2.0\System.Transactions.dll
\lib\mono\2.0\System.Web.dll
\lib\mono\2.0\System.Web.Extensions.dll
\lib\mono\2.0\System.Web.Services.dll
\lib\mono\2.0\System.Windows.Forms.dll
\lib\mono\2.0\System.Xml.dll
\lib\mono\2.0\System.Xml.Linq.dll
\lib\mono\2.0\xsp2.exe

It is still far from perfection (why ASP.NET applications need System.Windows.Forms, for example), but it is a good proof of concept. I’m only a newbie to the whole world of Mono. But now I can start a web site on a windows machine without any .NET Framework installed from a website folder just like this:

..\mono-mini-2.6.1\bin\run.cmd ..\mono-mini-2.6.1\lib\mono\2.0\xsp2.exe –root . –port 8080 –applications /:.

In order to make it repeatable, I made a batch script that creates this Mono-mini package out of a real Mono installation. It can be used like this:

mono-mini.cmd c:\work\ExternalBin\Mono-2.6.1 c:\temp\mono-mini-2.6.1

Summary

I’ve got an XCOPY-deployable .NET runtime for my ASP.NET web services with 3.5 support in under 21 MB (7.5 MB zipped) which works on my machine What now?

• I need to test it thoroughly with the apps I will run on it. It is still possible that some components are missing.
• Also I might remove the Windows Forms dependency but it would require me to patch the machine.config and the global web.config though.
• All this bin\, lib\, etc\ coming from the linux-background of Mono could easily be simplified for the Mono-mini package.
• Some licensing questions are yet to be clarified. When licensed under LGPL, Mono is not allowed to be embedded into a non-LGPL executable, AFAIK. So, making deployment even more simple with Xenocode (only as an assembly repackaging solution) or .NETZ (for the same purpose) is not possible without purchasing the commercial license from Novell.

Friday was a huge day for me! My team officially announced that we a going to implement Scrum. This was by no means an easy change. It took us 9 month and I just want to save this story in my blog for the records.

Why Change?

In April 2009 I was architect in a company using “waterfall” process with 3 month release cycles in a team of 40 people separated in 3 full blown departments of “product management”, “development” and “quality assurance” with its own organizational structures and typical “us against them” mindset. In addition to that there are also technical writers, who have to write all the user manuals on weekends after the code is implemented, and support engineers, who keep distracting developers with all those “urgent customer issues”.

PM was aimed to complete the software specifications before the “spec-freeze” milestone and throw it at DEV over the fence. Specs were long boring documents with faked GUI screenshots and lots of ambiguity. While PMs were writing specs, DEV made housekeeping, fixing bugs or writing code that DEV thought will be useful in future. With a spec at hands DEV coded like crazy to hit the deadline. Then QA started thoroughly comparing the spec with the software and filing found bugs or what QA thought was a bug. Nobody had time to make his or her job right.

After each release we heard the same annoying phrase from our management: “It was the toughest release ever, but we did it!” It supposed to be motivating

After an unfortunate try to present Scrum with all its “pigs” and “chickens” to QA and PM, the word “Scrum” by itself became a taboo…

At that point in spring 2009 I was about to leave, especially seeing some of my colleagues leaving too. But after some management rearrangements in DEV department, I decided to give it a try to facilitate the change to Agile before I leave.

What Changed?

Today we have:

• Sprints, which are 2 weeks long and relative consistent in terms of work committed and work delivered.
• Teams consisting of DEV and QA sitting together in one room (pro team), communicating with each other and helping each other.
• Teams estimate requirements and pull them from the Product Backlog into their Sprint Backlogs during Sprint Planning meetings.
• Teams decide how requirements are going to be implemented.
• Specification is emerging during the Sprint as a joint effort of PM, DEV and QA in form of FitNesse tests.
• Technical writers use Sprint deliverables immediately and have an opportunity to schedule their work accordingly.
• All “urgent customer issues” go first through the Product Owner, who is responsible for prioritizing them and putting into the Product Backlog. If it is really urgent, it goes directly to the Fast Lane on the Task Board to be pulled by a team member.
• A few Certified ScrumMasters and Product Owners.

How?

These are all things that we practice for some time already. Although not everything from the list works frictionless. Nonetheless the “change” on Friday was more like a Scrum training for all teams and an announcement “Oh, by the way, we are actually doing Scrum already”

It was an incredibly hard change, I must say. And it did not come by my will only. It could not happen without support from several people in our company who were willing to listen. Together we did it. But there are still a lot of things to do on the way to Agile. The only thing I know for sure is that there is no way back to the stone age of waterfall process anymore.

I write all this because since then Agile has become my topic of interest and I hope to be writing more on it in future. I stumbled upon many obstacles while bringing agile ideas to different people and it was always fascinating and invaluable experience. Stay tuned

Update: last time I forgot to put the usage example of the ExpectedSequence extension method. Fixed now. See the end of the post.

Previously introduced in Siverlight Toolkit, Microsoft Reactive Extensions (aka Rx) is making its way to be shipped within .NET Framework 4 now. Albert Weinert gave me an opportunity to demonstrate some of my geeky experiments with Rx on the DNUGK meeting yesterday.

The following API comparison between the well-known .NET iterator pattern and the new Rx observer summarizes the intent of Rx: provide API to work with events similar to that of collections, while preserving reactive nature (push-model) of events.

That means that we can do the same set-based operations with events as we already do with collections, e.g. Select, Concat, Join, Where, Merge etc. I must admit at this point that by events I don’t mean .NET events but rather more general occurrences of asynchronous nature, speaking Rx – anything that implements IObservable can be treated as an event and even participate in Linq queries.

To following example will make things more concrete:

The KeySequencer class publishes all the keys that user presses as a sequence of IObservable events via its Keys property. Creating an IObservable is in fact very simple – I use the Subject class from Rx that is an “observable observer”. As an observer it has an OnNext method where I can push keys into, and as an observable it forwards them further to everyone who has subscribed down the line. Note that key events are of type Char. As I said, everything can be an event!

Well, the more interesting part is what we can do with those events published by the KeySequencer. First of all we can subscribe to them:

Now every character will be put out to the console twice – first when it’s pressed and after that when the subscribed Console.WriteLine method has been called. Still not impressive? What about that?:

Here we define four further event sequences (pressed(‘e’), followedBy(‘x), followedBy(‘i’) and followedBy(‘t’)) and combine them into another event sequence (exit) which happens when the user types “exit”, so we can stop listening to keys being pressed and quit the program.

A further logical step could be to generalize the “expected sequence” pattern, of course with Linq in a nicely functional style:

Now I can turn the “exit” sequence into this:

And of course it works same way for any sequences. Just put a string as a parameter for character a sequence (since String implements IEnumerable<char>) or any other IEnumerable<T> for an IObservable<T> event source of your choice.

So, that were just my first steps in a new world of reactive programming with Rx. And I really liked it!

I want to thank everybody who came yesterday to my talk on orthogonal architecture at NRWCONF’09 in Wuppertal. I got useful feedback from several people yesterday and will try to improve this talk in the future.

This 1 hour talk just scratched the surface of agile architecture. Almost every second or so slide in the deck deserves a separate talk. I tried keep the talk concrete though by using code samples depicting the discussed architectural patterns.

For those who wonders what SOLID has to do with orthogonal architecture, look at the slide 10 which says:

Open/Closed Principle

• Open for extension, but closed for modification
• Orthogonal architecture = OCP on the architectural level

It turns out that I had to stress this point better in the talk.

You can view the slides here, but you need to be a registered attendee to download them from the conference website.

Yesterday I did a small demo of NHibernate Profiler at DNUGK in Cologne. Here is the sample code and some links:

• NHProfSamples.zip (2.4 MB)
• NHibernate Profiler builds (build 380 was used in the demo)
• User Guide
• User Voice
• Discussion Group

Thanks again everybody who came yesterday to the UG meeting.

That’s cool:

IObservable<Event<MouseEventArgs>> draggingEvent =
     from mouseLeftDownEvent in control.GetMouseLeftDown()
     from mouseMoveEvent in control.GetMouseMove().Until(control.GetMouseLeftUp())
     select mouseMoveEvent;

Jafar Husain’s blog contains all the details.

The last weekend I participated in my first open space (anti)conference – Architecture.NET Open Space in Düsseldorf. And I must say: It was my best conference experience ever!

There are some results in the conf’s wiki in German. Here I just want to write down some of my observations.

A couple of things came up in almost every session:

• Clean code and agile design principles. Software architecture consists of decisions that are hard to change. Agile software architecture aims to make changeable as many decisions as possible. So clean code and agile design principles is the absolute minimum that we don’t want to trade off. This statement is not a dogma – it’s the cornerstone that makes other decisions changeable, it makes agile software architecture possible.
• Asynchronous communication and messaging. This is a very hot topic now. Messaging is what enables the Open/Closed Principle on the architectural level. And O/CP is what enables architecture to evolve and does not let it rot.

Discussions were sometimes heated and controversial, but always very inspiring and thought-provoking. I already count days till Archnet Open Space next year.

I just watched a great demo of Intentional Domain Workbench presented at DSL DevCon about a month ago. Beside the fact that the demoed software frightengly looks like a “silver bullet”, "The Holy Grail” or at least “the future” of software development, it is the first demo of a RAD tool I saw that mentioned automated tests integration. See for yourself, it looks a lot like FIT acceptance tests:

Enjoy the full video at MSDN. It’s just awesome!