My response would be: Hell yeah! to all of the above – I learned loads, met lots of interesting people, exchanged ideas with people working on different projects, in differently organized teams – and it did prompt me to action! My TODO list is gigantic with things to check out, try out, read, consider as an alternative, question. Quite frankly, that’s what you want after a conference, what would be the point going there and come back with nothing to say/think about.

So – yes, I did like it – a lot. As Greg Young rightly pointed out in his keynote – QCon is on a different, slightly more abstract level than other conferences. It is not about a tool, framework or a particular language. It is about adopting a mindset that questions dogmas and principles and en-rooted thoughts. So naturally it was about making things done, making things simple, using right tools for the job, knowing tradeoffs and making decisions based on them. Oh, yes, and nearly everyone agreed that ORM is probably never a good tool for anything .

In large part my intention was to hear as much as I can on architecture, then on big data and NoSQL and satisfy my geekiness with a few talks on the side (Erlang, messaging).

What have I learned? Let’s go quickly through (some of) it:

DATA IS BIG

Nature of data is changing – it’s growing and not only for Facebook, Amazon or Google, we pretty much suck in estimations so, I suppose it goes without question that we do so in data size estimation too. As business recognizes value in it we will be generating more and more data and we cannot expect technologies 40+ years old to handle the volume simply because they were design with different requirements in mind. So it seems reasonable to resort to polyglot persistence – use right tool for the job – got it? And it actually makes sense – Relational databases would’ve not been around for so long if they weren’t doing a good job in persisting and keeping our data consistent. It is good to hear some sobering words though:

Relational Databases Will (probably) Never Go Away

(in enterprise)

It is sobering because NoSQL is all the rave nowadays. There’s a Hype Curve and it is showing that NoSQL is going steadily towards the peak of unrealistic expectations and will soon be heading for a spiralling down in disillusionment. Now NoSQL didn’t appear out of thin air – it came about as a solution to the problem that was previously unsolvable. Traditional relational databases cannot be (reasonably) scaled out – only up – which poses a big problem when we have huge amount of data. And that is why general consensus is that they can position themselves successfully

NoSQL as Complementary Solution

If history has thought us anything: all solutions aimed at replacing SQL databases failed miserably because Relational databases quickly responded adding support for similar features (XML springs to mind). So complementary solution – more specialized solution could find its way and seems to be finding its way. No wander there’s hundreds in offering of various types.

It all comes down to knowing your trade-offs. And it was so well put by Rich Hickey that it stuck immediately:

Developers Know Value of Everything but Trade Offs of Nothing

That is why I didn’t need, nor I wanted to hear that NoSQL will save the world – hype is not what we should be after – it’s about knowledge – about informing oneself, or as Dan North put it (something similar to this anyway): Inform yourself before making decision because you’ll make decision anyway. So it’s better to be informed decision – makes sense, hmmm, I wander why do we then take so many things for granted. I’m slowly starting to understand why one of the key notes had Mental Disease in its title.

Architecture should not be Pre-Set – it should Evolve

That doesn’t mean we should not do any upfront thinking and just get on with it in rather agile chaotic way – but rather do some thinking upfront and have a baseline architecture – put some thought in it, and then do iterative-incremental evolutionary design. The change is not exception – it is the norm – so it only makes sense to be ready for it – design for change. A cycle should have refine and asses and then refactor phase – we’re talking about architecture design here – so testing and changing architecture is here throughout whole lifespan of the project – that’s why/how it evolves.

Build System of Systems

There is no one size fits all – whoever draws high level architecture diagram as 3 boxes representing UI-Logic-Persistence layers deserves to be punched in the face. There’s absolutely no value in it and it communicates nothing. On the other hand when we have bunch of boxes representing billing, inventory, order management etc. and we have some lines connecting them it reveals much more about the system. It kind of communicates different responsibilities and functionalities that our system has. Making decoupled systems – in the long run – is better because it’s easier to manage and maintain and with it we get better freedom to make individual systems how we see fit. And it is all about simplicity – smaller chunks are simpler than one big monolith. Simple often means making more things – not less.

Micro and Macro Architectures have different considerations

When we have system of systems we have now 2 architecture levels – macro – communication between systems, how all this hangs together – and micro – responsible for inner workings of the systems. They have different dynamics of change – macro is there for longer (stuck for a decade?!), but micro can be changed frequently. This also allows us to have different micro architectures among the systems, even different languages – ha – polyglot programming!

Sometimes un-orthodox approach works better

