Home > Events > 33rd Degree Conference Cracow 2011

33rd Degree Conference Cracow 2011

polska wersja
The conference has just finished on Friday. Did it blow up my mind? Yes, definitely it gave me a bunch of new ideas and a lot of motivation.
It lasted 3 days (6-8 April) and I have to admit it was one of the greatest conference I’ve ever took part in.
I dare to say it was comparable to Google Developer Day last year in Prague in substantial and organizational aspect. Only that GDD lasted 1 day and was for free, but anyway it cost something to get to Prague by train.
Great thanks to organizers, especially the main one – Grzegorz Duda.
The place where the conference was held – Best Western Hotel – was equipped in everything needed for such event. Maybe one drawback was not enough toilets as there were queues constantly.
During conference we had free access to snacks and drinks all the time – that was really cool, not as on some other conferences when snacks used to go to end quickly.
Organizers took care for bonuses like 40% discount for O’Reilly bookstore, 4-months JRebel license, or lunch pre-order, but the most important – speakers were just great, at least the ones I’ve chosen from among multiple possibilities.
Here come the ones..

Linda Rising – ‘Deception and Estimation’

Linda Rising is an Insights and Experience Reports publisher in IEEE Software magazine. In her first speech she explained what deception is, in other words ‘lying’. People not only deceive other but also themselves. The process begins already in our early childhood, when we hear from the closest family: “Ohh… say how much you love aunt Ellen”, or in our adolescence in relationships – a common question of wife to husband: “Honey, do I look fat in this dress?”. We tend to lie, but in those particular cases there is nothing bad in it. What’s more – it is even healthier than to say an honest truth, e.g. “Yes Honey, you are fat!” 😉

However when it comes to estimation, deception is not such a good thing anymore.

First of all, are we able to make a good estimation? We are hardwired to be optimistic, we refuse to think about a process or information we don’t like, we distort what we see, even if confirmed by mathematical analysis. The smarter we are the more deceptive we are. Max Plack said:

‘A new scientific truth does not triumph by convincing its opponents and making them see the light, but rather because its opponents eventually die, and a new generation grows up that is familiar with it’

