The Scala 2.8 beta 1 announcement gives hope regarding the availability of a decent IDE for editing Scala code. We will see what Scala 2.8 final looks like, but if the eclipse IDE support features basic Class and Method renaming, I will most likely make Scala my main programming language for writing open source code that targets the JVM. Two projects that I would most likely convert to Scala would be :
- Gisgraphy Java client : a Java library that gives access to gisgraphy City and GIS features search engine.
- Pymager Java client : a simple Java wrapper on top of the RESTful interface provided by pymager, an image service that provides simple conversion and thumbnailing / resizing features.
In many situations, open Source software developers need to deal with the maintenance of patches. Examples include :
- Unofficial versions of the linux kernel, where specific patches are applied (e.g. Xen kernel, openvz kernel, ..) and need to be constantly forward-ported to the latest kernel when it is released
- Distribution-specific changes (e.g. Ubuntu-specific changes to debian packages).
Maintaining one big diff file for all changes would clearly quickly become unmaintanable, so it looks like different approaches are now widely used instead :
- Maintaining stacks of patches, using specialized tools such as quilt.
- Using distributed VCS tools such as git.
How to survive with many patches describes the use of quilt. Here is some background :
“Andrew Morton originally developed a set of scripts for
maintaining kernel patches outside of any SCM tool. Others extended these into a suite called quilt.
It looks like distributed VCS tools have now superceded quilt, as far as pure software development is concerned (linux kernel, etc.). But quilt remains very popular for maintaining distribution-specific changes to packages. Indeed, as distribution packages live outside a SCM tree, it is important to have mechanisms to apply distribution-specific changes to the upstream source packages. And this is where quilt comes to the rescue.
Ubuntu packaging guide describes the use of quilt in debian’s packaging system. Such a simple system is clearly awesome, and the more I understand how the Open Source communities organize themselves, the more it makes me realize how technically advanced the Open Source world is compared to the corporate world !
No matter how much you might have heard that tooling is unimportant, the reality is that tools are important. Tools enable complex collaboration, and this is clearly an area where Open Source excels.
http://www.suse.de/~agruen/quilt.pdf
I’ve been been using the web differently lately.
I discovered a nice application that allows me to wrap my web experience in a nice bundle.
It’s called Quix. And it allows me to use the web on steroids.
Quix is an extensible bookmarklet. It allows you to quickly access your favorite web sites – do an google search, look for a book on Amazon, bookmark a page on delicious… I don’t have to touch the mouse! It’s like a command line tool for the web.
But the real power comes from the extensibility. By default Amazon searches are done on Amazon.com. Since I live in Canada, I find it a bit annoying. So I start to write my own Quix file. You can find it on http://mathieuberube.net/quix/quix.txt.
So far I added these commands to my Quix file:
- Amazon.ca search (a pragmatic programmer) – I overwrote the default Amazon.com search for this one
- SAQ wine search (saq veuve clicquot)
- Javadoc search (java hashmap)
- rubydoc search (ruby array)
Quix has a page to configure custom bookmarklets. I then configured Chrome with the Shortcut Manager extension. Now I just press Ctrl-Q and I’m all set to enter any of the commands above.
Give it a try, you won’t regret it.
Quix in Chrome
Cumulative Flow Chart in Kanban attracted my attention as I consider it a nice example of using branching efficiently.
IMHO, it is simply wrong to assume that every single task can be split into small fragments that are then iteratively incorporated into the mainline. The author calls this kind of task a “technically complex story”, and I have yet to see a successful example of migrating frameworks or doing technical migrations like that without resorting to branching. This is what the whole open source community does, and it is high time the “enterprise” world catches with these practices.
Branching then comes to the rescue ! Let the “technically complex story” evolve in its own branch, and make sure to conduct in-depth QA BEFORE the merge. Same thing for code reviews and going through the DONE checklist : make sure to do it BEFORE the merge so that you do not end up with non production-quality code in the mainline, which is then pretty hard to get rid of.
BTW, Version Control Tools gives an overview of the differences between git and mercurial, which are two wonderful SCM tools that are very branch-friendly.
why can’t programmers…. program is definitely worth reading… Yes, this is disturbing….
The worst question interview ever describes… well, just read the post and you will quickly figure out what it is about. I simply LOVE Gavin King’s comment :
Heh, and I’ll continue to be an ass in all future responses to “John Smith”s who tell talented guys who worked on my projects for years that they aren’t “team player”s, “have an attitude” and are “prima donna”s. I’ll be the judge of that, not some asshole anonymous blog comment poster who has never met or worked with Norm. I’m protective of my team. That’s not going to change. Sorry if you don’t like it.
YES, Gavin King is an ass, but most of the time, this category of ass is right, and people should just listen to them instead of complaining.. ah ah ah 
love it !
PS: for those who don’t already know it, Gavin King is the founder of Hibernate…
EJB 3.1, a compelling evolution describes the new features available in EJB 3.1. It looks like EJBs are finally getting the features they miss..
However, there are still a few things bugging me :
- Why insist on keeping the neat features (IoC, ..) server-side only ? Why can’t I just use the same mechanisms for in-container server-side code and other kind of code ? Do I still need to revert to using Spring for everything that is not running inside the JEE6 container ? What about integrated tests ?
- How come we still don’t have any equivalent to Spring templates, that take care of creating standardized, runtime exceptions and handling opening/closing resources automatically ?
So for now, when working in non-spring environments, I need to create my own Templates to avoid creating clumsy code…
I agree that Spring Framework is a patch, and should eventually disappear. But for it to disappear, the underlying technologies need to start being half-decent…
These days, it looks like there is a lot of hype around the NoSQL movement.
These data storage systems have a number of features in common:
• a call level interface (in contrast to a SQL binding)
• fast indexes on large amounts of data,
• ability to horizontally scale throughput over many servers, and
• ability to dynamically define attributes or data schema.
NoSQL explained correctly gives an idea of what these datastores are useful for, and how they complement the current RDBMS offering.
High performance scalable datastores compares the technical characteristics, maturity and licenses of the NoSQL offering.
Other links on the subject that might be of interest :
As part of a market research for one of our customer, I came across this report published by Gartner in December 2008.
As the pace of agile adoption increases, development organizations must understand the different levels of agile maturity. CIOs and product and development managers need to assess where they fit on the maturity scale, and which level offers the biggest return in their organizations.
The report presents the 6 levels (from 0 to 5) of Gartner’s Agile Maturity Model and corrects a few myths.
- Agile adoption and penetration rates are being overestimated. Although the number of companies that are adopting agile practices is, indeed, reasonably high, most organizations use agile in a very small percentage of their overall work.
- An agile maturity framework is necessary to help make the case for adoption, process improvement and benchmarking.
- Current adoption rates for agile and iterative methods are between 15% and 25%, when taking into account penetration and maturity, with waterfall still the dominant approach. The pace of agile adoption is increasing.
The report concludes that :
As part of an agile readiness assessment, IT development organizations should access their current agile practice maturity at technical, project management and organizational levels. Practices should be assessed for, among other things, their effectiveness and adoption levels in the organization. Adoption should follow initial pilots, and should normally be Level 2, with the aim of developing a consistent set of agile practices at Level 3.
RECOMMENDED READING
You might be interested in these related posts:
- Gartner Predicts 2010: Agile and Cloud Impact Application Development Directions
- Forrester Reports “Agile Development: Mainstream Adoption Has Changed Agility”
- Will the current economic landscape prevent the launch of new BI initiatives?
It looks like that the future of OpenSolaris is unclear, now that Oracle has acquired Sun..
I take the official Oracle website to be rather … official ?
Lets recap, shall we ?
a) Almost every trace of OpenSolaris Support subscriptions vanished from
the official website within the last 14 days.
b) An Oracle sales rep informed me personally last week that I could no
longer purchase support subscriptions for OpenSolaris.
More information available on this thread.
