Peter Hendriks

Eclipse Galileo SR1 (3.5.1): enterprise polish

peterhe — Sat, 26 Sep 2009 10:25:00 GMT

Eclipse is used as a core tooling platform in big and small software development projects, using various plug-ins and programming languages, all around the world. Scaling is important for Eclipse, both in time (some projects take years), and size. Last month, Google held an Eclipse Day, and the videos are available here. The videos mention some scaling problems: how to deal with lots of code, lots of plug-ins and different configurations. Google is a huge development organization with tons of projects and millions of lines of code. In many ways, Google is the ultimate “Sinatra Test” for scaling Eclipse, and the talks show some interesting problems and solutions.

The Eclipse “Galileo” release train updated yesterday with its first Service Release! Among the many bug fixes are some very nice performance improvements (some of which mentioned in the videos). On my current project, we have over 200 projects in the workspace, close to a million lines of code, and our current (strict) coding policies show over fifty thousand problem markers in the codebase (mostly because of an ongoing migration to Java generics). Being a friend of Eclipse, I got to download the release a day early and try it out, and the results are impressive. Eclipse feels a lot faster now and some obscure JDT quirks seem to be fixed as well. Hopefully, these kind of performance fixes get more attention in next service releases as well, which means we can scale up Eclipse better and easier.

"Jazz" ALM tool Team Concert: now free for 10 developers

peterhe — Tue, 22 Sep 2009 18:46:00 GMT

Today, the IBM Rational Team Concert (RTC) "Jazz" team released version 2.0.0.1, an update to the major 2.0 release last June. The update contains a ton of bug fixes and feature enhancements, which is always nice. However, the big changes are in the licensing department. Most notably, the free Express-C edition is now equipped with 10 developer licenses (instead of 3), and can now run on all supported database platforms (DB2, Oracle, MS SQL Server) for increased performance. More details on the release are available here and here.

This means another compelling free option for small teams. RTC is a state of the art version control, work item management, planning and build management tool, with overall process guidance, history, chat and a web dashboard, very nicely integrated into one suite. It basically runs everywhere and provides first-class support for both Eclipse and Visual Studio .NET based tooling. RTC is developed by one of the best teams of IBM, with an aggressive release cycle of 3 releases a year, innovating very rapidly. And, if you can live with no support and 10 developer limits, it doesn't cost you anything. That's a pretty sweet deal.

So, what's all this talk about "developer" users? Because Jazz.net is not very explicit on this, I'll try to explain. Basically, RTC has several different categories of users, some of which require licenses and/or are limited based on the server edition:

Users (no license): have read-only access to project data such as dashboards, work items, etc.
Admins (no license): can perform technical tasks, such as configuring the server, adding users and licenses, etc.
Build (included with server): can perform version control operations needed for builds.
Contributor (license needed): full access to work items, planning, dashboards and reports. No access to version control and build management.
Developer (license needed, some included with server, max per server/edition): can use everything of RTC.

So, 10 developers does not mean just 10 users. You may have some flexibility if some users do not need all the features. So, go download the latest version here. The Express-C edition is very easy to install, just unzip-and-go. Try it out, if you don't like it, just throw away the directory when you're done.

Injecting JSR330 into JSR299

peterhe — Wed, 05 Aug 2009 19:04:00 GMT

Last week, I blogged about Guice 2.0 and the state of Java EE 6 dependency injection: JSR299, competing with another injection standard: JSR330. Well, the wise men of the Java EE 6 spec, just before finalizing it, have just decided to adopt JSR 330 into JSR 299. This is great news! JSR330 is not limited to the application server, so this means we can use the same notation mechanism on the server, desktop, mobile, etc. Also, JSR330 are just a set of interface and annotations, this means you'll be able to use it in today's technology as well, combined with Guice or Spring, providing a smoother ride to Java EE 6 later on. Most important, the competing specs would have caused some massive confusion and agitation, and fortunately, this has now been prevented before the fact.

