Wednesday, March 21, 2007

Last QCon post

Since I only set up this blog to report on the QCon for my company and colleagues, this will be the last post at this time.

Part of why I do not blog, is that I think my writing stinks. If you feel otherwise or just want to send an encouraging message, leave me a comment.

Signing off for QCon 2007, yours truly: Samuel Ranzato from Sogeti

Dojo (speaker Eugene Lazutkin)

OMG .. do you know how Russians talk in the movies? Remember Drago in Rocky (“I must break you”) .. if so, than you know what kind of a dialect we had to listen to for an hour long.

First the “bad” …

It seems to me like Dojo is years back in time since all of the API look really procedural to me. Didn’t we quit that scene like … years ago?

Second, the “good” …

Akin to Bruce Johnson with his GWT toolkit, I really got the feeling that Eugene loves what he is doing and what Dojo has to offer. To me, that goes a long way since I would rather do something medioce but with passion than being on the cutting edge and hating everything I do. Sounds strange? Well, I know people who develop really complex and challenging software but under such pressure and so little appreciation, losing a lot of personal time doing work in the late, late hours. I would rather have a life, nice colleagues and a company that knows how to combinate fun with productivity than doing rocket science with a whip going over my back. Makes me think back to the articles about the Electronic Arts “widows”, women that we married or somehow lived with programmers that were worked like donkeys to produce software within a high pressure environment without getting compensation be it money, vacation days or what have you.

I love blogging as a therapeutic exercise, don’t you?

Eugene enumerated three types of applications you can write with Dojo: Web 1.0 enhancers (think updatepanels for all you .Net geeks out there), Web 2.0, and the holy-grail-app to some … the one page application.

Dojo comes with a lot – and I mean a lot lot – of Helpers for OO, functional programming, events, AOP, etc. There also is a normalized DOM to hide browser idiosyncrasies. Dojo calls custom events: Topics.

Sorry, I don’t have more to write but my head hurt from trying to understand what the heck he was saying. Tip for next year: one of those translation services like they have at the UN building.

Rich Internet Applications for the Enterprise (speaker Christophe Coenraets)

All in all, this also felt like a product plug like the GWT but with the difference that this product (Flex) is not open source and will generate money for Adobe, for whom Christophe works.

RIA are, according to the speaker, applications that can be characterized by the following aspects: expressiveness, performance, realtime, rich media, and desktop/offline use.

The latter is a bit difficult for normal Ajax applications but with Flex you can use the Flash runtime to run your Flex application offline.

Christophe mentioned the trend we see in applications as they went from developer centric to data centric and now, with RIA, to user centric. To me, that sounds strange as the data of a company will probably be longer around than the average employee.

He continued by showing some really cool UI demos, no denying that, and told the audience that Flex can also target a locally available JVM.

Since Flex uses Flash, it is worth noting that Flash 9 is largely rewritten to support (better) JIT compiling and binary sockets, all of which is available to application written in Flex.

Sockets is typically one of those things that are virtually impossible to do in “ordinary” Ajax.

To sum this entry up, one nice data-management-thingy is, that with Flex you can configure when changes are persisted: realtime, leaving the field or per form.

My take on this session: really groovy looking demos by a guy who has been around long enough developing software to get some credit but at the end of the day, the feeling I got was that someone was pushing their product on me. Too bad that a friend of mine wasn’t here as he is very interested in buying / working with Flex.

Google Web Toolkit or GWT (speaker Bruce Johnson)

Bruce works for Google on the GWT but a little research has shown that he previously worked on the AppForge MobileStudio project which I used a long, long time ago.

But that is besides the point, back to business.

He started off by reiterating some of the risks that go with a Ajax toolkit project such as usability, portability, speed, tool support, and quality.

The GWT is only available to Java as it cross-compiles Java to the Ajax platform (JavaScript) but will enable you to use a lot of the standard Java libraries, in fact all that are not virtually impossible from JavaScript.

Programming in Java enables you to use all the debugging and rich IDE (Eclipse, Sun Studio and others) to develop and GTW provides a GWT Host Browser to run / test your applications. The host will go to great lengths to ensure that it resembles the real thing as it eventually will run in the user’s browser.

In the usability department, something that I consider very important if you are doing Ajax, was the fact that GWT has very good font and color-scheme support built in. A lot of functionally inhabited people use these to get a more satisfying experience using their computer but a lot of software or webpages out there simply ignores them and has these hard-coded which to me says something about how their programmers think about their users (personal ranting finished).

