Most interesting links of September '12
Recommended Readings
- Johannes Brodwall: This dependency injection madness must end! - it's very valuable to hear well-founded arguments against any popular belief and Dependency Injection is one of these. "I have started disliking the consequence of this strategy very much: All coupling in my system becomes implicit and harder to understand. I have instead reverted to using design patterns like the Singleton pattern, but with a slight twist."
- Computer Programmers Learn Tough Lesson in Sharing - WSJ.com - A balanced presentation of pair-programming including both benefits and issues. A key point: It is a skill that must be learned (to respect the other one, give her space, be aware of how your behavior is perceived by her, ...).
- Kent Beck: Functional TDD: A Clash of Cultures - TDD has been developed for object-oriented languages and applying it to a functional language with strong type brings interesting challenges. Also a good summary of the benefits of TDD: double checking of the logic (by the implementation and the, preferably quite different, test), solution decomposition (focus on part of the problem, once solve be sure it stays solved), automatic checking of correctness, outside in design (API first, implementation after that). Plus the pleasant experience of the continuous cycle of tension (failing test) - relief (green).
- Paul Callaghan: Thinking Functionally with Haskell: Types? Tests? We Need a New Word - Powerful type systems eliminate possibility of defects thus venturing into the domain of testing - what can they offer and where the new border and symbiosis between types and tests will be?
- Tales from the Ops Side: Black Friday - an interesting and exciting view into the life of operations engineers one day when all went wrong. Key learnings: Many interdependant components are difficult to reason about; good monitoring and communication are crucial. The post refers to an interesting concept of Recovery-Oriented Computing, i.e. failures are inevitable and their prediction is nearly impossible thus we must focus on making the systems able to survive failures (e.g. vi damage containment, automatic fault detection, component-level restartability).
- Groovy: The road map for the popular JVM language - why was Groovy created (as Java companion focused on productivity), key changes in Groovy 2.0 (more suport for static typing, Java 7, modularity with speed as a side-effect) and in the future Groovy 3.0 (invokedynamic everywhere, more Groovy written in itself).
- Martin Fowler: Key Points from NoSQL Distilled - an overview of why NoSQL, data models, distribution models, consistency, map-reduce, polyglot persistence, criteries for choosing a database.
- You’re a Top Developer! - a surprising hypothesis that "90% of all developers never read a programming blog, never have any side projects to learn something new, and never spend any time or effort outside work hours to improve". However I haven't seen any data to back that up (the author only quotes Peopleware) and the author doesn't propose any explanation for the fact. I'd really like to know if it is true and why it is so.
Continue reading →
Using Java as Native Linux Apps - Calling C, Daemonization, Packaging, CLI (Brian McCallister)
1. Using Native Libs in Java
Calling Native Libs
Calling native libraries such as C ones was hard and ugly with JNI but is very simple and nice with JNA (GPL) and JNR (Apache/LGPL)Continue reading →
Infographic: Why Should All Learn Little Code

Continue reading →
VisualVM: Monitoring Remote JVM Over SSH (JMX Or Not)
VisualVM is a great tool for monitoring JVM (5.0+) regarding memory usage, threads, GC, MBeans etc. Let's see how to use it over SSH to monitor (or even profile, using its sampler) a remote JVM either with JMX or without it.
This post is based on Sun JVM 1.6 running on Ubuntu 10 and VisualVM 1.3.3.
Continue reading →
Enabling JMX Monitoring for Hadoop And Hive
Continue reading →
The Best Code I Have Ever Written Is The Code I Never Wrote
Continue reading →
Programming Like Kent Beck
Three of us, namely Stig, Krzysztof, and Jakub, have had the pleasure of spending a week with Kent Beck during Iterate Code Camp 2012, working together on a project and learning programming best practices. We would like to share the valuable lessons that we have learnt and that made us better programmers (or so we would like to think at least).
Continue reading →
(Unit) Testing Swiss Knife: All the Tools You Wanted to Know
This post accompanies my JavaZone 2012 lightning talk and goes more in depth and introduces additional tools and tips.
Continue reading →
Help, My Code Isn't Testable! Do I Need to Fix the Design?
Continue reading →
Most interesting links of August '12
Recommended Readings
- How To Fail With Agile:Twenty Tips to Help You Avoid Success - a great overview of ways people may make agile projects and initiatives fail - use them to either avoid the failure or to make it certain, according to your attitude towards agile
- vim-adventures.com: Learning Vim keys in an entertaining way by playing an on-line 2D game. A brilliant idea!
- The Search for a Better BIG Data Analytics Pipeline - how to use big data and analytics on it in a company. Big data = lot of data, simple processing; deep analysis = representative, small sample of data (no need for all), advanced techniques. Big data can provide input for analysis.
Continue reading →
Tip: How to Easily Customize PMD Rules in Eclipse
Continue reading →
Recommended Book: Real World Java EE Night Hacks by Adam Bien
I highly recommend this very thin and down-to-the-earth-practical book to everybody interested in back-end Java (a basic knowledge of servlets, Java ORM, and REST might be useful). The book evolves around a small but realistic project (X-Ray), which we follow from the inception through couple of iterations til the end. Bien shows us how lean Java EE can be, how to profit from the functionality that it offers, and how these pieces of functionality fit together to deliver something useful. He actually introduces a complete Java EE development environment including continuous integration (CI), code quality analysis, functional and stress testing.
Some of the things that I appreciate most in the book is that we can follow author's decision process with respect to implementation options (such as SOAP vs. REST vs. Hessian etc., a REST library vs. sockets, or when (not) to use asynchronous processing) and that we can see the evolution of the design from an initial version that failed through cycles of growing and refactoring and eventually introducing new technologies and patterns (events, configuration over convention) to support new and increased requirements.
Continue reading →
Minimalistic Practical Introduction to Puppet (Not Only) For Vagrant Users
Continue reading →
You're Writing the Wrong Software - You Never Know What Users Want Until You Ask Them
Continue reading →
Zabbix: Fixing Active Checks to Work With Zabbix Proxy
Continue reading →