In the announcement, Java EE 6 is pushed to a November release (from September), and of course, some mea culpa here, because all the current JSR 299 samples will break and some serious late-game refactoring is needed. Better late than never though: Java EE 6 will be around for a while, and it's important for these kind of decisions to be right the first time.

Guice 2.0 presentation: no more reasons not to like dependency injection

peterhe — Fri, 31 Jul 2009 19:29:00 GMT

Dependency Injection is one of the most controversial improvements made in software development over the last few years. Dependency Injection really helps modularization of code, which in turn, among other things, greatly improves the ability to unit test code. On the other hand, dependency injection either requires tons of hand-written factories or a framework. DI frameworks may have their issues of their own, like doing a lot in complicated XML, a large footprint, too much "productivity improving" added voodoo magic, not being to inject everywhere, etc. Over the years, DI frameworks have competed fiercely with new ideas and new concepts, and though DI frameworks have been useful from the beginning, they are really a lot more powerful and easy to use nowadays.

A Dependency Injection framework will be part of the Java EE 6 spec. To be honest, I have mixed feelings about this. On the one hand, it's great to finally see these concepts embraced the spec, hopefully, it will end the silly battles of "it's not a Java EE spec idea, so it cannot be used". On the other hand, there are some serious drawbacks. First of all, the DI specified in Java EE 6 does not work outside the container as by the specs. You will need DI outside of container a lot: when writing stand-alone applications, when wanting to do out-of-container integration tests, simple standalone conversion code, etc. Of course, nothing prevents DI frameworks from adding custom API and support for this, but this defeats the purpose of having a standard.

Also, DI is a much more evolving topic than for other infrastructure-oriented API. HTTP, JTA, JMS, JMX, are infrastructure-oriented solution APIs, and as such are most likely limited to evolve based on the underlying technology, while DI sits on a much different level. This spec will hopefully be final soon, but it will probably take at least a few years for vendors and customers to adopt to this standard. In two years, DI will probably already be evolved by then, making the current spec solution suboptimal by comparison, and the DI part will not be as popular as one might expect now. On top of that, a competing standard (JSR-330) is working on a standardized interface for DI frameworks that is different from the one in the EE6 spec. This means the Java EE DI spec will have competition even from another JSR!

Meanwhile, Google released version 2.0 of their Guice DI framework. This presentation gives a great introduction on why you need Dependency Injection in general, and what Guice is all about. No large-mouthed marketing, no mud-slinging, a very technical and honest talk. I really like Guice 2.0, it's really easy, powerful, fast, small footprint, OSGi enabled, works everywhere and tries to solve one and only one problem. If you like DI, be sure to watch the presentation, if you hate DI, watch it too. No need to wait for a big spec change and a server upgrade, just start using today's great ideas today.

Update: it appears the Java EE 6 spec will adopt to JSR 330, this solves several of the problems I mentioned. Guice will probably adopt JSR 330 as well, as the Guice architect Bob Lee is on the spec team.

Eclipse Galileo: tons of new stuff

peterhe — Sun, 19 Jul 2009 12:37:00 GMT

The Eclipse open source initiative is one of the biggest open source communities currently active, and since mostly backed by businesses, has a strong quality and real-world focus. Eclipse hosts a ton of projects, and most of the mature projects participate in the "release train", a yearly coordinated effort to launch new releases. This way, it's easier to keep track of Eclipse developments, and because projects depend on each other, it allows for a smoother adoption as well.

This year, the train was dubbed "Galileo", and contains 33 projects (from 23 projects last year), containing 24 million lines of code. While Eclipse started out as a base tooling platform for Java development, today, it's a lot more. In fact, it's such a broad platform now, I will only highlight some of the new stuff in the projects I keep track of myself, starting with the new and less known:

* Jetty/Eclipselink/Swordfish/Riena: A few new "framework" like projects were added to Eclipse relatively recent. One is Jetty, a mature, flexible and fast Web Container, notably used by Google for its AppEngine Java cloud offering. Another is EclipseLink, the open source version of Oracle TopLink, and the official reference JPA solution. EclipseLink boasts some other interesting features too, including support for SDO and XML, and DBWS, a mechanism for declarative data-oriented web services.