The GWT also has the Back button problem and Browser History problem with Ajax applications covered but from a programmer’s perspective. No way near as elegant as what Erik Meijer suggested in his keynote yesterday but I won’t go into that.

In fact, one thing that distinguished the GWT from other Ajax toolkits is, that it will support Back / History even when you leave your application and later return to it. That is a good thing to test any Ajax toolkit on how well they support these browser functions.

You can indicate whether you want to generate obfuscated JavaScript (used when you only develop in GWT/Java) up to very verbose JavaScript that can be further enhanced by other developers.

I have to be honest here, it felt a bit too much like a product plug from which of course Google won’t get any money as GWT is open source but more in name-fame and thought-leadership. Fortunately this was offset by Bruce who was a very enthusiastic speaker and really wants to make the best toolkit ever. This left me with the feeling that it was one of those commercials that don’t annoy but nevertheless are meant to get you to choose “their product” if you know what I mean.

Ajax - Do we need a Client Tier (Dave Crane)

Dave started by admitting that he chose the title to provoke a response or trigger interest from the attending people. The answer to his question was Yes by the way.

What he did talk about was the size and importance of the client tier and his conclusion was very straight forward : it depends on how the level of Ajax used. Level seems a strange word to use here but let me put it in perspective. If you use only the UpdatePanels from Ajax for .Net than you are at a very low level but if you are going where no man has gone with Javascript, asynchrosity, and sending or receiving complex structure through XHR (XmlHttpRequest) than you are at a high level.

Dave also mentioned that it is a good idea to set the level at which Ajax is to be used in your design documents or at least bring it up as a design question.

Next on, he explained Java Literals, Closures, and more JavaScript specific stuff in a way that a relatively JavaScript noob like me could understand. I liked the fact that Dave calls Closures akin to inside-out objects. One thing that I really don’t like, but that is coming from a more structured, procedural mindset, is the fact that if you pass local variables to a callback within a Closure, those variables will be essentially global – and taking up memory – where the visibility is restricted to the callback only. In closure – pun intended – this is how Dave summarized the difference between objects and closures:

Objects: Data encapsulating behavior
Closures: Behavior encapsulating data

Dave wrote a book on Ajax Design Patterns and he told the crowd that he advises to not use Java-esque ways to program the GoF patterns but to use a more JavaScript approach. This will prove to have you writing less code and use some of the typical JavaScript constructs to their full potential.

He ended the session by demonstrating the implementation of the MVC and Strategy Patterns in an easy to understand manner.

Even though this turned out to be a more code-centered session, I liked it.

Ajax and browser-based applications (speaker Scott DeLap)

Scott gave a short introduction but I thought it good to iterate two things he mentioned:

Ajax as a name or abbreviation (AJAX or really AJaX) is about 2 years old whereas the technology is much older. This reminds me that I was doing Ajax even back in the days when there was only Classic ASP, come to think of it.

Ajax is almost synonymous with eye-candy and snappy user interfaces but there is also the set of improvements performance-wise since doing more stuff on the client will relieve the servers, network and other components in the communication chain. Kind of makes me think of Windows Vista about which most people only see the visual improvements but not what goes on under the hood.

Friday, March 16, 2007

Agile architecture, fragile architecture? (speakers James Coplien and Kevlin Henney)

Man, are those two the new Laurel and Hardy or something? Because it was a to and fro of quick comments and jokes. Very effective in keeping everyone awake during the last session of the day. Since it was more of a variety show than a presentation, I did not write down as much as I should because they did tell a lot. I just cannot reproduce it here.

One thing that I wrote down was this. Architects like to design their architecture using some modeling piece of software, but to some drawing out that design becomes more important than the purpose for which the exercise was meant. James called that : using the rules of drawing instead of using the rules of construction to design an architecture.

Next Kevlin made the nice point that if we want developers to write good code, management sends them off to some language course like Java or C#. But even though we ask developers to write documentation, no manager sends his developers to a course like Comprehensive Writing or Writing 101. That is strange because the developer does gets harped on that the documentation is to technical, elaborate or condensed, etc, etc.

Last, they looked up Agile in the dictionary to show that designing an architecture does have a place in an Agile world. Agile in latin could mean : to be ready. How can you be ready as you decide (hard) things as you encounter them or how to be ready to handle a familiar problem in a consistent way if not with architecture.

Unfortunately, the session was really talking about software architecture and not enterprise architecture or information architecture and so on.

And so ends another illuminating day.

SCRUM at Google (speaker Jeff Sutherland)

SCRUM has some of its roots in the Toyota Way of doing business and building things as well as a Harvard paper by some Asian named people whose names I forgot to write down but you all know how to Google, right?

