Archive for December, 2010
Web clients are hot. Hip. Sometimes even hype. But having worked on different projects, both fat clients and web applications, I’m starting to grow a consciousness on when a web application is appropriate and when the choice for a fat client would be a more sane one.
Fat clients have a bad reputation. Deployment issues being the main culprit here. With web applications, you just deploy it on a server and every user has instant access to the application. Fat clients, for example using Java Webstart, need to be installed on the local client. They also require a JVM. Updating is not instantly, but requires a restart in most cases (unless for example you’re using some fancy modular architecture that allows updating on the fly). From an operations standpoint, fat clients are maintenance burden that isn’t popular. But Java Webstart has evolved, and in the light of that evolution, perhaps it is time to re-evaluate our behavior on defaulting to a web client. Read the rest of this entry »
I’ve been a IntelliJ user since being introduced to it at version 6. Recently, the new version X (10) has been released and off course I installed it on my trusty Linux notebook.
I’m impressed. Whereas versions predating 9 where slow to startup, IntelliJ has become lightning fast. All indexing (which is fantastic once it’s done) is performed in the background, almost instantaneously allowing you to start coding. And I haven’t even started on mentioning some new features I really, really like:
- The new code completion. Completion as you type. No more Ctrl+Tab. Need I say more? This is going to shave off a few minutes every day, which is my only requirement before an upgrade.
- Android Maven projects are supported. In version 9, the Android support was already great, this was just the one thing I missed.
- Out of the box GitHub support
- Detachable source code tabs. Another good move towards dual screen developers. Dual screen coding in Java IDE’s is still subpar, but it’s getting there
- Enhanced Maven support. IntelliJ was already the best Maven IDE out there (sorry m2eclipse), it just got better. I really like the new POM refactors. There is still one thing annoying me: inserting a dependency in a POM containing a dependencyManagement section, still inserts the new dependency in the standard dependencies part. Luckily, the templates go a long way, but still.
- Great Spring Roo support. Now STS is really going to feel the pain.
- Spell checking in the commit comments. Sounds silly, but more than often necessary (take a look at the commit log at your company to see what I mean).
Jetbrains, you really delivered on this release. More than ever, you are my IDE of choice.
Writing extra code in the form of tests at first seems contradictory to enhancing productivity. At least it is perceived as such by managers. Extra code means extra time, and extra time means either delays, higher costs or probably both. A developer trying to introduce test-driven development will have a hard time convincing the people in suits of the merits of it. There are several reasons to this:
- Most of their software was written without test-driven development, and it works
- Once software works to a degree management is happy, the problems that occurred during the development of that piece of software is somewhat forgotten
- Selling software driven development is selling a concept. It’s hard to visualize the benefits of TDD without getting into technical details. And management hates technical details
- Let’s face it, techies aren’t the best of salesmen…
But there must be some truth in all the hype, mustn’t there? Well, let me try to see at the benefits of TDD through a manager’s view. Read the rest of this entry »
I’m all for open source. If there’s a OSS alternative to a product that fits my needs, I’ll be using it.
That said, some tools are just that good that it’s worth paying for. They should be viewed as a prime investment. The tools I’ll be talking about are usually repaid in a matter of month in terms of increased productivity.
A craftsman is only as good as the tools he works with. And for me, the best tools for performing my job is IDEA. I know I’m threading on religious ground here, as IDE wars are easily rekindled. But let me tell you why. A personal license costs EUR 230 or USD 249 (given the current exchange rate: better to buy in dollars), which is a real bargain (compared to other commercial IDE’s). The functionality and usability provided is unmatched by other IDE’s and due to the commercial nature of the product, innovation efforts are generally higher. Support is provided by Jetbrains and included in the license. Minor upgrades are free and you get a 40% discount for a major upgrade.
Bug and task tracking are essential for maintaining a clear view towards the work that needs to be done. Although there are nice alternatives out there (Redmine for example), none can match the power of JIRA. Especially with the latest 4.x version, it is simply put the best issue tracking system out there and well worth its price. I admit, it’s rather high, but again, the gain in productivity, communication and synergy between departments assures a quick ROI.
I’ve worked with ViewVC, WebSVN and other repository viewers and I can state for a fact none of those even come near to the functionality of FishEye. The only thing still lacking is an interactive branching view when using Git (gitk on steroids), but thats just me.
Zephyr Test Management
Test scenario management. About every company out there has his own way of coping with the different scenarios a tester needs to go through in order to sign off on a product. We’ve all seen the copious spreadsheets, the 200-page test document and other behemoths. I know, unit tests should assure that a product is stable and working, but every product needs to go through user testing.
Zephyr is a great looking product and works fantastic. It allows testers to track scenarios and integrate findings with issue tracking systems. For example, it has top notch JIRA integration. It can be purchased as a SaaS solution, which I feel is a great way for dealing with this kind of software: user testing in a company is usually not a ongoing activity.
Go for open source if you can, but if there is a tool that enhances your productivity to a level that surpasses the cost of that tool, buy the tool. Think long term.