Swordfish is a SOA "bus" product based on OSGi, and Riena is a platform for business-oriented client-server applications using Eclipse technology. Both these projects are still very new and still have some rough edges, but it's interesting to see more of these kinds of projects at Eclipse. Basically, you can now build your entire application with products from Eclipse, making Eclipse compete at a new level.

* Memory Analyzer/TPTP: the Memory Analyzer tool, contributed by SAP, is an exciting new project. It's hands down the best off-line Java heap dump analyzer currently available, supporting analyzing of large dumps on simple desktop computers, with amazing detail and performance. TPTP on the other hand still remains a bit of an obscure product, but at least I get it to work now for most scenarios, allowing some basic profiling. Still, I would recommend buying a real profiler tool, or check out the Netbeans Profiler (also limited, but easier to use and better performance).

* Process Framework: the process framework project hosts a sophisticated "composer" tool, designed for building web sites to describe processes. Also, the projects hosts some great reference web sites for popular processes. I find myself looking into the OpenUP and Scrum sites often. The new release improves support for "practices" based descriptions, that allow for easier mixing and matching when defining a custom process.

* Eclipse Web tools: "web tools" always has been a bit of a weird name, since I use it most to write EJBs. This release has some nice improvements for writing XML Schema and XSL stylesheets, and some UI cleanup across the board. Also, support for Java EE 5 and JPA has been improved.

* Mylyn: the premier task solution for Eclipse has some nice additions. Wikitext is now used all over the place for better formatting, and Mylyn now supports OSLC, meaning it can interact with Rational ClearQuest and the "Jazz" Team Concert products.

* Eclipse platform/IDE: the best known Eclipse product got some nice updates. First of all, support on the Mac should be improved a lot, and there are some great tooling improvements if you are doing OSGi development. On the part of generic Java developments, there is some nice little polish, but no huge new features.

Debugging now no longer requires to switch to another perspective, but allows to dynamically open/close views in the current perspective. I did not expect to like this as much as I do now. When debugging a simple unit test, it's less of a mental context-switch. And when I need all of the advanced debug stuff, I can still switch to the perspective and do some serious debugging.

All in all, Eclipse innovation is still going strong, with small and big improvements that keep the products going forward. Hopefully, you get to upgrade soon and start using Eclipse Galileo!

Returned from the RSC: back to the rest of the world

peterhe — Tue, 09 Jun 2009 10:46:00 GMT

Well, the IBM Rational Software Conference 2009 is over again. It was once again a great conference with lots of interesting new developments and insights. The Jazz products are evolving very fast, and they really try to improve on weak points first and adding only features that are really useful and relevant in real life. I really like the "enterprise" focus of RSC, as much fun as dancing robots or spinning cubes are, it's much more interesting to see how technology and tools can be applied in real scenarios. For fun and entertainment, comedian Mitch Fatel cohosted with a reality show using real developers. Basically, just like on tv, the show was pretty corny, but fun when the developers started arguing and acting like idiots to win the discussion. Those developers were also attending/speaking, and it was funny to see some guy getting an evil eye all the time while doing lunch (tv will do that to you). The guys from Mythbusters were special guests, although it was a shame that they could not blow anything up on stage because of the fire department regulations. They did provide some insight on risk management, the process of creating experiments, and space ships fueled with poo.

When I was at the conference, I completely disconnected from the rest of the world to focus on all the content. Now that I am back, I am reading up on all the other interesting stuff that happened the last few weeks. European elections, JavaOne, Google I/O, a lot happened in such a short time. Google is moving more and more into the Java space, with the AppEngine Java offering and the exciting new Google Wave initiative, fully based on GWT. The Wave demos are a great showcase for GWT. A lot of the Google I/O sessions are already up on the web, and I'll soon here from my colleagues that visited JavaOne what happened over there. It's great that despite the economic crisis, innovation still happens!