There is a lot of overlap with the Agile Manifesto and SCRUM is regarded as an Agile methodology that is continuously motivating (“bootstrapping”) people to excel when called upon to perform great deeds. So it is also a lot about empowerment.

SCRUM was incrementally introduced at Google, so the engineers discovered themselves what was not going as well as they thought or should I say hoped.

There are Standup Meeting periodically, sometimes daily or weekly or even monthly. Whatever suits your needs and your team is ready for. Jeff suggested that a Standup Meeting should be about 15 minutes where the team looks back on the pas 12 hours and into the next 12 hours of development as this will keep everybosy focused on feasible goals. The agenda usually contains 3 items: to do, done, and issues.

XP is a great addition to SCRUM because it adds engineering principles and best practices that engineers can use in the SCRUM process.

Some things I want to look into, that Jeff mentioned, are: The ABCs of SCRUM, the Nokia Scrum Assessment.

This was really a great session and if SCRUM only half as much empower people as Jeff did with his audience than it is worth a try.

ESB (speaker John Davies)

I am sorry to say that all I wrote down about this session were bulletpoints, so I will just put them up here and if some annotations come to mind, I will add them.

  • Message validation is critical, any wrong message can cost millions of money.
  • Be future proof or in other words, use standards.
  • Scalability is important, but only do it when it becomes necessary.
  • Expect failure no matter what the vendors tell you.
  • Integration within banks or outside is done on data and transport.
  • HTTP is a unreliable transport and web services use it but why do we? We should not need something as WS-ReliableMessaging if HTTP was reliable.
  • Using an ESB does not automatically imply the use of XML for messages.
  • An ESB is best off to use one canonical message format internally which Biztalk fortunately does.
  • In order to have the ESB do its best at performing the core services on messages, adapters should be used to offload stuff like validation, preprocessing and transformation to the clients of the ESB.

All in all, a very good introduction into what is important for a bank when it concerns the use of an ESB.

Test Driven Development (speaker Steve Freeman)

Steve started off with some pseudo-statistical evidence that TDD increases quality without hardly sacrificing development time.

His steps for successful TDD are: write a test, make it pass, refactor. A suggestion he made was to name a test after the feature you are testing instead of the method. Here also, a good rule of thumb is: err on the side of verbosity.

By writing tests, functionality can be described and added in small pieces.

After that you refactor them by replacing duplicates and making stuff as expicit as possible.

In conclusion he said that writing tests does not add enormously to development time, because research has shown that most of the time we read code more than we write it.

Too bad the session ended with a negative atmosphere because James Coplien had a difference of opinion that got fought out amongst the audience which I found to be very unprofessional.

User Stories and Planning (speaker Rachel Davies)

First of all, I want to point everyone to because if you are not familiar with what Agile is, and in relation to the topic XP or Extreme Programming, than a lot will not be completely clear.

The purpose of Agile is to produce working software as early as possible and I should add not earlier. Methodologies like SCRUM, XP, LEAN and others help you with that.

Agile people when presented with a deadline that cannot be met, will choose to drop features. Something that is not always appreciated by the customer. So you need “special” customers or companies that are willing to have incomplete but great and bugfree working software if a deadline was a little to ambitious.

User Stories are not meant to replace requirements, but what requirements seem to try and do but cannot succeed is pouring domain knowledge from the business analyst into the developers. User Stories are used for planning iterations and not for requirements. Period.

A nice way to describe a User Story is the following template: As , I need so that ”.

Every User Story should be given a descriptive name and storytelling should be used to extract variants on the User Story from the customer, like exceptions.

Rachel told us that Release Planning is used for creating a roadmap to base on how you want to make progress in your project but also determine the “cost” of deployment.

A Release Plan should be described in points (like every 250 function points) instead of moments in date and time.

It is important to do something of a Planning Game and have Standup Meetings. A Standup Meeting is usually in 3 parts. One, the business sponsor tells his User Stories. Second, the tech people discuss the effects and complications they foresee. Third, an iteration planning is created with (!) the customer since her or she gets tot prioritize the User Stories.

The speaker came over as a bit timid but I found the session nonetheless quite good.

Introduction to banking architecture (speaker John Davies)

Since Eric will be going deeper into this in his blog, I will only “scatch out” what I took away from this session.

A typical bank consists over one of the axis the LOBs or Lines of Business and the other the front, middle and back office.

The front office can be typified by: distinct functions usually traders, very high volumes and chaotic. The middle office is where the computational stuff happens but some similarity between function usually risk management with also high volumes but not as high as the front office and more a kind of ordered chaos. Finally the back office which can be described as a SSC or Shared Service Center which implies more similar functions, low volume and an almost leisurely atmosphere.

Painfully, there is a lot more Java going on here than any of the Microsoft languages and I do not count C++ as a Microsoft language only Visual C++ because that is not ANSI compliant.

The speaker obviously had decades of experience and that showed.

Keynote Thursday (speaker Erik Meijer)

It was to be expected but some of the stuff in the keynote was already familiar from the LINQ session. But it was nice to see the audience appreciate Erik explaining the impedance problem.

He went on to say that he really like the discoupling of relationships from object whereas they are implied in certain domain models. This way you can avoid relationships between another domain’s objects that are of no interest to your specific domain. The same goes for behavior.

The title of democratizing the Cloud (or Internet) was explained in a set of principles or guidance that basically said: do not burden a developer with problems that he/she cannot easily fix or are very hard to fix without a guaranteed ROI. He gave a funny example about choosing a producttype in Visual Studio. He asked: why do I have to decide to create a console application which is then almost impossible to change to a web application?

Defering these hard decision could be done by having the runtime environment do late binding on the platform of choice. Why make the developer chose for winforms, web or mobile at designtime?

His tip for making life easier on the developer was also : use what is in the room.

This was kind of repeated in the last session I attended in the form of architecture of locality, but maybe more about that later.

As a farewell, he demonstrated how LINQ queries could be used to have the runtime determine how to parallelize these and perform a distributed database action. Very interesting.

Thursday, March 15, 2007

.Net / Java Interop (speaker Ted Neward)

The final presentation of the day was given by the track chair person and I was joined by my colleague Eric.

The session did not go as I expected and did not go into the features that normally pop up whenever interoperability is discussed. But it was a very lively and funny talk.

What was very nice, is the fact that Ted is an independent consultant who does both Java and .Net contract work. This makes him able to look at it from both platforms.

He pointed out some really simple but no less workable approaches to getting the .Net platform and Windows technologies to work together with Java based server solutions.

But more interesting, as I am reading a book about it at the moment, was Ted’s explanation of the impedance problem. That word does not ring a bell for people whose native language is any other than English but it still is a very interesting problem. It describes how hard it is to translate a domain model to a relational or hierarchical model and other combinations.

That concluded the first day of the conference and so far off to a good start.

VSTS (speaker Kevin Jones)

I had my doubts about attending this one as it was an introductory presentation and I like to think that I am beyond that stage. Even though it turned out that I know most of what was presented, I must admit that Kevin knows a lot more about VSTS than what was presented today.

He, essentially, walked us through the different parts of VSTS, both client and server.

Along the way, he gave us some hints and tips like there is a tool from the Build team that provides continuous integration features (of course there is CruiseControl.Net) and that the Windows scheduler is good enough to schedule your daily or nightly build.

That VSTS is a V1.0 was made clear by the fact that Kevin also mentioned stuff that does not (or not completely) work well at the moment like for instance, deploying policies and the inconsistencies between how things are stored in Source Control, MS Project, and SharePoint,

Finishing his presentation, he also told us about the nice features that VSTS for Database Professionals has to offer and that finally DBA’s are a full partner in the Software Development Lifecycle or SDLC.

Sure, I knew a lot beforehand but the talk was informative and nice anyway.

And I must applaud the dignity with which Kevin handled his laptop failing to provide a picture through the beamer and the hassle of copying his PowerPoint presentation over and not being able to demo some of the things he highlighted in his talk.

WPF (speaker Ian Griffith)

Ian told us upfront that he was not going to show cool 3D rotating buttons that displayed movies and a marquee text. He wanted to get the point across that WPF had more to offer than some kind of Flash-type GUI stuff and really had business value.

Ever since Windows 1.0 or Windows 16 bit, not a whole lot has changed in the way Windows interacts with the user and how it uses the hardware it is running on. Now that 3D accelerated hardware is ubiquitous, the age of the API really becomes evident.

Also, as display density increases (DPI) the bitmap based GDI does not scale well. Just imagine the Start button on a 30”, 2560 x 1600 pixels XHD monitor and you know what Ian was referring to.

WPF adopts a popular pattern namely Separation of Concerns by splitting up markup and behavior. This is not something new as it is also done by ASP.NET where you have HTML and code-behind.

Integration is one of the most importing aspects that WPF has to offer. Now you don’t have to choose or combine one or more of the following technologies as they are combined in WPF. The technologies are: HTML, Win32, DirectX (on which WPF is built by the way, I am guessing DirectX 9), and Flash.