Like polyglot programming and stateful server in Wooga. I loved how they evolved architecture from PHP+MySQL through Ruby+MySQL then Ruby+Redis then going stateful! with Erlang+Amazon’s S3 all the way to Ruby+Erlang+S3+MySQL. Just brilliant. And this goes along with the whole theme of the conference – challenge en-rooted thoughts, don’t take things for granted – in this case go with Stateful Server (dear God!) nearly without Database (blasphemy!) with Multiple languages (insanity)! And it worked!!!!

But if you try to:

Achieve Sustainable Speed

I learned you need Commodity Languages for this (read old boring Java/.NET stuff), commodity hardware, foster high speed culture (which apparently means that tests are dead at the same time) and a few things in between. However haven’t I just mentioned Erlang in the previous point? That’s the nicety of this mash up of different ideas – you can’t hear this in a one vendor conference However, it all plays nicely with the overall theme of the conference – if it makes sense use it; and the question does it make sense? – is always wrong asking without a context. So next time someone comes along and says: we’ll make three tier application with relational database for data – now what are we making? – they deserve another punch in the face (I hope this doesn’t work like subliminal message, otherwise I might be in trouble).

While I’m at Erlang:

Erlang is language from future

but with insane syntax which probably hampered its adoption (it’s been there longer than .NET and it’s just couple of years younger than Java). If you cannot find proper Erlang programmers – whatever anything serious you try doing with it will end up in tears (commodity languages …). But if you want to achieve high availability for example there’s no better language than Erlang because it was made from ground up for fault tolerance, high availability and distribution (to me: it nearly spells use me for infrastructure) – so if you need this you better either train of find someone who knows it. I did tutorial on this before the conference – and some things you can do in 10 minutes with it would take you ages in .NET/Java (and you’d end up with more hair in your head for granted).

Mean Time to Recovery

(is actually the metric that matters vs. Mean Time Between Failures)

High availability is not the same as Up Time – Up and processing user’s transactions vs. just being up. Failures happen (all the time) so we should be ready. The question is how? Train for it – that sounded awfully scary, frying production boxes is not really my cup of tea (but got me thinking nonetheless, hopefully my PM is not reading this, hell I should delete this line). Learn from failures – but from successes too – which makes sense since (hopefully) we do more things right than wrong. Learn from other fields – like – from running Aircraft Carrier (weird but excellent advice). Automate (but keep in mind man cannot be replaced). Share near miss events!

You don’t have to be young to be cool

(technology-wise)

Like Event Sourcing – idea is here since 70′s but it’s becoming very cool lately. Node.js, Nginx mentioned, also, ideas seemed to be the same in messaging solutions. I liked idea how events are actually revealing intention not just merely logging data.

Messaging is cool again

The talk rekindled my affection for messaging (this sounded weirder than intended). It was about millions of messages per second, persistence, recovery, queues being dead (lots of deaths predicted here, plus some wishful thinking on ORMs). Ah, I’ll just have to watch it again. It was just great talk – superbly balanced yet rich with information (although maybe a bit heavy if you’re not into this … ok, ok, weirdness – suffice to say I’ll watch it again, I loved it. Just drop it.)

———————————-

And that is just a part of what I’ve heard and learned. There’s more. I could go on and on. I may not be agreeing with everything said there but it was very valuable to hear different opinions and see different approaches – and generally get the brain thinking about all of it. Now I am definitely better equipped to make architectural decisions in informed way which I hoped to get out of this.

Anyway, all of this will be available on InfoQ soon (well, over next 6 months). I already have a list of things to watch. I missed Joe Armstrong’s talk on Erlang which I heard was very good. And Dan North’s talk – Decisions, Decisions, then Patricek’s talk on F# (heard both were great fun), and all from architecture track I didn’t make. Btw, if you haven’t seen videos of talks on InfoQ before – they are great – that’s the way to do it – with synchronized slides and transcripts (transcripts were new for me), definitely recommended. Slides of all talks are already public so maybe worth having a look.

Just to mention briefly tutorials before the conference. They are of great value! One of the things I came to see was Erlang so I attended a great tutorial before the main conference. And then I watched Erlang in the real world (in Couch DB). So now I’m completely equipped to make decisions in that regard. Also, I attended tutorial by Simon Brown – Are you a software architect? And it was all about seeing big picture, driving vision, mentoring the team, coding!, and all in all supporting and enabling the team all the way through – there’s so many responsibilities it’s not even funny how poorly the role is often described. Great stuff, highly recommended.

That was it for this conference – hopefully they line up something as interesting for the next year!