Rational Software Conference 2009: Real, Smart and Green

peterhe — Tue, 02 Jun 2009 21:13:00 GMT

After a year, we're back in Orlando, home of Mickey Mouse, roller coasters, hamburgers and Coca Cola, and of course the IBM Rational Software Conference 2009. The conference is already well under way, it started last Sunday, but with an ever increasing count of sessions and events, my schedule does not permit a lot of blogging. The themes of the conference are Real, Smart and Green. Basically, Real is about practical, concrete value, Smart is about innovation and new areas of sofware usage, and Green is not wasting paper at the conference. The green part seems a bit funny when you hear it at the keynote: big plasma screens everywhere, airconditioning that requires wearing a sweater, even though outside it is 40 degrees celcius, and then a big show about how paper is saved and plastic bottles are banished.

Several new announcements were made. IBM is coming with a new cloud initiative, which should support hosting all kinds of customer applications, as well as the Rational Jazz based tools. This means new opportunities for management, monitoring and metering, as well as hosting and licensing models. The announcement is still very fresh, but it is an interesting model that will be interesting for lots of people, including smaller companies that don't want the hassle of managing infrastructure, or really big organizations that would like additional metering and governance for internal billing of server usage.

Also, IBM is expanding the portfolio with even more tools. The Tivoli systems management tools will now connect more and more with Rational, bridging the gap between software development and the production support organization. And Rational Insight will provide "executive dashboards" for management to bring together metrics from all kinds of tools and data warehouses, with analysis built in to assess the health of projects at a broad level.

Of course, lots of content on the development of existing products as well. Team Concert 2.0 has some exiting new features, and the work on the Jazz foundation means that the tooling integration will push to new levels in the upcoming Quality Manager and Requirements Composer releases. The Open Services Lifecycle Collaboration (OSLC) specification was just finalized at 1.0 last week. RTC 2.0 will comply with it, and there is a OSLC adapter for ClearQuest available as well. Interestingly, the Mylyn guys added support for OSLC to the Mylyn Eclipse plug-in. This means that everyone that supports OSLC will directly work with Mylyn. For Mylyn and the adopters, this could be a real winner, because right now, there are about 29 different adapters for Mylyn to support all kinds of task repositories.

Several other interesting things going on as well in the "agile" mentoring and guidance space. Adopting some of the agile ideas can be very hard to do, and there are several experienced speakers here with great ideas about moving agile forward, without being too naieve about it. All in all, a great conference so far, back to my busy schedule for the next sessions!

Jazz 2.0 release candidate

peterhe — Sun, 17 May 2009 17:05:00 GMT

RC1 for Rational Team Concert (RTC) 2.0 was released yesterday. Even though it's only been a year since the 1.0 release, RTC got a lot of updates. First of all, there is now an Enterprise edition, which allows an unlimited amount of developers on a single server instance, a big improvement for large organizations with more than 250 developers. Cross-server and cross-project linking has been improved and formalized, one of the user-visible capabilities is that you can now create dashboards that contain information of several projects. This allows several interesting scenarios, such as a "Project of Projects" for a Project Office in a large orginization, or different companies with their own ALM deployments working together through the shared Jazz link.

All of the core components got some serious updates, but the Agile Planning Tool got the best screenshots. First, a new Standard-only feature calculates risk in the schedule based on the estimates and the planned dates:

Another fantastic feature, available in all RTC editions, is the "taskboard" view mode. This basically gives you a Scrum-sticky notes overview of the tasks. It looks really great on my big widescreen monitor at home:

There are a lot more new features, check out the new & noteworthy notes if you are interested. It's not just brand new features though, in the different RTC "editions" (free, small, org, huge), a lot of the checkmarks got to the left side. This means the Express versions now are a much improved option for a quick single-project off-the-shelf solution. If you haven't given RTC 2.0 some attention yet, be sure to take a look!

Why tools matter

