Thursday, February 21, 2013

JFokus 2013: Second confrence day

On the second day I didn't make as much notes as I did on the first. That doesn't mean that the session weren't interesting I just focused more on listening. I attended eight session on the second day where the last one was the most memorable one by Dan North but I'll go through them chronologically. Some of the text is word to word notes from the presentations and some are my view of how I understud and processed the topic in my mind.

Building scalable, highly concurrent and fault-tolerant systems: Lessons learned

Jonas BonĂ©r told what makes systems slow and what kind of solutions can be used to speed them up or at least speed up the response to the user. 

First lesson to learn is There are no free lunches. If you use some approach it affects to something else. Some might use the phrase There are no silver bullets which means the same thing or at least that's how I undestud it.

Second topic was about concurrency. Mutables and threads isn't a good a combination. Using threads and mutables means you have to use locks in your code and you can't create generic locks that could used in every situation so that leads to more code, more maintaining which leads to more possible points where your program can fail. There are ways to use concurrency and possibly avoid problems with threads and locks etc., here's a few keywords that I picked up: Dataflow concurrency, actors, STM, agents. I've used akka framework and actors in one project and they are a easy way to bring concurrency to programs.
Blocking is also the enemy of scalability and a way to get around this is to use async calls and because every confirmation of sent and received messages is expensive in network time another way is to use ACK responses. 

Last notes I have are about Big Data. When and where Big Data is used functional programming should also be the choise of programming paradigm because it fits like a glove, think about MapReduce. Some acronyms related to NoSQL and Big Data worth a look are CAP and BASE and ACID vs. BASE.

Patterns fo key-value stores

On this I didn't make many notes just a few things to remember with KV stores. Most of this session talked about RIAK and Redis KV stores so the topic was a bit misleading.
  • Value can be a reference to a key
  • Consistent hashing
    • Data shared among servers
  • RIAK has support for REST, JavaScript and Erlang
  • Redis has some sort of transaction managent and could be a good choise as cache in front of a RDBMS
  • Two important things to remember with KV stores are naming the key and having a good data model
    • personal note: even though KV stores are schemaless you always need to have a data model

Real-Time delivery architecture at Twitter

This was interesting actually so interesting that I only managed to make three notes because I was concentrated on listening.
  • Twitter uses Redis as a cache on all reads
  • Statistical backend is Hadoop
  • Read, write and search are all separated in their own paths

Continuous delivery patterns for large software stacks

Hans Dockter introduced commonly used delivery patterns. There's no way I could explain these better than he did in his presentation material and these can propably be found from the internet so I'll just list the patterns here.
  • Binary snapshots
  • Branching
  • Single build
  • Water gater

Stop doing retrospective and start your Toyota kata

This presentation talked about the principles of Toyota kata. So Toyota kata is a way to constantly improve and it's about experimenting. 
First thing to know is that 50% experiments has a different end result than expected. So when your experimenting things don't always go as you expected.
As I mentioned Toyota kata is about constant improvement and that means that all the time there's some experiment going on in the background.

Toyota kata is actually two katas improvement kata and coaching kata. 

In the improvement kata you set a concrete vision, something that can be measured. To get to that vision you set challenges on the way to the vision think of them like check points on the way to the big finish.

The coaching kata is about team leader supporting the team, pointing them to right direction.

My last note about this was something like this: To improve you must experiment.

Rocking the Gradle

Hans Dockter introduced Gradle build tool e.g. to replace maven. I didn't make any notes because he was talking so fast and demonstrating so many different possibilities of what you can do with it. Gradle is something I'm going to investigate at some point in the future even though I've heard it has some performance problems compared to maven.

Simplicity: the way of the unusual architect