P.S. Racoon and Cheetah were sent to keep me company and protect me by my son (three and a half). He was very serious about it – they are his favourites.

P.P.S. I’ll keep a list of all talks I’ve seen here as soon as they become public. Hopefully

The key note was given by John Allspaw and was about Resilient Response in Complex Systems.Drills on live system, comparisons with running an aircraft carrier, near-miss events, learning from failures, but also from successes!, learning improvisation, Mean Time Between Failures Recoveries – all of that had been touched and more. Some of the mentioned – really scary stuff – like – simulate failure of components in live production. But also some common sense – why don’t we learn from our successes too when we presumably succeed far more often than fail.

Next two talks had lots of overlap and were basically covering NoSQL space and both resonated around same thing: Relational Databases are here to stay, NoSQL can be used as complementary solution to fill some gaps. It was a nice overview and actually there was lots to learn from the talks like where is NoSQL (or well, alternatives to SQL because other things were touched too) positioned on Hype Curve. It seems it’s at the beginning of the curve going up towards Peak of Inflated Expectations. Also, there has been some comparison on all available alternatives to relational databases some of which I never really considered before. See some more scalable datastore comparisons.

The next talk was Ain’t no cure for the distributed blues by Dan North. Very amusing and informational talk, but the choice of the room was ridiculous, the room was too small to fit everyone even with people sitting on the floor and standing by the wall. This wasn’t really that much about working distributed as about how to cut waste, importance of communication and making people want to do something rather forcing them – ah yes, all with background Star Wars theme.

Then it was about Erlang and Damien Katz, creator of CouchDB, explained why he found Erlang weird, simple, reliable, beautiful alas slow. Dubbing it Language from the Future – with appropriate background picture (hint: trilogy ), he pretty much covered when you would want to use it and when you might resort to some lower level alternatives. The bottom line is – it can do anything and everything but slow adoption rate is hurting it and slow adoption rate might be simply due to weird syntax. He strongly declared that the language is beautiful and once past syntax barrier productivity is phenomenal.

The last session of the day and of the conference for me was on Hadoop. It was fairly comprehensive coverage what is it and why one might want to use it. This, combined with previous NoSQL sessions and Dan North’s mentioning of metrics and usefulness of data (well, usefulness of useful data ) just made my appetite for massive data generation through various logging insatiable – hopefully it passes me until I come back to work on Monday … otherwise our servers are in trouble. Read original Map Reduce paper on which Hadoop is based.

It’s been a pretty long week, I need some time to summarise impressions and surely I’ll have some more reflection to do on this.

Key note for today – Simple Made Easy, by Rich Hickey – author of Clojure. It was interesting talk around these two words – simple and easy: how we reach for easy things first and by doing so we might be making more complex systems – easy is not simple. To quote him, hopefully correctly:

Programmers know benefits of everything but trade-offs of nothing.

And actually that was the key thing of the talk – we need to know trade-offs we are taking when we introduce, say a new framework – what complexity it entails for the convenience of not hand crafting 20 lines of code for example. At least that was my interpretation of his talk. Also, he presented couple of tables – The Complexity Toolkit and The Simplicity Toolkit – where were looking a bit biased towards functional programming – however I took them as: if you take from the former know the trade-offs, if you take from the latter know possible benefits (over the former) and make decision for yourself. He concluded along the lines: Simplicity is a choice. No tool will do it for us – testing tools don’t care if it’s simple or not.

Bashing of ORMs continued (ORM – OMG in complexity toolkit), and this bashing is happening throughout conference (already done on several talks yesterday, forgot to mention, and couple of talks today). This seems not be really aimed at ORMs but our often brainless usage of them – see the quote. From this conference, one of the points I’m taking so far is – think about what you’re doing ( makes sense), things should not be given (usage of Rational Database for example goes normally without question) but conscious decision on using them should be made based on the problem at hand. Genius, some common sense goes long way.

Anyway, with that I went onto High Performance Network Applications in the Capital Markets by Todd Montgomery.

1. It was absolutely packed, people were standing, sitting on the floor
2. It was extremely interesting, actually, I loved every minute of it

Here are the slides. Now, this might not be your cup of tea, but I was once very much into messaging and integration and that kind of thing, and the talk was just perfect for me. They are getting 7.2 mill mesages through per minute during the peak, and the key is Shared nothing messaging: Peer-to-Peer architecture, Parallel persistence and Single message API. Won’t go into the details – see the slides, I’m going to see them again, and I’ll see the talk once more when it becomes available on InfoQ. He boldly stated that queueing [as we know it] is dead long live [publish/subscribe] queueing – btw, that’s my interpretation.