peterhe — Sun, 03 May 2009 15:34:00 GMT

Improving software development productivity is a much discussed topic, with many different schools of thought. Some will say you need to get people who can "Hit the High Notes", others will focus on teamwork dynamics as a means to ultimate productivity, while some will emphasize that using the best tool out there is critical. A lot of these camps will often downplay the others, stating that their focus on productivity is the only one that really matters.

I think all aspects matter a lot, and depending on the situation, you should focus on different aspects. Small teams vs big teams vs novice teams vs experienced vs long vs short projects, etc. The important thing to recognize is the relations between them and how they compound or conflict with each other.

Tools play an important role here (with tools, I mean "automated" support, such as an IDE, build tool, version control, etc.). In my opinion, tools can determine the bandwidth of operational productivity. In other words, tooling will play a role in determining the barrier to entry to perform certain activities, and the maximum theoretical performance a team member can reach using the tool.

A nice example is creating a build. If properly tooled, everyone should be able to start an automated build with the press of a button (or even better, it just happens). Otherwise, creating a build may involve several complex steps, requiring specific knowledge and coordination, and is likely to be executed by a single team member as an "integrator" only. A properly automated build reduces the barrier to entry for the task of creating a build.

If a version control system does not support certain features (like atomic commit, for instance), or is very slow, this may limit the bandwidth of team members using the tool. Limited tool support incurs overhead in the form of error-prone behavior, complex workarounds, and increased waiting time.

Of course, tools are not the only potentially governing boundary factors for productivity. Just simple pen and paper are a great drawing tool, easy to use, very fast, and very mobile. On the other hand, it is difficult to navigate and search through paper drawings, or maintain them when something changes. Tools should always be viewed in the context of a given task and situation.

I tried to summarize this using this very sophisticated picture:

J-Spring 2009, full of surprises

peterhe — Wed, 15 Apr 2009 18:20:00 GMT

Well, it's spring again, so time for another NLJUG J-Spring event! The NLJUG J-Spring/J-Fall is the biggest Java event in the Netherlands, a one day conference held in Bussum. I am a regular visitor on this conference, interesting sessions, a good indication of the Dutch Java scene, and it's great to meet up fellow Java developers again. The conference was "sold out" (entrance is free to NLJUG members), but because it was nice weather outside, it was less crowded inside during the breaks than usual.

Data Context Interaction

For me, the conference started out with a talk on "Data Context Interaction" (DCI). Basically, this is supposed to be solving the problem that "typical" object oriented (OO) design mixes all kinds of stuff inside your domain objects. DCI completely separates each interaction, using simple techniques like a decorator, or a full-blown new programming environment called Object Teams (unfortunately, only the latter was demonstrated). I had a bit of trouble with the initial problem statement. In "good" OO principles (like SOLID, for instance), mixing unrelated stuff in the same object was already considered very bad! I agree with the stuff DCI proposes, but I do OO design this way in plain Java for years already, without needing fancy new languages or confusing new acronyms. As a research effort though, I am really interested if something useful will evolve from this new emphasis on a cleaner separation.

Web Beans

Next was a talk on the JSR-299 "Web Beans" specification. Basically Web Beans is the best of Guice and Seam (both inspired by Spring), mixed together in a single Dependency Injection standard. This talk was a real meat grinder, the speaker had little mercy for any listener that did not have intimate knowledge of Seam/Guice, and crammed the entire spec in the talk (and the spec is pretty big). Fortunately, I did know enough about Guice and Seam and managed to keep up the entire session. Web Beans will be great when it's done (no date is set on that, but not likely this year), especially if it works on Java SE as well. It's a nice clean spec so far: easier than Spring and Seam, more powerful and complete than Guice.

Pragmatic Model Driven

The revival of model driven development was apparent on this J-Spring too. Jos Warmer did the afternoon keynote on a new framework called Mod4J, which is basically an out-of-the-box DSL and code generation tool to work model driven using predefined DSLs. Another talk by Richard and Tony in the afternoon relied on a more low-tech technique by using out-of-the-box Enterprise Architect capabilities in conjunction with Freemarker templates. Both approaches each have their pros and cons, but both did model driven only for the simple boilerplate code, no ambition to replace coding completely, or rely on very abstract models written by non-programmers. Very interesting stuff, meta-models seem pretty easy, especially in Enterprise Architect, so basically, this stuff relies on easy to understand code generators to be accessible to the average programmer. I talked a bit with some of the model driven guys, but since they have been investigating and experimenting with this stuff for years, to them, everything seems easy.

The demise of the Swing JSRs

Finally, I visited a talk on the JSR-296 "Swing Application Framework" spec, by Karsten "JGoodies" Lentzsch. Karsten is a great presenter and a real Swing guru so I never miss one of his talks. This talk was especially interesting though, because although he did explain the spec, he basically said that it was dead. Sun re-prioritized on JavaFX, and abandoned some important Swing JSR specifications. According to Lentzsch, you'd be better off right now if you roll your own framework for serious Swing applications instead. It's surprising to hear a member of a spec expert group say: don't use this spec! Refreshingly honest though, which is loads better than hollow promises of Sun on this subject.

Still, the JSR is a great inspiration for solving common problems, although Karsten pointed out some things he did not agree upon (like resource bundle injection). Karsten did say some nice things about Eclipse RCP too, stating that as the only real alternative for plain Swing for now, interesting to hear from a Swing guru (both Netbeans RCP and JavaFX were mentioned). Finally, he did mention the Eclipse JFace data binding too, as a cleaner and more powerful alternative to the JSR 295 "Beans Binding" spec (dead now, too). Since JFace data binding is pluggable, it can be used outside Eclipse as well, and Karsten mentioned the UFace project (Swing and GWT bindings) as something very interesting to watch in this space. UFace, though, has not released any downloads as of yet, so right now, you have the choice between a JSR that is dead, a new generic framework that is not yet available, or just plain old JGoodies for Swing data binding.

All in all, an interesting and surprising day at J-Spring. See you next J-Fall!

Google AppEngine for Java: the cloud keeps getting bigger

peterhe — Wed, 08 Apr 2009 19:06:00 GMT

Google joined the cloud computing turf a year ago with "Google AppEngine", a framework to enable relatively simple applications to be deployed directly in the cloud. Google AppEngine only supported Python as the programming language, and required the use of very specific API code, that basically meant that if you wrote something for AppEngine, it would not run anywhere else.

Since its inception, Google always Java promised support for AppEngine. Today, Google announced the first preview for Google AppEngine for Java. Interestingly, unlike the Python API, the Java edition of AppEngine uses a lot of Java EE standards: WAR, JPA, Servlets, JSP, etc. This means that it is easy to program if you already know Java EE, and it is easier to migrate to or away from AppEngine. The Java edition promises support for data storage, authentication, in-memory-caching and probably other features of AppEngine, like scheduling, will be supported as well. The Google Web Toolkit (GWT), Google's AJAX Web framework for Java, can be used in AppEngine too. See this intro movie for more information (captioned, no need for sound).

The AppEngine Java preview includes an SDK, complete with Eclipse support and a local sandbox environment. The "preview" program just got started, so there are limited slots for hosting applications. Claim your slot on the AppEngine page and start writing some cool Java apps!

The user interface beyond Star Trek

peterhe — Sun, 15 Mar 2009 18:07:00 GMT

Everyone knows about Star Trek and the science fiction genre. Science fiction plays with future technologies that do not exist yet. While not everything in Star Trek has now been invented, when it comes to user interfaces, we are pretty close. We now have touch-screen, very small computers, voice commands and rich real-time 3d visualization (real life proof of this: the Star Trek Flat).

Well, Star Trek will need to update real fast. The computer industry is still rapidly evolving, and pretty soon, the post-Star Trek user interfaces might emerge. A great example is the Sixth Sense research project. This is a portable image recognition and projecting device, that provides in-context display and can be used using gestures, projected surface interaction, or simply holding objects in front of it. See this TED presentation for more information and some great demos. It will be interesting, when this becomes mainstream, how much of current UI frameworks can be reused to build the next-gen interfaces.

Manifesto for Software Craftsmanship

peterhe — Sun, 08 Mar 2009 14:06:00 GMT

By now, everyone in the software development industry probably heard about "agile" development, formally described in the Agile Manifesto. Agile was a rebellious response to the continuing push of vendor-driven processes and procedures, which seemed to balloon in its efforts to describe every complex artifact and activity, preventing professionals to think up more simple solutions for the problems at hand.

The agile manifesto is a call to action to emphasize several points the big-process guys seemed less important. It's about relying less on a big tell-me-all-do-nothing-without-it process, complex tooling, huge documents without any real proof, a detailed contract and planning set in stone. Agile states that these concepts are at odds with the very nature of software development, yet were at the time (and still are at a lot of places) commonly practiced.

Whether agile is right about this (I think it is) has always been controversial and a source of heated discussions. This seems strange: if you consider "change" in a software development project as inevitable as "gravity" in the real world, you would expect no real debate on something so obvious. However, unlike falling apples, most problems and forces in software development are more abstract and subtle, and solutions often seem counter-intuitive.

Another controversy in the software development industry is about quality. To a lot of people, quality costs money, and lower quality equals cheaper production equals money saved. This very simplistic thinking leads to spending less on qualified developers, less solid testing and/or improving based on test results, less on learning, coaching and/or improving, less on usability and creative, but risky solutions.

Again, the opposite is true. High quality means better efficiency because of the extra reuse opportunities, a more predictable schedule (less meetings and re-prioritizing efforts), less re-work on testing, fixing bugs, and testing again, and higher return on investment in production, because of better features, less failures and greater user satisfaction. Actually, the best way to waste money is try to achieve the lowest quality possible, something the manufacturing industry already knows for decades.

To emphasize the value of quality and a professional attitude when developing software, the Manifesto for Software Craftsmanship has been created by the software craftsmanship group. Based on the Agile Manifesto, this manifesto declares that in order to be agile, you have to be professional. Probably, like the agile manifesto, it will lead to some heated discussions, with dogmatic enthusiasm and stubborn rejections. I think it's a just cause though: it's not just what something costs by the hour, but also what it delivers in return. If you agree that craftsmanship matters when developing software, sign the manifesto to show support!

Java 7 and the Elvis operator

peterhe — Mon, 02 Mar 2009 18:53:00 GMT

With Java 6 out for quite a while now, Java 7 is finally looming closer for a release due in early 2010. Most of the big changes are either scrapped (like support for closures or a standard module system), or actually pushed into a Java 6 update (the new G1 garbage collector is coming in update 14).

Not all is lost on Java 7 though. Along with several API updates and JVM/tooling improvements, there are also some language changes expected. These are gathered in "Project Coin". The clever name implies that each proposal involves "small" change, and refers to the proverb "to coin a phrase".

One of the proposals is the new "Elvis" operator. It involves using the question mark as a shorthand to check for null scenarios. One of the expressions is this one:

?:

If you look sideways, it's Elvis! I really am not that fond about this kind of programming, but having something called the Elvis operator as a new feature is reason enough for me to migrate asap. ;) I hope other language additions will get a similarly cool name.

JUnit to the Max

peterhe — Mon, 09 Feb 2009 20:08:00 GMT

I just stumbled upon a cool new project from JUnit grandfather Kent "XP" Beck. It's called JUnit Max and basically introduces the "Run tests on save" feature in Eclipse. This means you don't have to think about running tests, they always run. The tests are run in fail-first order, so if you're in the change/retry cycle of fixing a test you get immediate feedback. See the link for a slidecast explaining the product. The licensing model for the beta is a bit strange: 2 dollars a month! I think it's a great concept though: it promotes more running of tests and adds another argument to why unit tests should run isolated and as fast as possible.