This was the end keynote by Dan North. Firstly he presented some history and how everything in software development repeats itself in some way e.g. CORBA, JMS, SOAP, REST same basic idea in all of them just a different implementation. He made great points about software development but he presented them in a non-serious way so that the audience was concentrated on listening him. This was a great way to end the confrence. Here's a few notes I made during his session.
  • Three ages of everything
    • explore
      • maximize discovery
    • stabilize
      • minimize variance
    • commoditize
      • minimize cost
  • People make things complex when things should be simplified
  • Observe complexicity
    • e.g. What is this meant for, is it doing more than it should be

Monday, February 18, 2013

JFokus 2013: First confrence day

This was my first time at JFokus but hopefully not last. I wasn't quite sure what to except. I had heard good things about the confrence and knew that it was quite big. It was more and better than I expected. There were over 1500 attendees and great session from beginning to end. If i get the opportunity to go again I'm most definitely going again.

On the first day I attended six sessions. I'm not going to write all my notes here but I'll try to give good summary of each session and the rest can be read from JFokus website where you can find presentation materials for both days.

Taking development to the edge

This was the keynote of JFokus embedded, M2M & internet of things miniconfrence.

In the future everything is connected to each other and to the internet by everything meaning absolutly everything. Cars can share information of traffic, houses can tell if all the doors are closed and locked or the are the lights on.

Smart homes didn't succeed 10-15 years ago because automation was expensive and possibilities were unknown. In the future smart homes will be true but instead of full blown automated homes the automation will take care of the simple things. Lights can controlled automatically depending on movement in rooms or how much sunlight shines through the windows. When nobody is at home the lights can be switched off, temperature can dropped by adjusting central heating and home surveillance system be turned on.

For all this to be true and to keep the networks running without massive break downs embedded systems need to able to turn on and off their network traffic so that they don't send status updates every minute or so but when there's actually something signicant to report.

Today there are about 200 000 programmers in the embedded field but in the future there are going to billions of embedded devices. So who's going to be designing and implementing all those devices and their software. There's going to be a huge need for embedded programmers in the future and Oracle is going to respond to this with Java and their aiming to #1 platform of embedded devices. JVM already works in embedded devices but Oracle is going to expand this support by bringing Java SE APIs to Java ME.

By attending this session I also got a free Raspberry PI and hopefully I have some time in the future to try out some embedded programming with RPI and Java.

Design patterns in modern JVM languages

Very well presented session about patterns by Venkat Subramaniam. The most important thing to remember from this was that patterns are communication between people a common way to describe how something is done so don't force your code to patterns. I didn't have to make much notes abot this one because I was so concentrated on observing.

Unofrtunately there aren't anything about this session on the JFokus web site either but here's a few good patterns he demonstrated: Lambda expressions, execute around and function composition. And  these are a few you shouldn't use: Cascade pattern, Java 7 ARM (automatic resource management).

Continuous delivery: From dinosaur to spaceship in 2 years

Story of how SAP's SAP ID Service department brought their tools and methods to this day from Java 1.4 and waterfall methodology. This was a ok session nothing bad but also nothing amazing. I don't think I have anything say that you can't find in the presentation material.

Large scale automation with Jenkins

Introduction to Jenkins plugins that makes Jenkins more than just a CI build tool. Kohsuke Kawaguchi introduced Jenkins plugins for variuous situations like parameterized builds, naming builds, virtual maven repository and some for visualizing build workflows and pipelines. If your using Jenkins or evaluating it I really suggest that you look through the presentation material.

Howto do kickass software development

Great non-technical talk of howto create good software.

So why to deliver kick-ass software? 

To have happy customers of course.

Howto know that you're doing the right thing? 

Fake the software first, do a pretotype e.g. do paper models of web site and see how everything fits together. Constantly gather feedback and remember to answer to the feedback and don't let the project manager filter the feedback but go through the feedback in the development team and let the developers answer.

What about kick-ass development team? 

Traditionally developers are one team and QA is another break this! Make developers test each others code and practise this. Do pair programming with developer and tester or let developer do the testing and tester do the testing and compare notes.

Some other things you can do to improve

