Tag Archives: conferences

Strange Loop 2013

Clojure, Programming, Science

This year I had the pleasure to be at the Strange Loop conference in Saint Louis. Here’s a brief recap of what was happening there.

Preconf: Emerging Languages Camp

On the first day I sat in about a dozen presentations related to “emerging languages”. The good ones:

  • Daniel Gregoire – Gershwin: stack-based, concatenative Clojure. There were a few presentations of stack-based languages here, but in my opinion this one was the best. It’s been the first time I actually heard about such languages. Not very practical, but quite an interesting excercise none the less.
  • Bento Miso – Daimio: a language for sharing. An attempt at creating a language for creating web plugins, with sandboxing, clear and isolated execution spaces, interactions defined in in/out ports… A bit too hard to follow though..
  • Andreas Rumpf – Nimrod – very good presentation of quite interesting and well thought out language intended mainly for game development. Reportedly fast, very expressive, decent compiler with macros and some serious compile time optimizations… Worth a look.
  • Walter Wilson – Axiomatic Languages. Interesting, very theoretical approach to programming. Define programs in terms of axioms and logical reasoning. Want to sort a list? No problem, just define what it means for elements to be ordered and what a permutation is, then say that the desired output is a permutation that is ordered. Rather academic.
  • Tracy Harms – J. The joke says it’s been an emerging language for 23 years. I’ve never been able to get it (not that I tried much), and this presentation was a very good introduction. It included and decently explained a lot of the syntax as well as the underlying flow and concepts. Quite unusual and interesting.
  • Bodil Stokke – BODOL. This gem was one of the wildest things that I’ve seen not only on this conference, but also in my professional life. Ponies, pattern matching, logic programming, lambdas, monads, types, parsing, programming language theory, live coding… All running from Emacs.

I also attended two unsessions.

  • One was a live recording session of the Think Distributed podcast. 4 smart folks took questions from audience and shared their thoughts on testing, programming, handling failures etc. in distributed environment. Worthwhile.
  • The other un-session was largely based on the she++ documentary on bringing women to programming (and technology in general). Important problem that reappeared a few more times at the conference. It’s worth mentioning, though, that Strange Loop had an unusually high number of female speakers. They might have been preferred in some ways, but nonetheless delivered many awesome talks and the gender did not really matter.