The rest of the talks I’ll just mention briefly – wan’t really impressed. Modelling in Cold Climate was about phases teams go through when Model they’ve been working on “sucks”. It was entertaining session, there were couple of interesting things there, but the whole talk wasn’t really relevant to me.

I decided for Extreme FIX Messaging for Low-Latency because they were doing it in C# and Java, and I hoped to see how is it possible to do it and not resort to more exotic solutions. And the only thing I got was Garbage Collection needed to be tamed and they’ve used custom drivers and custom networking hardware. Was a let down on my expectations.

With that I decided to go back to Architecture track and BigData@Facebook. It was about Scale and Scope of their data and how their architecture evolved to tackle hyper growth. It was interesting to see how their data size just exploded recently and how they coped with it – from RDBMS data warehousing solution through introduction of Hadoop, evolution into Hive and then adding HDFS to it. Also interesting was how focus moved from simple business reports to data science to democratization of data and fighting chaos that came out of it, and on towards new near real-time statistics requirements and on and on. It was interesting and actually valuable to see another aspect of data – data that is behind the scenes which affects new features and development of the application.

The last session was on Azure – platforms choice there. Of course, having any connection with Microsoft – demos were the order of the day However it was interesting to see that Microsoft is diversifying the offering. Focus was on Node.js and solid support it now has in Azure.

That was it for today, for tomorrow I’m planning Big Data and NoSQL track and it seems like lots of interesting sessions there.

Martin Fowler and Rebecca Parsons opened the conference with the key note – Data Panorama. Martin was very funny screaming how big data is to open the talk. And it turns out that data is Growing and how we use it is Changing. Keywords were Growing, Distributed, Valuable, Urgent and Connected, and I believed every word Who would argue with this. Nowadays when even a fridge can tweet data is coming from all various devices which wasn’t the case just few years ago, so now challenge is even to decide how much to store and for how long, let alone how to use it. Response to this change are NoSQL databases – and Google with BigTable and Amazon with Dynamo started the trend out of necessity. The necessity being – couldn’t scale up anymore – had to scale out and relational databases couldn’t do it. So now we have new wave of databases that are offering convenience (easier to store aggregates) and distribution (sharding). Talk went on about polyglot persistence and event sourcing; then how the data sources have changed – it’s not tables only anymore, it’s text and images and video and connections … and we need to analyze it differently – obviously – with emphasis on visualization of the data. I could go on and on about this – obviously I found this highly inspirational.

I am really into this polyglot persistence – and when I was thinking about it simplest thing that sprang to mind was logging. I read somewhere how Hadoop was used for logging and it was mentioned by the speakers along with map-reduce, so that’s probably why I thought about it. Anyway, my impression is that we’re not producing enough data – sounds silly, no? We could be logging easily much more data about operations of our services if saving that data to rational database wasn’t perceived as heavy, amount of logged data would probably be vast and it would use the most expensive storage, and how would I analyze it without very expensive tools? It’s non functional concern in the end. But if we used something like Hadoop, that would’ve been much more palatable – maybe. Anyway, just thinking out loud, these all silly thoughts were heavily reinforced by next two talks.

Stefan Tilkov was talking about Breaking the monolith: Towards a system-of-systems architecture . The session was absolutely packed, it was becoming very hot, it was just silly that track hadn’t been assigned a bigger room, all sessions were packed, nearly full, or even overflowing. Anyway, Stefan was talking about system boundaries, how three layer architecture everybody draws is too generic and how one project doesn’t necessarily means one system. On he went to talk about system characteristics and argue that we should really have Cross System and Internal architectures, rules and guidelines (Micro and Macro architectures if you will). Where Macro architecture would define separation and interaction between the systems, and Micro would be responsible for individual systems where we could have even different languages between systems. Polyglot programming, how exciting! Now all this makes sense, Cross System rules and guidelines is something that is going to be changed rarely and we might be stuck with it for a decade, where Internal architecture could change more frequently and independently as long as it (functionality it provides) looks the same outside. He carried on about loosely coupled systems – and again – about data integration, replication and redundancy – something similar to the key note tone. So, the take is – redundancy in data is not necessarily bad, and most probably in relational databases, for various reasons we already have it. He argued that this maybe doesn’t feel right but it is better in the end. Well, I would love to try it it all made lots of sense. Anyway, I really enjoyed the talk, just at the end it trailed off a bit towards UI part of it, and while I get it my interest is more on the other end. All in all, very useful.