Automate builds and testing. This gives you the opportunity to fail fast and to share artifacts. Run your tests concurrently to run them faster. Have a build stategy for unit tests and for performance tests. Examine the statistics of your code, builds and tests.

Howto fail a software project fast and efficiently

This presentation listed almost all the possible things one can do to ensure that a project fails. I can't summarize this presentation because everything in the presentation was important. This is something everybody involved in software development at any level should read through. When you read it through remember to negate everything until you see the stop sign.

Thursday, February 14, 2013

Vaadin meetup

I attended Vaadin meetup with a few colleagues on a way to JFokus 2013 and thought I should share my notes of the two. First post is about vaadin meetup that took place on a cruise from Turku to Stockholm.

I made notes of three presentations and one of them I had high expectations. There were also two other presentations that I didn't make any notes of.

Vaadin 7

Vaadin released Vaadin 7 framework the same day that the meetup was on so they had a presentation where they told about new features and future plans. I'm more of a backend programmer than UI programmer so my notes of this were pretty brief but here it goes.

Whats new

  • Servlets and HTTP-sessions are controllable by the programmer
  • Multiple UI classes
    • e.g. One for web browsers and one for mobile web browsers
  • GWT is now build-in
  • Support for external JavaScript modules

What to expect in the future

  • Faster relase cycles
    • maintenance release every two weeks
  • Dynamic CSS injection
  • Vaadin CDI, their own depency injection system
  • Vaadin charts, for drawing nice charts


This was a project ordered by Helsinki university and it was developed by a company called Arcusys. It's some sort of feedback system. The interesting part of this presentation was why they chose Vaadin framework for the UI. They chose it because it could programmed with Java or Scala and the developers didn't need to have any knowledge of web technologies like HTML, CSS or JavaScript.

Modern software development anti-patterns

Martijn Verburg, Diabolocal developer, had a presentation of software development anti-patterns. This the presentation that I really wanted hear he also had the same presentation later at JFokus. I had high hopes for this presentation and it didn't let me down. I'm just going to write a few buzzwords and notes here and the rest is available on Martijns slides and video filmed at the meetup.
  • Mortage-driven development
    • Write code to pay your mortage and make sure anyone else can't understand your code
  • Distracted by shine
    • Always use the latest and greatest
  • The deity
    • Huge classes e.g. Java class with 140k lines
Those were anti-patterns but he also gave tips how to avoid anti-patterns. 

One of the things he said is something in my opinion every developer should understand and remember. The anti-pattern was CV++ meaning that you try all the new frameworks and tools just so you can put a new line in your CV when instead you should be good at the principles.

So what does that mean. It means know the principles of software developent because languages, frameworks and tools change and evolve all the time but if you know hte principles you can always learn a new language or learn howto use a framework you haven't used before.

All the presentations of Vaadin meetup were filmed and uploaded to youtube. Links can be found at Vaadin meetup website

On the next two posts I'll be what I learned in JFokus 2013.

Wednesday, February 13, 2013

Blogging from snowy Finland

First post on my first blog... Lots to say but can't deside what to say so I decided to start by a introduction of myself before we get into business.

I do software development for a living and that also happens to be a hobby of mine, what a nice coincidence. I work as a IT-consultant and I'm loving it most of the time. I get to see a lot of different environments and solutions but... there's always a but, I also see a lot that could be improved. With improvement I mean cleaner, simpler and easier to understand solutions.

I do most of my programming with Java, but I've had some experience with HTML, CSS, PHP etc. solutions in my past and in the last two years I've done some development with Groovy and modern JavaScript libraries.
Various relational databases have been part of my toolbox since I started web development with MS ASP and PHP over a decade ago. Recently I've also done development with NoSQL databases as a backend instead of RDBMS.
I haven't given a proper try to functional programming languages yet but I'll be doing that in the future first I have to do few other things.

Theme of this blog is going to be various aspects of my experiences and thoughts of software development. Perhaps even some actual code... or maybe I'll just put that in github.