Day One

  • Jenny Finkel – Machine Learning for Relevance and Serendipity. In this opening keynote we got to learn some of the challenges behind Prismatic. (If you haven’t seen Prismatic yet, do it now. It’s awesome.). Very good insights on the discovery problem, machine learning, collective intelligence, user behavior, statistics…
  • Jason Gilman – Visualization Driven Development. One more stab at the problem of using visual aids in programming. This time more like: Tired of waiting for the tools? Roll your own, very custom for the code you’re currently working with.
  • Philipp Haller – Scala Async. I don’t really do Scala, but I liked this presentation a lot. Solid, elegant presentation of upcoming features of Scala for async programming (inspired by F# and C#). Lots of good code, easy to follow examples and great explanation of the matter.
  • Craig Andera – Real-World Datomic. A little bit of a case study, much insight into design and usage of the database. We got to learn about designing and representing the domain model, all the index types and their use cases and some other internals of Datomic. Great talk.
  • Rich Hickey – Clojure core.async. Very, very good presentation not only on core.async (which I’ve never actually used before), but also on asynchronicity in general, CSP, performance, code expressiveness and cohesion… Not so much syntax and case studies, more of a solid explanation of reasons and usage of the library. Plus Rich is as brilliant a speaker as he is a creator.
  • Craig Muth – Xiki: GUI and Text Interfaces Are Converging. Demonstration of a nice… engine (?) for doing all kinds of things from plain text files or just a text editor: GUI prototyping, using git, databases, rails, file system navigation. Very impressive demos, but is it practical? Seems like it may need a good deal of Emacs-fu or a few dozen keyboard shortcuts to do effectively.
  • Joseph Wilk – Creative Machines. The presenter shared many different attempts to get the computer to create music (as well as some examples of work done by others on this topic). All this trying to answer whether machines can be creative, what it means to be creative, how does human creativity work and whether it can be reproduced by a machine. Passionate, well-delivered and thought-provoking, even though I do not fully agree with the conclusions.
  • Jen Myers – Making Software Development Make Sense to Everyone. Very passionate keynote on encouraging women to technology. Talking about iconic heroines of the past (Sally Ride, Nichelle Nichols), as well as something closer to our field and time. Jen presented the “little”, things that she is directly involved with at the moment (Dev Bootcamp, Girl Develop It), as well as shared her vision of a future where hopefully it no longer will be necessary.

At night there was a wild party in the City Museum. Warehouse turned to museum with lots and lots of industrial or fossilized attractions: High and twisted slides, caves, hanging bus, ball pit, crazy places to crawl and walk and lie and sit everywhere (ceilings, floors, going in all directions). Everything adult sized, and boy were those geeks happy as kids to do all this stuff. Last but not least, it was accompanied by very appropriate cave/jazz/dubstep band Moon Hooch. Words can’t really describe it, you had to experience it.

Day Two

  • Martin Odersky – The Trouble With Types. The first half of this keynote was a dense study of type systems in various languages, including the tradeoffs of dynamic vs. static and strong vs. weak. Martin did a great job explaining why Scala is looking the way it is, and why he thinks a strong, static type system is the way to go. The second half delved deep into Scala and to me was too abstract or needed too deep knowledge about Scala. Still, Odersky is a great speaker and thinker. Bonus points for the joke that Rich Hickey could take those slides and give the same talk and treating us to Bach.
  • Avi Bryant – Add all the things: Abstract algebra meets analytics. Very good presentation with very practical examples of how thinking in basic mathematical terms can make software development easier. It showed how you can apply the group theory to data aggregation and storage. It also had a few interesting tricks generally related to the area of data collection and analytics. Great presenter.
  • Crista Lopes – Exercises in Style. Take one problem (word count in text file) and solve it in one language in several different styles, every time deliberately taking some very specific constraints. Spaghetti script, procedural, functional, continuation passing style… Great exercises, worth a look (much bigger book coming out shortly). Unfortunately, was too slow in the beginning and had to cut a few examples later.
  • Brenton Ashworth – Web Apps in Clojure and ClojureScript with Pedestal. Good talk demonstrating and explaining Pedestal. Might have been a little bit too abstract, but I guess you can only fit so much in one hour. Included an impressive dashboard demo (great user experience and data visualizations).
  • David Pollak – Getting Pushy: Pushing data from server to browser. The creator of Lift, appropriately dressed in a lab coat, did a very good job talking about client-server (or server-client?) interaction in web apps. It involved communication in both directions, nicely encapsulated in one accessible piece that solves all the pain of possible failure modes in HTTP and network itself. Included very slick demos in AngularJS and Lift, as well as a little experiment in Clojure (Plugh) based on core.async and clang. Very good.
  • Josh Bloch, Bob Lee – Java Puzzlers, Strange Loop Edition. A handful of entertaining puzzles that often can suprise even veteran Java developers. Java specification seems to have infinite amounts of craze corners, apparently created only so Josh can have fun with the puzzlers.
  • Chris Granger – Finding a way out. The inventor of Light Table unveiled another interesting project supposed to make programming different and more accessible: Aurora. It made for some very slick and impressive demos, but it’s far from finished or usable as an end-to-end product. This time it looks like the target is not a developer of complex apps, but rather the “spreadsheet programmer”. Really nice, but not sure if very practical, and it would be great to actually see a finished, polished environment (Aurora or Light Table).
  • Douglas Hofstadter – What is a strange loop and what is it like to be one? Very good closing keynote, related to Hofstadter’s books. Impressive speech on life, perception, abstraction and consciousness.
  • David Stutz – Thrown for a Loop: A Carnival of Consciousness. Performance/theater very closely related to the preceding speech and Hofstadter’s works. Good deal of discussion of the material and immaterial, self-consciousness and imagination. Appropriately included variations of Goedel theorem, Escher graphics (plus a good deal of Emacs) and live play of Bach fugues by a brass quintet. Plus some very pleasant acrobatics. Very spectacular and unusual, I wish my English sucked less so I could get more of it.

Final Thoughts

I’m using the words “very good”, “great” and “impressive” all the time. It’s boring, but it doesn’t even do justice to the quality of talks and the whole conference. I had very high expectations for the whole thing, and I tend to be hard to please, yet the reality was simply a dream come true.

In some ways the conference was surprisingly minimalistic – I did not even get a note pad or printed program, no sponsor adverts, well nothing except for the ID badge, breakfast at the hotel and cold catered lunch. On the other hand, we got the wild party at the City Museum, the conference venue was very spectacular and comfortable, not to mention the speaker list. I do not mind the tradeoff at all! That’s the way to do it – cut the semi-important stuff to minimum and spend all the money on what really matters and becomes a truly unforgettable experience. Hats off to Alex Miller for putting it all together.

JDD 2012

Programming

Last week I attended the JDD 2012 conference. Here’s a bunch of very quick notes from the talks.

  • Rebecca Wirfs Brock, Joseph Yoder “Pragmatic, Not Dogmatic TDD: Rethinking How We Test” – nice presentation about TDD, felt a bit like theater (dialogue between two presenters). A few good points to show that TDD is not only about the fast red-green cycle (anyone thinks so, by the way?). Little gem: Use pomodoro specifically to break the flow, take a step back and look at the big picture.
  • Jarosław Pałka “The deconstruction of architecture in times of crisis” – very good talk about applying system thinking to software development. The theory is fairly well applicable to our craft, and the interdisciplinary view helps you see it in different perspective. Briefly explained some pieces of the theory as well as a few concrete examples (tragedy of the commons, boiling frog syndrome). I only found one important bit missing: Theory of constraints. Suggested reading: Thinking in Systems: A Primer.
  • Jakub Kubryński “Microbenchmarks performance in the smaller scale” – difficult choice (in conflict with Jessica Kerr’s FP/OOP talk), but I went for this one since the topic was less familiar. And I don’t regret it. I learned a ton about Java execution model: The role and place of JIT, possible optimizations, and finally the impact on microbenchmarks (and ways to do them better).
  • Sławomir Sobótka “Evolutionary Distillation of Architecture” (in Polish, I took the liberty of translating the title) – introduction to ports & adapters (aka hexagonal architecture). As usually, served in a broader context on thinking about how we code, what tools we use and why we should constantly learn new ones. As always, very entertaining, professional and inspiring. Little gem: If someone only knows entity and service, he’ll go at great lengths implementing everything with just those two concepts. Related reading: Hexagonal Architecture by Alistair Cockburn.
  • Piotr Bucki on cross site scripting attacks – nice presentation on XSS, discussing various ways to protect an application: input sanitization and validation, escaping on input and output, white list filtering for places which need to allow special content (like auction descriptions with limited HTML). Conclusion: Sanitize and validate input, escape everything on output. Careful, include all directions and outputs – validate batch import from files, don’t even trust your own logs (someone could deliberately execute an invalid request to have it logged, and then XSS into your admin log viewer). Solid, though not spectacular talk.
  • Wiktor Żołnowski “Reversed Tests Pyramid ? dealing with legacy code” – great idea on approach to testing legacy code that can’t easily be covered with unit tests. Start with end-to-end tests (in bigger number that would otherwise be necessary) to gain some understanding and confidence in refactoring. Write more and more lower level tests as you refactor. Eventually throw away slow higher level tests as they become redundant and invert the pyramid as it should be. Quite fun, felt almost like a BOF session (appropriate for the evening). Hated one bit: Looking down upon the audience and repeating “I moved from development to coaching a few years ago”, “This is probably not interesting to you, developers” etc.
  • Thomas Sundberg “How to fail a software project fast and efficiently?” – pretty bad presentation. Could’ve been fun and sarcastic, but was really shallow and dull. Very little content, no argumentation.
  • Adam Bien “Java EE Future Is Now, But It Is Not Evenly Distributed Yet” – positive suprise! Went there just because I know so little about recent JEE and wanted to see something new. Very professional and dense. On our eyes Adam built a JEE app from scratch that demonstrated dependency injection (including configuration/params), differences between EJB and non-EJB life cycles, JSF, asynchronous execution (comet), event propagation… Very good mix of humor and live coding. Repeat, that was one spectacular live coding. I expected some fanaticism, but got none of that sort – some respect to Spring and others, but actually focusing on showing how JEE became lean and cool, not bashing the competition.
  • Patrycja Wegrzynowicz “Security Vulnerabilities in OpenSource Java Libraries” – stats done bad. Most of the presentation was a view statistical views on data for number of vulnerabilities discovered in various libraries and app servers. Ignoring information on how quickly the holes are patched (or whether there are workarounds known to community), it literally contained information such as over X years 100 issues have been discovered in Tomcat, 20 in JBoss, so Tomcat is much more likely to be insecure. But app servers from IBM and Oracle are even worse, they’ve had more issues discovered over so many years.
  • Hardy Ferentschik “JPA into the Cloud Introducing OGM and OpenShift” – demonstrated an experimental Hibernate extension to persist JPA to NoSQL databases (and deploy that to cloud using OpenShift). Not yet production ready, has some rough edges and I’m not completely sure why you’d want to do that. Anyway – challenging, interesting, well prepared and presented.
  • Gustaf Nilsson Kotte “Surviving the Zombie Apocalypse of Connected Devices” – proposal to use HTML hypermedia as the data format for all kinds of environments. Create a basic HTML model that can be viewed by any browser (leverage the fact that browser can display HTML data in a nice way). That can be used directly as default for most non-critical screens. For more interesting (or critical) areas or environments, use HTML merely as data format and build an app on top of that. We have tools to parse and generate HTML, so why not use it as data format? Very interesting idea – instead of REST and all kinds of unprintable data formats, use a popular format that has decent support and can be displayed by any device. The talk was pretty hard to follow, though – too calm and sleepy.
  • Jessica Kerr “Git Happens” – very good talk on Git to close the conference. No live demos, very good explanation of basic concepts. Not just the happy path, and not overly optimistic. Also, Jessica is an excellent speaker – passionate (sometimes to the point of running, screaming and damaging equipment), but also with a very good plan and attention to detail.

All in all, I’m quite satisfied with this conference. Like any, it had some low points and on one or two occasions I skipped the talks because there was nothing interesting to me in that hour. Feels small and local compared to 33rd Degree, and doesn’t have the community vibe of Confitura, but certainly has its place. Anyway, I learned a few new things, most of the presentations were good and a few were great, so it definitely was worth it.

DevDay 2012

Life, Programming

On October 5, 2012 I attended the second edition of DevDay, a one-day conference sponsored and organized by ABB in Krakow.

The Awesome

Scott Hanselman was the first speaker, and also one of the main reasons why I went to the conference. Even though I only knew him from This Developer’s Life.

His “Scaling Yourself” talk was probably the best productivity talk I’ve seen so far. Part of it was tricks and techniques I have already known, such as GTD and pomodoro. Apart from that, my notes include:

  • The fewer things you do, the more of each you can do.
  • By doing something you are likely to get more of it. If you’re available on weekends and after hours, you will be expected to do it. If you’re available for calls about work on vacations, you will be called. Even if you do work at that time, set that email to go out at 9 AM next business morning.
  • Avoid “guilt systems” such as long collection of recorded TV shows – or books, or unread articles. Or whatever it is that you collect and want to do, but eventually forms a big pile that you only feel guilty about.
  • Sort your information streams by importance and limit usage. Some obvious ones like do less Twitter or Facebook. Some less obvious ones like basic email filters. Combine that with techniques that help you root out the distractions such as pomodoro or Rescue Time.
  • Use information aggregators: Blogs or sites that repost articles, mashups etc. instead of subscribing to 100 different blogs and news sites.
  • Do not multitask, except for things that go well together. Foe example, exercise while watching TV or listening to podcasts. What’s more: use activities you want to do to motivate things you should do. For instance, watch TV only as long as you keep on moving on the treadmill.
  • Plan your work: Find three things you want to do today, this week and this year, and do them. Helps you set the focus on goals. Hint: Email & twitter probably won’t be on the list.
  • Plan your work: Plan your own work sprints, execute, and finally perform retrospectives. Can be applied to work, but also all kinds of personal activities.
  • Synchronize to paper. Don’t limit your space to one screen when you can print or write/draw it on as many sheets of paper as you want. Also, paper notebooks can be used in different conditions and never run out of battery..

Finally, Scott is a great speaker. Lots and lots of content served in a perfect way, sauced with some pretty good jokes. Delicious.

That’s just a bunch of quick notes. Even if you think you’ve heard enough on the topic of productivity, go watch the presentation on Scott’s site. Now.

The Good

I enjoyed the “Why You Should Talk to Strangers” talk from Martin Mazur. Half of it was about social interactions: “us versus them” divisions, difficulties that one can face when approaching complete strangers in public, and the amount of new things you can learn from them if you break the ice. The rest was really about polyglot programming: learning Eiffel, Haskell or Ruby and applying some concepts and ideas back to C#. Largely an unknown territory, but still the talk resonated really well with me.

Antek Piechnik gave a good talk on continuous delivery at an extreme scale: Where each new team member pushes code to production during the first week, and each commit to master can trigger deployment. I found the ideas on project organization pretty controversial, though: having a totally flat team, large pool of features and everyone working on what they want and how they want. Sounds interesting, but it’s only possible if you have only experienced A++ programmers in team that also have the same vision, agree on tools and techniques, and so on.

Finally, I liked Greg Young’s talk on getting productive in a project in 24 hours. The talk was nothing like the subject, though. Basically an introduction to code analysis: afferent/efferent coupling, test coverage and cyclomatic complexity, as well as data mining VCS. Very clear and down-to-earth, discussing some tools and practical examples for each concept.

I particularly liked the points on code coverage. I knew that method with 20 possible paths can have 100% line coverage from 2 tests, but still be poorly tested. Greg made a good point explaining that method coverage gets worse as the number of methods/collaborators between the test and the method grows, or when the methods between the test and our method have high cyclomatic complexity. In such cases it’s really an accidental coverage that in no way guarantees security.

Greg repeatedly stressed how all these concepts are only tools. They indicate interesting areas that may be trouble spots and may need attention. But one can never say that cyclomatic complexity of X is good code and Y is bad code (and the same is true for all other metrics).

The Rest

Rob Ashton’s talk on JavaScript was alright, but not spectacular. I did not learn much new. I know that the language is here to stay, for better or worse. You can patch some gaps with jslint/jshint and others with CoffeeScript, but for its spread the tooling is really patchy and barely existent.

I skipped Mark Rendle’s talk on Simple.Data/Simple.Web. Not my area.

I really did not like Sebastien Lambla’s talk on HTTP caching. Noise to signal ratio approaching infinity. Filled with poor jokes and irrelevant comments. Little, chaotically and patchily discussed substance.

Wrapping Up

All in all, DevDay was a good conference. Really good selection of speakers on a free conference, with free lunch, coffee and snacks. No recruiters, no stands, just the participants and speakers. I wish it had at least two tracks and more focus. I’m not sure if it’s a generic developer conference or a .net event (went for the former, felt atmosphere of the latter).

Confitura 2012 & “Boring” Application of Clojure

Clojure, Programming,

This year I attended the Confitura conference for the first time. Many posts have been written on it, so I’ll focus on one (but not the only) presentation that I found particularly worthwhile.

Clojure…

I started my day with talk on Clojure as HTML Templating Language by Łukasz Baran. Despite all the advocacy for Clojure that I do, I was surprised to find this presentation in the agenda – specialized, concrete talk instead of a generic “Clojure is awesome! Go use it!”. Another surprise came from the fact that someone in Poland was serious about using it commercially. I suspect I wasn’t the only surprised person there, as there were a few dozen people in the room and only few of them used Clojure or even functional programming.

Łukasz showed how you can use Clojure for HTML templating in Java projects. He described a team which moved from Velocity to Clojure ca. 2009. They created a DSL for HTML similar to Hiccup (before Hiccup became popular), and went a step further implementing a component library and other automations. From the very beginning they assumed it would be called from Java, so they wrote a loosely coupled component that you can plug in to Spring. Finally, they’ve been using it in production for years and are very happy with it.

Why do this, and why this way? Compared to Velocity, Clojure is very fast, concise, powerful and productive. It has gentle learning curve (when narrowed down to DSL). It was much easier to introduce Clojure in a big enterprise Java shop this way than to write purely Clojure projects from scratch (this may be a good approach in general, by the way).

Personally, I really liked it that this presentation was limited to such a boring, but concrete area. Everyone knows something about writing view layers in Java webapps. Everyone knows pains of JSP (Velocity & other frameworks or not). This presentation showed that it can be done differently and the pain points can be mitigated. It also was a great proof that Clojure has its place and is no academic black magic. In other words, advocacy done right: Instead of showing off the new tool from an ivory tower, demonstrate how it can solve a concrete everyday problem.

… and the Rest

That was not the only good thing at this Confitura. In fact, I really enjoyed most of the talks I saw there.

Paweł Wrzeszcz gave a very good presentation on How to work remotely and don’t go crazy. He showed many good habits for teams and individuals that let you live a healthy life in a healthy project. Though my personal conclusion is that even if you do everything right as an individual, team culture can kill and sometimes the only way out is… out.

I saw two talks on testing, by Jacek Kiljański and Tomek Kaczanowski. Jacek seemed to be a young passionate who believes in everything he says, but also had a well prepared presentation on Clean Tests with clear message and good examples. The following talk by Tomek was quite different – felt more like a rational, sometimes skeptical veteran sharing war stories. It may be due to my tiredness or combination of high temperature and low oxygen, but I did not find this presentation as sharp and clear as the previuous one. Part of the story might be that Jacek stole Tomek’s thunder and there was much overlap.

After a break I went to Maciek Próchniak’s talk on Scala, CQRS and Event Sourcing, but I was rather disappointed. It was pretty chaotic and shallow. I suspect that if you had a slight idea of CQRS and ES, you could not learn much new – even though the problem at hand had some depth that could be discussed in more detail. On the the hand, it assumed too much of the listener to be suitable for a beginner.

Then I saw Sławek Sobótka’s presentation about Soft aspects for IT experts. It was centered around Dreyfuss skill acquisition model (again, and even Sławek admitted it’s something that appears a few times at each conference). Still, it managed to offer something new by only treating the model as a framework and an excuse to dive into many interesting aspects of psychology. Very professional, enjoyable and worthwhile.

Our day ended with Wojciech Seliga’s keynote titled How to be awesome at a Java developer job interview. Less of a talk, more of an emotional rant, but most of the time I really agreed with the presenter. I know way too many careless, ignorant people who consider themselves experts and neglect common tools and practices, stopped learning years ago or simply don’t know what they’re doing.

All in all, it was a very good conference. More technical and low-level than 33rd Degree. By no means “worse” or “better”, just different. Felt like a family get-together, rather than a big conference with big names talking about big stuff that put things in perspective or show some trends, but are somewhat detached from our daily work.

33rd Degree 2012

Clojure, Life, Programming

After great success of the first edition of 33rd Degree I did not really need anyone to convince me to participate this year. I can honestly say that I’ve been waiting for it for a year, and it definitely was worth it.

Day 1

The conference opened with three keynotes. The first speaker was Raffi Krikorian from Twitter who spent good deal of time explaining what Twitter really is: A gigantic event pump that consumes massive amounts of messages and broadcasts them as fast as it can. He also provided a very coarse-grained look over some pieces of their architecture, including heavy use of parallel scatter-gather algorithms even for fairly basic tasks like rendering a timeline. Another interesting bit was their own Finagle library for asynchronous networking with all the fancy stuff of failure detection and failover/retry, service discovery, load balancing etc. Worth noting is that Raffi did not say a bad word about Rails, but only explained why it did not scale to their level.

The second keynote was Ken Sipe talking about the complexity of complexity. I am not sure who was first, but I’m under the impression that this talk was in many ways similar to Rich Hickey’s Simple Made Easy, except for that it was a lot more fluffy. Rich had a very clear point to make and he did it perfectly, with witty and merciless criticism of some flavors of agile as a little cherry on top.

The third keynote was Venkat Subramaniam on Facts and Fallacies of Everyday Software Development. Addressed to pointy-haired bosses (including inside each one of us), it challenged some common opinions like trusting “proven technologies” (read: fossils or large vendors) and advocated polyglot programming (he can’t help but do it even when he talks about “pure Java”). Hardly anything new, but Venkat’s beloved style still made it an entertaining talk.

After those keynotes we got smaller presentations in parallel tracks with some hard decisions to make. I wish I went to Matthew McCullough’s git workshop. Instead I wasted some time looking at JFrog presentation by Frederic Simon (I expected some interesting stuff on continuous integration & delivery). Sadek Drobi’s talk on Play and non-blocking IO was quite OK, but I did not really buy the product. It may be because I’m not into Play, but I found the solution somewhat overengineered and much less appealing than Finagle.

The last technical talk of the day for me was Wojciech Seliga’s piece on tests around JIRA. Those guys are quality nuts, but I can honestly say I would feel really safe and comfortable in this environment. He explained all kinds of unit tests that they have: Regular “boring” unit tests, integration tests (including talking to other Atlassian products), functional tests and platform tests. Even though most of the functional tests run against an API (and only some on Selenium), testing the whole system takes many hours on a 70-worker CI cluster, and they still do it on each and every commit. That is mostly because of platform and performance tests, where they meticulously test against all kinds of platforms: combinations of OS, architecture, DB and whatnot.

Wojciech openly admitted that sometimes it takes them days to make a build green, but they are still very rigorous about it. He also shared some good tricks. Tests are very neatly organized in categories and you can drill down to see what exactly is failing and why. Failing tests go to quarantine in order to keep developers from assuming that there is a false negative that can be ignored while there can actually be other issues making the build fail. Once something goes into quarantine it’s either fixed or eradicated, there is zero tolerance for failure.

Day 2

I started the second day with Barry O’Reilly’s talk on agile & lean startups. I expected much fluff, but I actually learned a few interesting things. We all now the agile/lean cycle of (rougly speaking) iteratively inventing, creating, testing and evaluating, and we got to hear about it here as well. What was interesting and new to me though was how much you can do in the market research field. Two good examples include: Create very detailed portraits of your potential users, to the point where you can actually imagine this person as if you walked their shoes, feel their needs, think how they may want to use your product etc, eventually leading to detailed sketches and scenarios. Consider several distinct portraits and see what functionaliy and user experience emerges. The second idea that sounds crazy to my introvertic self is actually going to the street, cafes etc. and asking strangers about their needs and opinions. Reportedly they love it (“Building new Facebook? I wanna be a part of it!”).

Then I listened to Matthew McCullough’s presentation on economic games in software (and life, actually). Perfectly prepared, rich and fluent, easily one of the best speakers I saw in action (even when he’s coding, like last year on git and hadoop). Matthew touched a few topics: Money is not the only (and not the most important) part of the equation. It may be better to live in a nice place with your family and friends around you than to be paid $300/hour and work on the South Pole. It goes the other way round as well: If you hire people, make sure you motivate them in other ways – create a great environment, listen to their needs etc. Speaking of money, he also explained some tricks that are used on us every day – such as shaping restaurant menu or software license pallette so that they have some ridiculously overpriced things that no-one would buy only to make you buy other overpriced (but cheaper) products.

Enough soft talks, next one was Venkat Subramaniam talking about concurrency, reportedly in pure Java. Started off with a seemingly trivial synchronization issue that is very hard to do right in Java and easily generates a ton of boilerplate. Then he went on to resolve it in a few lines of Clojure (surprise, surprise), explained the concept of STM and went back to Java, resolving the original problem using this little concurrency library (yes, Clojure in Java). Very witty and entertaining, and even though I know some Clojure I wasn’t aware how easy it is to get it to work for you in Java. It really can be just an accessible concurrency library!

Next on my schedule was Sławek Sobótka’s talk on basic software engineering patterns. I enjoy most of the works that he publishes on his blog and the live presentations. This was no exception, even if most of the stuff wasn’t new to me. In short, it was a gentle introduction to some ideas behind DDD and modeling. From basic building blocks (value objects, entities, aggregates) up to operations (services) and customization (policies), all neatly organized in clear layers and levels. Professional, clear, fluent and to the point.

Then I saw Ken Sipe’s presentation on web security, which was basically a run through OWASP Top Ten threats. Unlike the keynote this one was little fluff much stuff and taught me something about common security issues. I knew most of the threats, but never really went through the OWASP list myself. Very good and thorough presentation, complemented by personal stories and interesting digressions.

Venkat Subramaniam showing Scala in a terribly overcrowded room was the last thing on my agenda for the day. I’ve never done anything in this language and I found this presentation a very gentle and interesting introduction. Looks like something between powerful but chaotic Groovy (that feels more like a scripting language to me) and old and baroque Java. I could actually give it a try, though I am yet to think of an applicable project.

Day 3

I kicked off the last day with Jacek Laskowski’s talk on Clojure. It clearly was not possible to show all the interesting corners of the language, but I think he did a good job at explaining the very basics as well as some concurrency concepts. It could have included more details or examples on why we would want to use those concurrency constructs, but still it managed to spark some interest (and not scare people off), and that alone is a big win.

Then I listened to Bartosz Majsak talking about Arquillian – a JBoss library for running higher level tests (demonstrated on Selenium-driven acceptance tests) using mock classes in a managed container. Quite interesting, I may give it a try when I get to play with JEE webapps.

The last strictly technical talk of the day was Nate Schutta on HTML5. Nate asked the audience which parts of the stack they are interested in, and after the introduction went over what we were most interested in: Canvas, client-side data storage and worker threads. Very good, fluent talk, explaining the foundations and history behind HTML5 and complemented by practical examples.

Finally we got three keynotes. The first one was Nate Schutta on code craft. Just like you may expect from keynote, it was a mile wide and an inch deep talk about code and work quality. Keep it simple, keep it short, write tests, don’t reinvent the wheel, get and respect feedback… you know it. Professional and interesting, but immediately forgettable. Things to take away: PMD, Clover – run them regularly, radiate information and encourage others to participate in improvement. Culture kills.

Second keynote was Jurgen Appelo telling us how to change the world. It was very well prepared, starting with a witty and masochistic self-introduction, but then it continued to explain a 4-tier model of influencing people:

  • Work iteratively and reflect on your progress, for example using the classic Plan-Do-Check-Act approach.
  • Understand and drive individuals. Make them aware to the idea or product. Make them desire it by making it challenging, interesting or in other ways appealing. Finally pass on knowledge and abilities.
  • Affect social interactions and culture. Understand that each successful adoption has several stages: Innovators and early adopters who are personally interested in getting your product or idea (crazy people who are ready to drive around the city looking for the last iPad). The majority or skeptics whose needs are largely different (more interested in the ability to watch a movie on the train than in having the latest and coolest hardware). Finally the laggards who can undo your efforts if you stop early.
  • Shape the environment to reinforce all of the above: Radiate information, create a strong cultural identity, use incentives, infrastructure and institutions that encourage or guard the right direction.

There was much more to it than this shallow summary, and there is a reason why it fits in a 19-page booklet (downloadable).

The last keynote was Uncle Bob Martin demanding professionalism. Let me sum it up. Started off with a weird off-topic discussion on why people see more colors than dogs and les than bees. Then came a good part: Creating software resembles engineering, but not the way we popularly believe. “Regular” engineers and architects create very detailed documents and are relatively cheap compared to the manufacturing and execution. It’s often said that programmers are on the “manufacturing” stage, while actually everything they do is on engineering. They actually produce very detailed documents (source code), and that’s a huge effort compared to execution (compilation and running). So the cost model is inverted.

Then Uncle Bob slowly went to the point. Our computers are many orders of magnitude more powerful than those of the distant past, yet we use very similar constructs. Execution on modern hardware is practically instant and free. Uncle Bob asked where it got us, and someone replied “Angry Birds”. To this point I very much agree: It’s extremely sad how we waste all the power on bloated frameworks or worthless entertainment. But the point that Uncle Bob tried to make was quite different: Since hardware and execution is so cheap, we need to keep the model inverted by making execution as fast as possible, and that is professionalism. Write tests, don’t test through GUI, avoid database.

Let me repeat: Hardware is blazingly fast, so our primary concern should be to keep the build fast so that most of the time is spent on coding, not compiling deploying. Am I the only one who finds it self-conflicting? The issue is not that we create useless junk. It’s not that we miss business requirements. It’s not that we suck at estimation. It’s to keep the cost model inverted. Actually, when Uncle Bob encouraged the audience to ask questions, someone asked: “How to estimate better?” At this point he laughed and left the stage.

One thing worth taking away: Good architecture is what makes decisions about infrastructure deferrable to the last stages of the project. Keep expanding the core and mocking if necessary, and think of database or frameworks last.

Final Word

All in all, I would say this edition was as good as the last one if not better. I paid more attention to technical talks and some of them paid off. One thing that was definitely worse: It was terribly overcrowdeed! It was next to impossible to walk the halls or even the large exhibition area, not to mention lunch or bathrooms. I don’t think making it larger in the same venue was a good idea.

Two Stories of Ignaz Semmelweis

Life, Programming,

Here’s two versions of the story of Ignaz Semmelweis. You may have heard it as it’s quite popular in the programming & craftsmanship community. I heard the two versions about a year apart and together they’re even more interesting.

First Story

Ignaz Semmelweis was a Hungarian physician. He believed that by washing their hands consistently and well enough, doctors can significantly reduce the infection and mortality rate among mothers and their newborn children.

Unfortunately, those findings were in conflict with what most doctors believed at the time. They were prejudiced and had their old, established point of view and would not listen to the poor man.

Semmelweis did not manage to convince his peers to his findings. He died a miserable death in an asylum.

Second Story

Ignaz Semmelweis was a Hungarian physician. He believed that by washing their hands consistently and well enough, doctors can significantly reduce the infection and mortality rate among mothers and their newborn children.

Unfortunately, in the process of achieving his superior results, he managed to alienate or offend his entire profession. Things eventually got so bad that his colleagues started to deliberately avoid washing their hands just to defy him.

Semmelweis was a genius but he was also a lunatic, and that made him a failed genius. He died a miserable death in an asylum.

Which is True?

I heard the first story for the first time on the last year’s 33rd Degree. The way my inner wannabe-craftsman understood it at that time was: poor guy ahead of his time was tormented to death by his prejudiced, petrified community. He was right, and his stubborn peers made his life miserable.

I read the second version in Apprenticeship Patterns by Dave Hoover and Adewale Oshineye. Here the lesson is completely different. There is no way you can get your point across if you alienate or offend your peers. You have to be very patient and careful, especially if your ideas do not go hand in hand with what the community believes at the point.

Even if your peers are willing to listen, and you have convincing evidence or arguments, you can never play the one and only enlightened man in the world. It goes the other way round, too. Learn to listen, even if some ideas don’t exactly go hand in hand with your point of view. See if there is any value you can take from them. And even if you disagree, have some respect and don’t play the “we know better, be gone ye stupid lunatic” role.

I suspect both versions of the story are true. People are full of judgement and prejudice. Such is human nature. It’s rarely a wall that you can take down with a ram. More often you find yourself sitting on a giant elephant and trying to convince it to go in a specific direction. The only way you can succeed is preparing and cutting the way through the jungle and pointing the elephant into the opening.

This elephant rider metaphor comes from an awesome talk by Venkat Subramaniam. Heck, I would say his presence alone makes 33rd Degree 2012 a must-see.

What I Got from 33rd Degree

Clojure, Programming

This week I attended the 33rd Degree conference in Kraków. Most of the time I followed the “soft” path and learned how people work and how I can improve my skills (not only as a programmer, as it turned out). Here’s a quick summary of some of the valuable stuff I got there. It’s going to be fairly shallow, but anyway there is no way I could describe 25 hours of talks from very smart guys in a single blog post.

Tunnel Vision

Like all people, developers tend to get tunnel vision. When you’re in the flow, you don’t care about the big picture. You just crank out code and your thoughts are faster than your fingers. The more you focus on detail, the more you’re biased and suffer from inattentional blindness. Vision, scope and quality fade to background. That’s not good, because you’re a part of a bigger machine whose basic purpose is delivering business value.

Paweł Lipiński did a great job explaining how various agile tools address it. User stories clearly state what business value you’re about to deliver. Programming in pairs prevents individuals from getting out of control by having one programmer paying more attention to the strategic vision. Finally, several layers of tests (including acceptance tests) verify that the specification is met even as the code is refactored or extended.

Marcin Kokott and Martin Chmelar tackled it from a broader perspective. Sometimes companies realize something is wrong. They’re not going fast enough, or what they deliver does not exactly meet business expectations. So they hire consultants like these guys who talk to all involved parties (from developers to executives) and investigate how the whole process works. What happens from the moment a feature is described to when it actually is implemented. Sometimes the problem is not in developers, but on a higher level of the whole process. For instance, marketing or stakeholders generate so much pressure on developers that they produce poor code and don’t meet expectations. That leads to more pressure and demotivation of developers… and so we get a negative reinforcement loop that leads to inevitable failure.

Another topic that the two Martins touched is how experience adds walls around you. You get used to some way of thinking and get less and less creative. You no longer try and think outside of the box. You become prejudiced and make pessimistic assumptions. In his final “Abstraction Distractions” key note Neal Ford followed it by stating that what shields you from the world at some point can become a prison later. We think of file systems, while our users only care about documents. They want to move pictures from the camera into the app – not think about folders, JPGs, mounting an external storage or whatever (example from my experience). We are used to so many abstractions. It’s interesting how it took 30 years to market user interface that has no file system, no mouse and keyboard (that is the iPad). It took quite a while to make the breakthrough.

Finally, Matt McCullough made an interesting point. In both his talks on Git and Hadoop he stressed how you should always try and understand your tools on one level below what you need right now. It not only helps you understand the thing better, but there may be some very interesting and worthwhile piece of engineering underneath you can learn from. Oh, and in just one hour Matt managed to explain how Git works and make me actually want to give it a shot. Something that many other advocates could not make me do.

Sharpening the Axe

Another recurring topic was self-improvement. First of all, why should we care? Why not just hold on to your knowledge of the good old Java as of 2005? Quick answer: To keep your job. Longer answer: Because that’s professional. Constant self-improvement is part of the job. If you don’t do it, you will be unable meet new requirements. Web development? Fancy Ajaxy UIs? Scalability? Big Data? Standard requirements today, hard if not impossible to solve with the technology and knowledge as of 5 or 10 years ago. In fact, you even may want to learn out of boredom! But how?

There is no way to describe what Venkart Subramaniam and Ted Neward have done. Not only they had a lot of great thought-provoking content to present, but they are fantastic speakers (true rock stars in the old good rock’n’roll sense). Their frantic enthusiasm and passion were truly contagious. Venkart compared learning to mental exercise that you do to stay energized and in shape. To get the most out of it, you should learn something completely different from what you know. No point learning C# when you’re a Java master. Go learn Clojure or Erlang – something that hurts when you first do it! Even if you don’t use it directly, it may change the way you think in your primary environment (that’s what I loved in learning Clojure). Another nice side effect is that the more you know, the less effort it takes to learn another new thing (because you just learn the deltas).

On the other hand, Ted stressed the fact that there’s always a wide range of tools to choose from. There’s no silver bullet to be found. Some tools work here, some over there. You may or may not need JEE. Or Rails. Or Hibernate. Or blub. You can’t blindly apply whatever your current favorite toy is. Be critical. Even worse, you can’t rely on authorities or community to tell what’s the best. There’s no such thing as universal “best practices”. Everything depends on context.

Productivity

Finally, I really enjoyed two talks on productivity by Nate Schutta and Neal Ford.

It all started with Grzegorz Duda urging participants not to tweet about the conference (his conference!), but focus on the real people and stuff around them. Not too long after that Nate gave a great talk about the broader context of productivity. First of all, to be productive you have to be physically healthy. If you sacrifice sleep or physical exercise, your productivity actually goes down due to fatigue, poor blood flow etc. Another side of the same coin: Time and attention are limited. You only have so much time. There’s no way you can experience, enjoy and learn everything. You have to be very picky about everything you do. Are Twitter, Angry Birds or TV really worth it? Go on an information diet and be selective about everything you pick up. Drive towards doing fewer carefully chosen things in much more depth.

Compared to this, Neal’s talk was very down to earth. He shared many tricks that can make you a more productive programmer on a daily basis. Go faster by using keyboard and shortcuts of all kinds for everything, because typing is a lot faster than navigation. Mouse is for your grandmother. Stop repeating yourself and automate everything. Stay focused by getting a more comfortable environment – comfortable chair, dual monitors, virtual desktops, full screen applications, and so on. Avoid duplication by having one canonical representation of everything. If you need to update docs to keep rest of the team up to date, maybe you can generate an RSS feed for them from the VCS commit log? Finally, automate everything. Use one-step build, continuous integration and automatic tests. Don’t force yourself to interact with what you’re building – use a test suite such as Selenium to do it for you, and run it repeatedly as often as you need. Make your QA record their steps in Selenium so that you can easily and accurately replay it.

Be a craftsman, not a laborer. Build your own tools if you need.

Driving Change

One recurring question common for many different topics was: That’s all cool stuff, but how do you drive the change? How can you do it in your company? How to change yourself? The same question applies to developers’ observations on problems in the whole process (supposedly beyond their responsibility), but also to introducing new technical solutions (languages, techniques, libraries) in development itself. Even to self-improvement outside software development.

If you’re lucky, you may be in a team like the one Jakub Nabrdalik described. A bunch of people who want to improve their skills and company themselves and have enough determination to convince the boss to do it in their paid work hours. For example, it could be weekly workshops, presentations or team code review. More on that here

That’s great if you’re in a professional and energized team with an understanding boss. If you aren’t that lucky, you may still be able to sneak some stuff in. Clojure community has heard of the anecdotal way to introduce their favorite toy: Don’t call it a language. Java is a language. That’s a Huge Deal. Don’t do it, just call it a concurrency library for Java. Another example (thanks Artur): Use Gradle to solve a tricky build problem that would take 1000 lines of Ant… and open a back door for Groovy.

Venkart Subramaniam used a great metaphor. Imagine an elephant rider. Of course when the elephant takes control, it will ride wherever it wants. It won’t go somewhere only because the rider frantically says so. But if the rider is smart and rational, he may be able to control the elephant. That elephant can be your environment, or your inner lazy, prejudiced and emotional self.

Last but not the least, be a child. Drop your assumptions and prejudice. Just try it – it may simply work!

Next Year

This lengthy post may not even cover a half what I was able to see at the conference. It merely scratches the surface and does not give even a slightest hint at the great atmosphere there. Grzegorz Duda made an excellent job in organizing the event and gathering so many talented speakers. I already am looking forward to the next year. If this was only the first edition, the next one can be an earthquake. The preparations have already begun and with such stars as Uncle Bob on board it just can’t go wrong.

33rd Degree Conference

Clojure, Programming,

This April I’m going to attend the first eddition of the 33rd Degree Conference in Kraków. Not only does it have an exceptional theme (check out the web page!), but also has attracted several interesting speakers.

For some reason I am most interested in the non-Java talks and workshops given by Neal Ford (The Productive Programmer, Functional Thinking (hey, Clojure!) and Abstraction Distractions) and Linda Rising (Deception and Estimation). If there was a “Productivity and Psychology for Developers” conference, I would be the first to sign up for it.

Then there is a promising talk by Michael Nygard on scalability, as well as two sessions by Matthew McCullough on Git and Hadoop (both high on my to-learn list). Last but not least, a whole lot of more or less predictable talks on Java (mostly but not only EE).

I wish there was more Clojure and less Groovy on the schedule. Maybe next year. Anyway, the agenda is packed with interesting events and I expect it to be three very interesting and productive days.