The designers for doing WPF or XAML work have not yet matured to a production-quality level but they are getting there. At least a lot more with Visual Studio Codename “Orcas”.

Even though the presentation was not exactly what I expected, it was no less interesting.

Service Oriented Communication and WCF (speaker Christian Weyer)

Usually strange or tall people give great presentations, don’t ask me why.

Just to name a few strange ones: Erik Meijer and Don Box.

And for some tall ones: Mark Russonovich and Christian Weyer.

By the way, in no way does strange mean something negative but literally “out of the ordinary”.

Christian insisted that the track was not called “SOA and WCF”, because of all the vagueness that is associated with SOA whereas he was going to give a deeply technical presentation over what WCF really is and what it is trying to provide or accomplish.

First of, WCF is really two things namely a runtime and a programming model.

He continued by explaining your WCF ABC being Address, Binding, and Contract.

The types of contracts he talked about were service contracts, operation contracts, data contracts, message contracts and last but not least, fault contracts.

He went on to provide some common pitfalls like mutually excluding service configurations such as session-less services that want to use a basic HTTP binding and some more.

One of the tips he gave for well-behaving services without unexpected behavior or permissions was to run service hosts under a non-admin process. That can be complex if they need to run using a kernel-level service like http.sys but nonetheless it is very important that you do. It will also make it easier to run well on Windows Vista and Codename Longhorn Server.

The presentation ended with a good question from the audience about how to test services. Christian replied that from his experience, unit testing code generated by SVCUTIL or using channel factories worked best for him.

Again, a really informative and rewarding session.

LINQ (speaker: Erik Meijer)

After the keynote and a short introduction from Ted Neward about the .Net track, Erik Meijer presented a talk on LINQ. Nice to see another Dutchman talking about this fascinating subject.

If you do not know who Erik is; he created Haskell which is a functional programming language and after some diversions set out to create LINQ out of a subset of principles that make up functional programming and its roots in mathematics.

He started by pointing out that LINQ is based on previous scientific work on stuff like list comprehensions, relational calculus and monad expressions. If you are familiar with all three, I applaud you because I wasn’t.

On a side note, I do have to mention something about the person Erik.

He presented in an almost ADHD type of fashion, wearing a t-shirt that could be how one experiences a bad LSD or acid trip. It kept everybody on their toes but he was, to me, at times also exhausting to try and follow everything he said. Let’s just say that he is a personality.

LINQ is designed to separate the data model from the query syntax. The query syntax provides three distinct features: filtering (e.g. x mod 2 = 0 or a WHERE clause), mapping (e.g. x * 2 or the field-list after a SELECT statement), and aggregation (e.g. Sum function). Any data model can provide these features through something called extension methods which kind of resemble, to me, the Decorator pattern. All this is based on the IEnumerable interface and some “little” adjustments that had to be made in the .Net CLR.

Since LINQ is sort of a subset of functional programming, there is support for something called lamba expressions. It is way out of scope for this blogger to dive into that area, but remember that Google (and Wikipedia) are your friend for subjective information.

All in all, a very riveting presentation.

Addendum: all the speakers in the .Net track, only Kevin Jones was there hosted by Ian's laptop. From left to right: Ian Griffith, Ted Neward, Christian Weyer, and Erik Meijer.

Keynote (speaker Werner Vogels)

“The Technology Platform: Building Blocks for Innovation”

To kick off QCon, Werner Vogels gave a presentation of the building blocks that make up Amazon.

But first I want to mention that for the CTO of an American company, he spoke with a Dutch accent. I will investigate this later.

What he basically said was that Amazon provides two ways of integrating with their platform: Data Integration and Service Integration. The first means you can extract (and provide) data to the Amazon warehouse. The second means a couple of thousand (yes, that is 3 zeroes) web services exposed by either SOAP or REST.

The functionality or technology as he prefers to describe it which they provide basically consists of three aspects being: Storage, Compute and Queuing. That does not mean that there are not a whole lot of subcategories but they all boil down to these. So, there is a persistence framework, a business rule framework in the broadest sense, and a messaging or message queuing framework. Three might sound a bit low but as Van Halen (the rock band) wrote: if nothing is simple than nothing is learned.

Finally he led us through a historical journey of what he describes as 10 years of chaos followed by restructuring and re-architecting of The message he wanted to get across is : scale later. This is what Donald Knuth summarized as : premature optimization is the root of all evil.

All in all, a nice way to kick off the day.

Addendum: I also took photos when I was in London, speakers and sights. I will distribute them across the appropriate sessions.