The next one was Games for the Masses by Jesper Richter Reichhelm of Wooga – they’re making games for Facebook, and are were facing some serious challenges as games became more and more popular – talking in billions of requests per month. He has kindly shared the slides. So what he said was that logic wasn’t really complex, the load was the challenge – 100K+ DB operations/sec, 50K+ DB updates/sec. What they did was to rewrite their backend 4 times in 2 years, and it was exciting to see how the architecture evolved. They’ve started with Ruby and MySQL, went on to Ruby and Redis, then introduced stateful server with Erlang and did saves to Amazon’s S3, and finally settled for Ruby+Erlang. This is perfect example of Polyglot Programming – Erlang is great for infrastructure kind of code – supporting sessions in reliable and super fast manner, but Ruby has syntax that’s much more appealing to the eye (talking about readability of business logic). It was just interesting to see this also from the perspective of how many servers they ended up using and how they simplified their architecture at the end. I simply enjoyed the session.

The next was Michael Stal of Siemens with How Software Architects can Embrace Change. He raised some good points like why don’t we learn anything from failed projects? Jokingly he said we could use silver bullet to kill right person at the beginning of the project – that would be the silver bullet – ha. Talked about balance between Agile and BDUF i.e. unstable vs. nice but unsuitable architecture. At the end it all boiled down to iterative-incremental architecture development – small iterations with mandatory review of the architecture and some time for refactoring. Reviews and refactorings are important to prevent architecture erosion. Design for change, design for testability. Around that time I ran out of paper – they should hand out bigger notebooks here. In all honesty the talk was a bit too fast for me and slides too crammed – but when I went through my notes I could actually recall most of it. It was a good talk just a bit tiring.

I switched to high availiability track from there on. There were two talks, I’ll just go briefly through. From zero to 10 million daily users in 4 weeks was about sustainable speed of development in startup social gaming company. There was 1 TB of analytics daily mentioned – see how we generate more that, that’s what I was thinking. It wasn’t too inspiring talk but it was useful nonetheless. Interestingly there social gaming teams tend to be small and independent (similar to Wooga above). I didn’t really agree with some inflamatory statements that Testing is dead and Operations are dead, but I understand the background story. Also, there were some interesting pointers on Dark releases and Split testing. The following talk was on Event Sourcing – he he, again, but even though Martin is excellent speaker I felt it lacked content a bit. I might’ve expected too much out of it to be honest. The talk was actually very interesting and I’m nearly sold on this, but before commiting I need to get more information, but this seems to be one of the things really worth adopting.

The evening key note was done by Greg Young, great speaker, and was excellent. It was about weird and interesting things we do. Things that stuck were: Reusability is overrated, DRY has it’s dark side too, we love solving problems that nobady actually has, and ultimately – software is there to bring value. So we should be writing good enough software – and that was the highlight of the day actually. It was all about common sense, simplicity, back to basics.

All in all, it was very enjoyable day, I heared loads of interesting and useful information and I’m looking forward to tomorrows sessions. Thing to practice for tomorrow – conciseness – this was too long.

See reactions to the conference: #qconlondon.

When Martin Fowler announced he’ll be having key note there I had to check out what was the conference all about. Now, recently he was blogging about Polyglot Persistence which caught my attention (info deck they prepared on the topic is excellent), and that was going to be the topic of the key note so naturally I was interested. It turned out the conference ticked all the right boxes for me with tracks on Architecture, Big Data/NoSQL, High Availability, High Performance, surprisingly I had absolutely no interest in Agile track (we’re agile enough I like to think ). Anyway, goes without saying with all that on offer my expectations were always going to be high, especially when for every day, every slot, I want to see at least 3 sessions. It was very hard to pick what to see (well, harder to decide what not to see I should better say) and the ones I chose better be good!!!!

So conference is only 3 days long, but there were 2 tutorials on first two days and I chose Practical Erlang Programming and Are you a Software Architect.

Why Erlang? Well, I’m all into this Polyglot Programming thing – using the right tool (language) for the right task. Also, I like learning new programming languages and I like to see different philosophy, different approaches, keep my mind open for new ideas. When I say different languages – to me Java and C# are pretty much the same in this context, however, if you look at languages like Ruby, it’s very different, F# too, Prolog completely out of this world. Now, Erlang was made from ground up to be highly available, concurrent and distributed, oh and have I mentioned – functional (they are definitely gaining momentum them functional languages). So this makes it quite different and don’t mind functional aspect of it – high availability and distributed computing is the key here.