We tend to think about ourselves we are superior than other people, smarter, always have right. Often we use some silly things to estimate, e.g. it’s common believe that adding more people to the project should cause more work-force, therefore should bring it to the end faster, however the Brooks’ Law says something different – it prolongs the project. Brooks gave simple example, that “Nine women can’t make a baby in one month” (http://en.wikipedia.org/wiki/Brooks’s_law).

Agile software development says we should divide a project into very small pieces – the smaller, the better estimation.

Finally if we still can’t answer the questions that come up when we need to estimate something we can use a special page prepared for this purpose 😉 http://estimategoat.com

Matt Raible – ‘Comparing JVM Web Frameworks’

Matt Raible is an UI architect specializing in Open Source web frameworks. Matt compared a few frameworks such as: GWT, Spring MVC, Vaadin, Ruby on Rails, JSF, Wicket, Tapestry, Play.

When we start choosing the right web framework for our application we need to get to the right one by eliminating the ones that won’t work for our requirements an leave the ones that fit the best. It often appears that when one framework is excellent for implementation of certain functionality, it completely sucks for others, therefore coming to the choice by additive approach is not the right thing.

When choosing the framework a good idea is to watch a mailing list traffic on the framework’s page – this is a good indicator that framework is alive and people use it. Choosing a framework that is dead means we will have to fix any bugs that we find in this framework ourselves, which is not what we want to do. Web framework popularity report for 2011 can be found at http://www.zeroturnaround.com/java-ee-productivity-report-2011/

Nathaniel Schutta – ‘Hacking Your Brain for Fun and Profit’

Excellent presentation full of ideas on how to boost one’s productivity. From among many, just a few I’ve noted down..

Listener’s brain pattern mirrors the one of speaker and when the listener gets lost, his brain patterns decouple (http://www.zeroturnaround.com/java-ee-productivity-report-2011/)

Our brain is active 24h/7. Even when we sleep our brain still digests, e.g. there is an unbelievable example of Croatian girl who woke up from coma being able to speak German while she’d never spoken it before (http://bit.ly/9t7JW9).

Scientists have amazing achievements on the field of brain analysis, e.g. the first brain scanners that can tell what a person is thinking about are already being developed (http://www.newscientist.com/article/mg20427323.500-brain-scanners-can-tell-what-youre-thinking-about.html)

It’s proven that a short nap can enhance productivity. Thomas Edison was sleeping 4-5 h a day, but he used to make a short naps. He kept a heavy balls in his hands when falling asleep in order to prevent falling into ‘deep sleep’. Whenever he was reaching this state, his relaxed body dropped the balls which fell on the floor noisily making him wake up (http://www.wilywalnut.com/Thomas-Edison-Power-Napping.html, http://dilbert.com/fast/2009-05-26)

There are cases in history of people that managed several days without sleep (http://www.youtube.com/watch?v=nSNRdvusmQs). Nevertheless the sleep is necessary for our body to function properly. Lack of sleep can cause severe productivity loss, even cause illnesses. It’s also proved that genes impact our resistance for sleep, an insomniac gene was discovered at some people that could deal without sleep for a long time.

The whole presentation with many references to external resources can be found at Nathaniel’s page: http://ntschutta.com/slides/Hacking_Your_Brain.pdf

Nathaniel Schutta – ‘Going mobile with jQuery’

Again Nathaniel proved he is a real showmen on his presentations. A few examples comparing native mobile interface with a one implemented with jQuery Mobile (http://jquerymobile.com/) was very inspiring. I will definitely try it out.

Developing interfaces in HTML5 has a main advantage over native ones – we deliver one code for multiple operating systems and multiple mobile devices. The difference in appearance is sometimes almost impossible to spot. Noteworthy is a Pretty Mobile toolkit (http://wdtoolbox.com/prettymobile-iphoneitouch-website-development-toolkit/) mentioned by on of the audience, which is helpful for developing web interfaces that appear nearly as the native ones.

Linda Rising – ‘The Power of Retrospection’

Again Linda proved her tremendous presentation skills, this time on a workshop.

What is retrospection about. In Agile projects it is a term meaning a meetings on which project members meet to summarize the project. Which is important, managers do not take part in the meeting but can see the results of them later on. The results should be anonymous. The retrospection does not necessarily have to be set up at the end of the project but can be more often, e.g. after each sprint.

Main retrospection rules are:

– no naming, no blaming

– do not admit to faults

We talk about the problems and not about people involved in them. We also do not put guilt on ourselves.

There are 4 retrospection questions to answer:

1) What worked and we don’t want to forget?

2) What should we do differently?

3) What did we learn?

4) What still puzzles us?

When we say what we should do differently, we should find out no more than 3 small and easy things to change, even it at first sight they might not bring any solution. Often solutions some itself when the changes are brought into life.

What is nice to have on retrospection meetings is to offer appreciations to the team. Each member says what he liked in other members, e.g.: “I appreciate very much Bob, that when we delivered the project you stayed at work in the weekend when your sun had birthday. Without you we couldn’t get where we’re now”

A technique which helps to spot the things which went right or not during the project is doing a lifetime. What is the lifetime about? Any day during the project duration each member of a team might choose one of 4 colored papers and write on the sheet his/her feelings about that’s currently happening. The papers are: red for anger, green for challenge, blue for happiness, yellow for surprise. The papers are filled in and placed on the wall or floor anonymously during each project phase. At the end of the phase or project when it comes to the retrospection it is clearly visible when the project faced most problems (red cards) or when most ambiguities happened (yellow cards).

Jakub Nabrdalik – ‘Hack your company’

This talk was a set of real life examples of how to boost performance and motivation of employees. Just a couple tips can be:

– weekly/monthly workshops (like code retreat) that last for about 1h

– weekly/monthly lightening talks when a person picks up a technology to present to the others for about 1h

How to convince your boss to spare some time for these activities? One of the statements can be to choose a suitable time when anyway employees are not very productive and usually do nothing, like Fridays around 3-4 p.m. The other is involving inexperienced developers in workshops that can bring about better code quality in the future. Employees gain new skills.

The first day finished with beer party 🙂

On the second day I started with Jevgeni Kabanov – ‘Do you really get Memory?’

A presentation about how JVM works in terms of garbage collectors, different implementations of GC. How JVM memory model looks like (young, ternured, perm spaces). What does ‘volatile’ word means.

The presentation, unfortunately in very low quality, can be seen here:

http://www.youtube.com/watch?v=-KlYKIXBdHw

http://www.youtube.com/watch?v=lE5djOLKTjg

http://www.youtube.com/watch?v=it9I5bIzktE

Hamlet D’Arcy – ‘Java Boilerplate Busters’

An overview of such Open Source libraries like:

Google Guava

Apache Commons

The libraries help to write a clear understandable code that is effective instead of ‘discovering the wheel’ ourselves.

Dan Allen – ‘Arquillian: Real Java enterprise testing’

Started with some problems with his laptop with about 15min delay but eventually led an interesting speech about testing enterprise application in their real environment instead of isolation (e.g. embedded container).

The tool used for this purpose is Aquillian from JBoss community together with Shrinkwrap.

Patrycja Węgrzynowicz – ‘Patterns and Anti-Patterns in Hibernate’

I expected something more on this speech. It was an introduction of a few real life problems with transaction isolation, query performance and errors.

This was something that I already knew before, therefore not much gain for me form this presentation.

Jarosław Pałka – ‘Architecture and programming model for NOSQL web’

Presentation in Polish. This was a first time I’ve seen NOSQL used in real life project, therefore very interesting. Source code of the examples shown on presentation can be found at https://bitbucket.org/kcrimson I’m looking forward to find some free time to experiment with it myself. Another external resource for NOSQL knowledge pointed in presentation is http://nosql.mypopescu.com

Jarosław show how to connect NOSQL value-key store with traditional RDBMS. Also a discussion on using Neo4j in commercial applications proved that NOSQL trends will gain more and more interest in the coming days.

As I’m interested in the new approach since not long ago I was happy to find even more topics around application scallability and NOSQL in next presentations.

Matthew McCullough – ‘Monitoring 10 Critical Code Quality Metrics with Sonar’

Matthew presented an interesting tool – Sonar – an enterprise application for code analysis with web interface. The tool is 90% Open Source. The rest part has a commercial license. It is extend-able for new plugins, recognizes multiple languages (even COBOL, that made me surprised) and looks cool for code reviews. User can easily navigate from analysis to affected lines of code.

Moreover the tool goes with Eclipse plugin that can be synchronized with server. In Eclipse you can easily navigate to problematic code, make a correction and submit the change.

Server application can be integrated with SVN or Git for code version control and Hudson for continuous integration. It also integrates with Apache Ant and Maven.

Google charting is used to present most common developer sins which appear in the following domains:

  • size/complexity
  • unit test
  • duplication
  • coding rules
  • potential bugs
  • architecture
  • comments

Nathaniel Shutta – ‘Agile UI’

Again a great speech. This time about usability of design. A few ordinary life bad but funny designs were presented. The main idea about UI design is to put yourself in the shoes of end users. Where do they work? Is there noisy? Is there light?

The software should be intuitive. What happens is we don’t watch the signs or misinterpret them? (http://www.slate.com/id/2245644)

The slides with more external references are at http://ntschutta.com/slides/Agile_UI.pdf

The second day finished with Hackergarten. This is a name for a meeting on which developers gather to work on different open source projects. The idea is to finish the meeting with a commit. This not necessarily has to be a piece of code, but also documentation, podcast, etc. It must be something that brings some value to the project.

Interesting experience as I’ve never done sth like this before. It’s a great chance to meet new people, see how they work and exchange knowledge.

Nice that we were supplied with food and beer for free 😉

The third day I begun with presentation of Karl Rehmer – ‘How Debuggers Work’

Unfortunately my level of knowledge on debuggers design and operation didn’t allow me to grasp too much from this presentation. However what I remembered is that Java debuggers differ a lot from other languages that run directly on OS (that use DWARF).

Java debugging does not use addresses or machine code. They use JDWP (Java Debug Wire Protocol) or JDI (Java Debug Interface) to communicate with JVM. These can be useful not only for debugging but also for any analysis of runtime such as getting the constants pool, intercepting executed methods, etc.

Costin Leau – ‘Using Spring with non relational databases’

Costin can be found at http://twitter.com/costinl

Another dose of knowledge on NOSQL trend. This time showing Spring support in this domain: http://www.springsource.org/spring-data

It provides extensions for key-value stores (Redis, Riak), document stores (MondoDB, CouchDB), graph stores (Neo4j) using AspectJ to provide transparent POJO persistence. An example of Neo4j usage with Spring is Restaurant Social

Spring has also support for Apache Hadoop – software framework for intensive data processing.

Matthew McCullough – ‘Hadoop: Divide and Conquer Gigantic Datasets’

This was an introduction to Apachee Hadoop. Matthew showed on VMware image that everyone can download from http://www.cloudera.com/downloads/ how to use Hadoop.

Hadoop is ideal solution for systems storing huge files of approximately 1TB size. The larger data sets the more performing is Hadoop.

Data is distributed among multiple servers but it’s transparent to the and user who can execute common shell commands (in fact these are Hadoop commands) e.g. to list files, count words in text content, etc. as if the files were stored on localhost. User can also write own map-reduce methods in Java used to process distributed data.

Hadoop was inspired by Google MapReduce framework and Google File System. The document describing GFS is available from http://labs.google.com/papers/gfs.html

I’m going to explore the VM ware from Cludera soon 🙂

Neal Ford – ‘Abstraction Distractions’

The presentation can be seen at http://www.jfokus.se/jfokus11/preso/jf11_AbstractionDistractions.pdf

Neal underlined an importance of wider look at the problems. The abstraction can never be as good as the original thing. The abstraction which is good now, can appear to be completely ridiculous in the future, e.g. in the past it was believed that the Earth is in the center of universe and any other idea was aggressively refused. Similar idea – how to persist some important information so that it survived decades. E.g. first computer programs ware stored on perforated tapes. One of the programs that lasts for decades and is still used is Emacs editor. It’s  original source code is still stored on the perforated tapes but to retrieve it the machine to read perforated tapes would have to be build.

People undertake steps to create solutions that will be valid over centuries, one of these is a Long Now project that is to build a giant millennium clock http://longnow.org

Another example of abstraction (from many mentioned by Neal) can be e-mail storage system. For years mail clients used to store messages sorted in folders structure until GMail appeared with an idea to assign tags to a message. The message can have multiple tags, it can be connected to multiple contexts which is a lot more natural than putting it into only one folder (of course we could create different copies of the same message and distribute it among different folders, but isn’t it an unnecessary complication when compared to the abstraction on GMail?)

The resources recommended to read in the speech include Paul Graham: ‘Hackers and Painters’ as well as Gef Roskin: ‘The Human Interface’ books.

Neal mentioned also a Blub paradox which can be explained as a problem of ignoring new things, e.g, ignoring the programming language which a developer does not know. The developer is familiar with a language he uses daily and all new stuff sucks for him.

Michael Nygiard – ‘Architect for Scale’

Michael spoke about large scale systems, partitioning and scalability. Again in this context NOSQL appeared and CAP theorem. Basically partitioning is about fewer number of nodes within cluster and larger number of clusters.

Systems can be partitioned e.g. geographically, functionally.

Amdahl’s Law was compared with Universal Scalability Law.

This was already the last presentation I could attend. I rushed for the train back to Lodz afterwards.

Conference home page

Advertisements
Categories: Events
  1. you
    April 20, 2011 at 20:56

    Me encanta su recurso posts. Awsome.

  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: