Sunday, February 13, 2011

A small Subversion guide for Git users

A recurring problem for us Git users is that we tend to forget the good old Subversion tricks. We want to do some patch on some old code in a Subversion repo, and suddenly we've got no idea how to work around.

Here's a quick guide:

> git pull
> svn update


> git add new_file
svn add new_file

> git add changed_file
N/A: SVN automatically adds all modifications to the index. If you don't want to commit it, don't change it.

> git commit; git push (you always have to do these together):
> svn commit

> git revert [SHA]
> svn merge -c -[R] .


> git branch branch_name
> svn copy url_to_project/trunk url_to_project/branches/branch_name


> git tag tag_name
> svn copy url_to_project/trunk url_to_project/tags/tag_name


> git checkout branch_name
> svn switch url_to_project/branches/branch_name/


> git merge branch 
svn merge -r[start]:[end] url_to_project/branches/branch_name .
(Note that you have to keep track of at which revision you made the branch, and that the result will always be squashed. Renames and moves will create conflicts).

> git rebase ...
Forget about it :)


Please add other neat SVN tricks to the comments if you can think of any good ones ;)

Saturday, February 12, 2011

XP-Meetups

Kent Beck wrote a small chapter about Communities in his book Extreme Programming Explained: Embrace Change (2nd ed):
Participate in communities, local and global. Look for communities that encourage you to be your best self. If you can't find such a community, start one yourself. If you are wrestling with difficult questions, you are not alone. As a community we can accomplish more than we ever could in isolation.
When I lived in Oslo, I was a member of the local XP-meetup group. It was awesome. In the beginning, I was still a CS student, and I felt privileged I could attend these meetings. These experienced people were dropping serious knowledge about how to work and develop software in practice.

It was so refreshing compared to the artificial subjects at university, and it just made more sense. At the same time, the speakers were so humble, you could ask them anything, and they would try to identify with you, draw parallells based on experience, tell stories..

Over the years, the meetup grew into being the largest XP-meetup in the world, and they attracted big jolt speakers like Tom Gilb, Michael Feathers, Jeff Sutherland, the Poppendiecks, Kent Beck and Uncle Bob. The organizers started doing an annual conference, now gathering 500 participants. Other meetups popped up as well, about Lean, Coding-Dojos, Agile Offshoring and more.

I think these communities have made Oslo a vibrant city for software developers. There are numerous advantages to this:

* Knowledge is shared, which benefits the community as a whole. People become more happier and better at their jobs. Projects become more successful. Old inefficient companies die out, and new companies that provide value to society are the ones that thrive.

* There is synergy between communities. Oslo's Java User Group, javaBin, got more traction thanks to the XP-meetup, and vice versa. JavaZone is arguably the best Java conference in the world, and every year it's sold out. There even is an umbrella organization for the communities in the city, and they're talking about raising a building for hosting communities.

* Networks between software developers are extended. I think this actually sharpens the competition for creating the best place to work for the developers. Communities give a lot of insight on how it is to work for another company, which in turn makes it more tempting to switch ships. The companies who want the best people have to make themselves more attractive, which again means more budget for salary, conferences and courses.

In the end, developers get better treatment, become better at what they do, and enjoy life more. Society gets more value from the software produced. Everybody wins.

----

Bonn, with a population of 320.000, is not as big as Oslo, but it's certainly big enough to maintain its own community of XP-practitioners (aka Extreme Programmers). We'll do our first XP-meetup on the 21st of February, in an a bar 5 minutes from the central station. I hope you'll join too!

Friday, February 11, 2011

Sonatype and Hudson/Jenkins: An Analysis

I'm dare say I'm a seasoned Hudson user (admin) and proponent. For over five years I've been introducing different kinds of CI at whichever place I worked at. When Hudson entered my radar, this work became a lot easier. I'm also a heavy Maven user, and Nexus did for Maven repositories what Hudson did for CI.

The Plot
Over recent weeks, the community around Hudson has been shaken by a fork: The main developers (Koshuke and crew) have renamed Hudson to Jenkins, while Oracle have kept on developing Hudson in partnership with Sonatype. Here's a simple illustration of what happened:

These are my pure external speculations about what has happened recently in the forking process, with regards to Sonatype's involvement in particular.

So who is running this show?
I noticed that Sonatype (usually personified by Jason) have gotten their fingers pretty deeply into the Hudson infrastructure already:

Like this tweet noted, it appears they are controlling Hudson's Twitter account. The @hudsonci account tweeted about something Maven-related, and it appeared it it was indeed meant for a Sonatype account.

And here it appears Jason is administering some of the Hudson infrastructure. 

It's no secret that Sonatype and Oracle are tightly partnered on this. But I think the relationship is more like one of a smart trickster sitting on the shoulders of a dumb giant.

Backstabbers and Benson
A lot of people felt betrayed when Sonatype chose to side with Hudson/Oracle in the fork. Heck, even I was disgruntled that my Maven heroes were going with the big evil anti-open source Oracle..

I've been pondering on why they did this unpopular move, and here's my rough guess:

The reason is Benson:
Benson is Sonatype's Maven-focused distribution of Hudson taking into account everything that we've learned about Maven 3.0 during its development and how Maven should operate optimally within a CI environment: there will be no better way to work with Maven and Hudson. Benson is Hudson's brother from another mother. (source)
As with any fork, maintaining it is expensive. I think Sonatype found it hard to keep Benson up to date with Hudson and all its plugins. Or maybe they wanted more changes in direction Nexus/Maven than the Koshuke crew were willing to go with.

See more about Benson in Jason's presentation from JavaZone 2010 (time 39:20).

A Genius Take-over
Had Hudson stayed under Koshuke's rapid development, Sonatype would've had to keep on maintaining Benson, merging in conflicting Hudson changes as they grew ever more distant from the fork.

Now, they can achieve the same with Hudson itself, and in the process they gain a huge brand by sticking to the Hudson name, and they also stay under Oracle's wing (this has its own con's, of course), with infrastructure and paid coding contributors.

So in a way, Hudson is the new Benson.

You can actually see this manifestation taking place right now. I guess you could simplify this to mean that Sonatype are now merging back the development they made in Benson. What the community is wondering, is why they didn't offer to do so before the fork (see the discussion in the comments), but that doesn't really matter anymore. Sonatype came in at exactly the right time, and did what was best for their company and customers. Nothing wrong with that.

My two biggest questions of this are:
  • Will Oracle put up with Sonatype's strategy over time?
  • Will Sonatype put up with Oracle's inherent bureaucratic inertia?
Over time there's nothing stopping Sonatype from forking out Benson again, if it turns out Oracle's wheels are winding too slow. Another possibility is that Oracle takes a liking to Sonatype's infrastructure tools and proposes a buy-up.

This is a Good Thing

I think Sonatype is one of those rare companies that are able to work the open-source ecosystem, making a profit while at the same time donating a huge amount of great tooling back to the community. Some times they have to make unpopular compromises in order to stay profitable, and this is what happened with Hudson/Jenkins.

Nexus is an awesome product. It shares many of Hudson's qualities: It *just works*, it looks nice, it's easy to upgrade and maintain. I hope Hudson will retain these qualities. I'm sure Jenkins will.

What path will you take?
Personally, I think I'll go with Jenkins for now. I'm tempted to go with Sonatype/Hudson because we extensively use Nexus and Maven, and we're not paying Sonatype-customers. At the same time, I have only moderate needs for stability, and from experience I'm very happy with the features vs stability rating of the Koshuke crew.

I think (but might be wrong), that Jenkins will outrace Hudson in terms of features and usability.

I fear, that Hudson will get tangled down with Oracle stuff (register here to download, etc).

I hope both will continue to exist and fulfill two different needs in the market. Best of luck to both of them!

Monday, February 07, 2011

Google Guava r08 is released

A few days ago, Google Guava r08 was released.
"This project contains several of Google's core libraries that we rely on in our Java-based projects: collections, caching, primitives support, concurrency libraries, common annotations, basic string processing, I/O, etc."

I had a little look through the API changes to find some neat new details, and put together a couple of JUnit tests that show them by example here.

That whole GitHub project is a Guava showcase, so if you can think of some more examples that should be in there, please fork! Especially the IO, Net,  and Concurrency bits could need some examples.

I've also taken my old blogposts about Google Guava and ported them to tfnico.com/presentations/guava. After noting this, the Guava guys honored the effort by linking the page from the Guava homepage, which gave me quite the traffic bump! Luckily, my pages are all hosted on Google servers, so it's their own bandwidth bill ;)