The session was excellent, packed with information, lots of hands on as well. Definitely gave me enough to want more and I should really start reading Programming Erlang since there’s so much to it and we only skimmed the surface. Well, I should’ve really said continue reading it since I’ve started it a year ago (*blushing*). It was interesting to hear where Erlang is used like in Televoting (X-Factor and such, you know ), but one thing that impressed me the most was Erlang’s lightweight processes. Your man, Francesco, spun off 10,000,000 of those (one was spun off by the next, sends it a message, receives a message and terminates) – it took just 12 seconds for them to finish. I thought that was really impressive. Another impressive thing demonstrated was how easy is to create distributed processes and communicate between them, and actually monitor if they are still alive and it was all in just few lines of code. For a lightweight introduction to the language I would recommend Seven Languages in Seven Weeks book, that’s how I started with it, and there are 6 more languages covered in it, so very well worth reading.

The second tutorial I attended was Are you a Software Architect? Well, the answer is sort of, not, maybe, yes, well … depends Joke aside, the tutorial was brilliant. My motivation was actually to see what am I doing wrong and what am I doing right and to see how to improve on both ends – do things that I’m doing good better, and fix things I’m not doing well. Simon, the speaker, was excellent, and the format of the delivery too. We had several exercises where we had to discuss various topics in pairs and then we would call out responses. Honestly I did not expect any exercises given the topic but this was clever. I got to know how other people have organized teams, what problems they’ve encountered, got to hear different opinions on roles – not just Architect role, and it was really interesting because you don’t have opportunity to do this … well, ever And when people start talking about, say responsibilities of a Software Architect, more often than not my reaction was – right, never thought about that.

All in all, I never thought before that Software Architect would have so many responsibilities and so many soft skills required, that there are so many fallacies and myths. Now that I took so many notes and it has been mentioned, it makes sense, but seems that there’s never enough time to step back from all the daily chores and actually think about all these things.

Lots of impressions for the first two days, and if it is to be judged by them the reminder should be really really good. Expectations are high, tomorrow is going to be a long day, I’ve settled for Architecture track and will maybe switch to High Availability track later in the day. Hopefully will have something exciting to write about tomorrow.

For example, with a telephone directory, the more unique a name is the faster you can identify the person you are looking for. A name like “John Smith” is likely to have many entries and thus require verification of unindexed data to resolve the correct entry for your search, whereas “Zaphod Beeblebrox”, would be relative simple to identify.

Thus having a high cardinality or relatively unique column values, is typically a positive thing, in terms of index efficiency anyway.

The future of C# is Asynchrony apparently. I’ve always felt all the current Async patterns unjustly interfere in what it is you’re trying to do. I also knew it was possible to write the code to potentially hide that (but writing it yourself sort of defeats the purpose I guess). They’ve decided to add new language constructs to pretty much do exactly what I thought they should do. They’re hiding the callback aspect of an async method and doing a good job of it too. I’ve always felt the problem wasn’t necessarily the callback paraphernalia by the way guys, I always felt it was the disingenuous and indirect way the arguments (state) are passed back and forth into the newly spun up async thread myself.

Windows Phone 7 appears to be a tantalisingly good platform to work with. Strict guidelines and smart lessons learned from (ahem) other mobile platforms make it look like Silverlight has finally found that home it’s been searching for. All of the problems associated with Silverlight in other environments appear to melt away when it’s considered for a mobile platform.

Being at heart a developer, all the power of the Silverlight development tooling makes the Windows Phone 7 platform an extremely attractive option to me. But as DSI’s General Manager is wont to say, there is really no point in investing in this technology unless there is sufficient user uptake. He feels a figure of 30 million subscribers is about right. He certainly knows more about these things then I do. However, I can’t help feeling that the market will go where the features are really.

I saw the gaming platform today as well and it’s pretty damn cool. The excellent and wonderfully entertaining Rob Miles made the most of the rather dour crowd, demonstrating just how relatively straight forward the XNA platform for Windows Phone 7 really is.

So even though, no native development kit is available for the phone and video capture’s not supported in the API and it doesn’t support custom Shaders yet, it still looks like a snazzy development platform. As a result I’m getting an upgrade ASAP and I may start lashing something together myself I think.

To download the SDK is completely free for both Silverlight and XNA they only charge to register once you have something ready to develop on a real phone.

The Workflow Foundation 4 stuff I saw yesterday was about what I’d have expected. It’s been considerably reworked since 3.5. They’ve removed some of the rough edges, but I can’t help feeling it still retains some of the original problems. There’s no rules engine, and no state engine, but it does have an excellent editor and now supports strong typing and of arguments.

I always feel the big problem with business process architectures is the premise that business analysts will be able to (or even want to) directly describe their own workflow. I personally think the real value of a tool like this is, the Business Analyst can easily interpret and verify the developer’s implementation.

Today I was also treated to the wonders of process and thread creation. This was actually a really useful (for me!) seminar. I think the average punter might have not seen the benefit or maybe it might have it put them to sleep. The stuff was complex enough, that a second hour would have been nice too. I can’t help feeling like I missed half of it, as the velocity the seminar was delivered at was mandated by the large amount of complex content to deliver. Still when I wear my super nerd hat, I’ll have to concede it was really interesting.

Tomorrow more Windows Phone 7 stuff and whatever else appears interesting.

The talk given by Ilja Laurs, the CEO of GetJar was the best one I attended today. GetJar is the most popular mobile app portal after Apple’s AppStore. His talk was entitled “Mobile Apps: Where Do We Go from Here?”. I’m not easily impressed by stats in general however Laurs’ presentation was great to outline the current and the near future of mobile application market. With their 1.2 billion downloads to date, GetJar is at the right spot to talk about tendencies, user profiles, different markets and predictions. One of the not-so-surprising news was the growth of Android. Google’s Android is the fastest growing market. Last month alone, this market recorded an amazing 280% growth.

According to Laurs, active data subscriptions drive the app market, in an ecosystem where we are going to have 5 billion devices by the end of 2010. 27% of those are currently data subscribers. This figure will jump up to 45% in 2 years and 60% in 3 years, which predicts a very healthy market in the years to come. Furthermore, the app economy will increase 7 times in the next 3 years. 50 billion application downloads are expected in 2012. And the incredible forecast is that as soon as 2013, the app market will be bigger then the entire music market. In 2012, the app market is expected to generate some $17.5 billion whereas the music market will generate $23 billion.

Another interesting trend is about the pre-installed mobile applications: On-deck application distribution will shrink to 20% from the current 60% by 2012. And currently, a single-platform application doesn’t look like a good strategy for optimum growth.

Two sessions outshone the others within the “Transaction” theme. The first one was Mark Little (JBoss – RedHat)’s “Transactions: Overused or Misunderstood”. This was another excellent session. Little not only masters this topic but he is a great speaker as well. After briefly talking about Java and Transactions, he went through the ACID properties and explained why Two Phase Commit alone does not provide ACID guarantees. He also spent some time in demystifying the myths created by anti-transaction sentiments: “They add overhead for no benefit”, “Too expensive and bloated”, “I don’t need atomicity”, etc. Then he talked about multi-core CPUs and STM, when to use transactions and when to avoid them. All in all, it was a very informative and a very enjoyable session.

The second talk was entitled “Bridging Transactions from Java EE to .NET” and was presented by William Heinzman from JNBridge. I’m always interested in attending interoperability talks because in DSI we develop applications in Java and in .NET and most of our systems are large enterprise systems, where we have to work in heterogeneous environments. Therefore, interoperability is part of our reality.

To be perfectly honest, Heinzman’s talk started quite dull however it quickly picked up pace and turned out to be a pretty good one. After briefly introducing two phase commit transactions, Heinzman talked about the differences in Java and .NET implementations. Theoretically the interoperability between a Java and a .NET system should be easy as they both implement the same specification but once again reality is bitter (One thing that my experience proves me over and over again is that in theory, theory and practice are the same but in practice they aren’t). It was tragically funny to hear that Heinzman couldn’t put together a demo that showed how to use Transaction Internet Protocol, WS-Atomic or WS-Coor. I don’t doubt his skills but it just shows how unusable these technologies are. And he mentioned that he knew only one person who managed to get a system working using these technologies but the performance had been abysmal. Then he talked about cross-platform transaction bridging and the future of transactions. If you’re interested in cross-platform transactions, you should check his company’s products.

After the sessions, Oracle threw an amazing party, which took place on Treasure Island, between San Francisco and Oakland. The party was setup as an entertainment park. The concert section featured Black Eyed Peas, Don Henley and Steve Miller Band. Check out Jason Sheedy’s blog! His video montage of his JavaOne 2010 experience is quite good and contains many scenes from the party and the concerts.

After a good technical session about Building Highly Scalable and Available Apps, I went to discover that the second talk of the day on my agenda was rescheduled for 8pm as a BOF session (I know, I should have checked my e-mails more carefully first thing in the morning but the wireless coverage is patchy and the SSL bridge to access work e-mails don’t work here). With this huge blow to my daily schedule I was almost lost, not knowing what to do, shaking and cowering in a corner, when I discovered a session about Hudson, entitled Getting More From Your Continuous Integration Server: Taking Hudson To The Next Level. I was familiar with the basics but I was nowhere near being an expert so it ended up being a great talk for me. The speaker, John Smart, was very good and I ended up being glad for this schedule change. The whole session was almost a series of demos, which was a great way of learning about Hudson, its plugins, some corner configuration scenarios etc.

The following session, Java Exam Room: Tools and Techniques to Get an Inside Look at Your Application, was about diagnosing today’s highly concurrent applications running on multicore servers. The talk started with general disclaimers that in short said: Your Mileage Will Vary. The speakers presented a well-structured way in approaching the most common problem cases: triaging, getting to know the application at hand, verifying the symptoms etc. Then they dived deeper into scenarios such as Low CPU Utilization and High CPU Utilization. One of the tools that they showed was the jRockit Mission Control that is enjoying an ever-increasing popularity in this year’s JavaOne.

After having a well deserved break, getting some air outside and walking around the block, the day continued with a topic along the same lines as the previous talk: The Concurrency Revolution: The Hardware Story. In my opinion, this was the best talk of the day (though I hesitate between Hudson talk and this one as of this writing). Brian Goetz and Cliff Click did an excellent job in presenting the hardware-side of the concurrency story. I am usually not a hardware-geek however this was a fascinating topic as it is very important for us, developers, to understand the changing hardware architecture, obliging our applications to become multithreaded in a way to take advantage of this “Design Reboot” happening in CPU architectures. We all see in our newly developed systems that “Memory is the New Disk” and in search of faster memory access the crucial question becomes “How fast can we cache-miss?”. After the introductory parts, the speakers gave some recommendations. And the last part of their talk was about some solutions for certain scenarios:

• Thread Pools/ Work Queues
• Fork/Join
• Map/Reduce
• Actors
• Software Transactional Memory
• GPUs

The JavaOne Technical Session was scheduled pretty late during the day, which contained 3 main sections: Java SE, Java EE and Java Mobile/Embedded. Mark Reinhold repeated his “Java 7″ talk, which was the first talk I attended yesterday. This covered the Java SE part of the session. Then it was followed by the Java EE head Roberto Chinnici‘s talk. And finally Greg Bollella talked about Java on Mobile phones and embedded devices.

I’d like to open a bracket here and mention something we witnessed yesterday during Thomas Kurian‘s Keynote speech. When Kurian was talking about Java on mobile phones, we were showed a video of Java applications running on a Sony Eriksson phone (I apologize, I am not able to give you the exact model as I am not familiar with these phones). The tragically comical part of the demo was that I thought I was back to 2005. In the era of iPhone OS 4.x and Android 2.x, it is insane to show such a video during the keynote speech of one of industry’s biggest conferences, unless one wants to ridicule a competitors lame product. I am asking you: who uses these apps on these phones? How popular they are? How much money they generate? What is their future? I know some folks who still love and play Atari. Is this such a technological nostalgia? Do you really think that someone who needs a mobile twitter client or a mobile facebook client would do so using such a phone? Even if there’s a niche market at the moment, how big this market be next year compared to its current size? And in 5 years, how many feature phones we are going to have?

I think it’s time to stop this madness. We already have Java on mobile phones. It is called Android. We don’t need a zombie technology that never dies but looks like it has been dead for a decade. Instead of suing Google, Oracle should thank Google because they achieved what Sun hadn’t been able to in so many years. Today, there is no doubt that Android is in route to become that biggest popular mobile platform. We are probably going to witness an episode similar to Windows PC vs Mac on mobile devices with Android vs iOS. And this is not only on mobile phones, Android is and will be used on e-book readers, tablets and probably more and more smart devices some of which are not even invented yet. And this is great for us, Java developers. So Oracle wants us to have the best tools and platforms… as long as it’s from Oracle. Just like Henry Ford who said “Any customer can have a car painted any colour that he wants so long as it is black”.

So, please stop showing us these strange looking mobile UIs of an earlier century. No one is impressed by them. You just need to turn your head and look around to see what kind of phones people use. I’d be really interested in seeing what kind of phones the presenters were using.

I’d like to finish this post with something positive and cool. Moscone Center has some cool stuff at the entrance of the exibition hall. Judge it for yourself: