Development Musings

Functional UI programming

2011-07-10T07:04:00.000-04:00

I started using Scala recently to develop a movie player as a side project, with the goal of using functional constructs whenever possible. I found myself using imperative-style programming when interacting with the UI framework. This got me thinking, is there a functional state-less way to develop UIs? A bit of Googling revealed the following:

A StackOverflow post that talks about this problem and references functional reactive programming (FRP).
The Haskell people have developed UI frameworks around FRP.
For the rest of us non-Haskell people, there is Flapjax, an FRP model built on top of JavaScript for the web.
The spreadsheet is an example of a FRP model where cells are re-evaluated when dependent values change.
Clojure creater Rich Hickey recommends sticking with state-ful programming but keeping it to a minimal.

Drupal Developer Modules

2011-01-13T23:31:00.000-05:00

Imagine if Firebug disappeared all of a sudden and you have to build a website/app without it?

I came across 3 Drupal modules for development that will help you do better customization, improve performance and responsiveness of the beast, and help flatten that learning curve. These modules may even get you to start thinking about using Drupal in the web application space, as opposed to a mere brochure-ware. After spending 30 minutes with these modules, you're going to feel like you've been developing without Firebug. Drupal development may even be fun.

Devel - 61k sites report using it, which probably means that you should be using it. This is the core development module that provides the usual SQL query profiling, node debugging, etc..

http://drupal.org/project/devel

DrupalForFirebug - 5k sites using it. The name is exactly what you think. Never again will you do var_dump($node). You can see SQL queries profiled. And it's all organized in Firebug into separate Drupal tab (as opposed to a Firebug console dump). There's even a Chrome extension.

http://drupal.org/project/drupalforfirebug

Devel Themer - 2k sites using it. The Firebug Drupal extension is a sleeper compared to this. When enabled, you can hover almost any piece of content (like Firebug) and see the Drupal function call and/or theme file that emitted it. It even shows the arguments of the method and tells you what template file to create to override the function. This makes it MUCH easier to customize the output of piece of content because you no longer have to track down the 10s/100s of files and piece together what is calling what. Watch this screencast: http://ftp.drupal.org/files/videocasts/moshe-theme-developer.mov.

http://drupal.org/project/devel_themer

Free to distribute fonts from Google

2010-12-25T09:32:00.001-05:00

Web fonts can be boring. There are much nicer fonts on your desktop operating system or application. But these fonts are not free and can be very costly to distribute. Fortunately, there are nice looking free fonts for free distribution, provided by Google:

http://code.google.com/webfonts

Writing Testable Code

2010-10-30T11:28:00.002-04:00

Check out Misko Hevery, the clean code talk guy's guide to writing testable code:

http://misko.hevery.com/code-reviewers-guide/

The page itself is a 5-minute read but download PDF for a more detailed explanation of the rationale for these guidelines, which are sort of a common realization among folks who have gone through the trials and tribulations of extensive unit testing.

There's also quite a bit of other interesting stuff on his blog, including: augular, a RAD platform for developing CRUD apps on the web with only HTML (no server-side, no SQL); and CoffeeScript, a terser way of writing JavaScript.

Data recovery tutorial using Ubuntu Linux

2010-06-19T13:36:00.007-04:00

I have an old hard disk with corrupt NTFS volumes and I want to recover the data. I'm not sure how the drives got corrupt but they cannot be fixed by chkdsk /f. Fortunately, there's a plethora of open source data recovery tools available. Two such tools are foremost and photorec which specialize in combing through hard drive partitions to recover files based on header information. They can even recover files after accidental reformatting.

Foremost is a tool originally developed by the U.S. Air Force and is available via sudo apt-get install foremost. It can recover common file types such as txt, jpg, avi, and etc.. Foremost was last updated in 2008 which means that its knowledge of file headers is, at best, two years dated.

Photorec is part of the testdisk suite and is available via sudo apt-get install testdisk. Testdisk is a tool that not only "tests your disk" but also rebuilds your partition table. This is the tool to use if your hard drive's master boot record or partition table is corrupt. Photorec, like testdisk, is a poorly named command-line tool. Like foremost, photorec recovers files (not just photos) based on file headers. In fact, photorec supports more file types and is more up-to-date than foremost, which is evident by the fact that I was able to recover more files with photorec than foremost.

The problem with both foremost and photorec is that they recover file content but not file names. So you end up with directories of randomly named files with only the file extension preserved. It's not ideal but it's still better than not having the data at all.

See also:
http://help.ubuntu.com/community/DataRecovery

Towards a Universal VM

2010-06-05T11:42:00.001-04:00

Alex Buckley talks the features and progress that should make the JVM the universal run-time environment for languages. Interesting discussion in the talk include:

the distinction between the roles of the byte-code compiler and JVM compiler.
a high-level overview of how the JVM does method inline optimizations.
the introduction of dynamicinvoke in the new JVM.

The talk is normally 1-2 steps lower level than what software developers deal with on a day-to-day basis but nevertheless very understandable and useful to know.

Ubuntu Linux on a Syntax Olevia LT30HV

2010-02-28T16:56:00.000-05:00

The Syntax Olevia LT30HV, like many off-brand low cost LCD HDTV, does not provide accurate EDID information which prevented me from running the LCD at the native resolution 1280x768. After extensive Googling, I finally found the necessary configuration to put in my /etc/X11/xorg.conf.

1. First, make sure you have the proper Modeline in your Monitor Section:

Section "Monitor"
        Identifier      "Default Monitor"
        HorizSync      31.5 - 80.0
        VertRefresh    56.0 - 75.0
        DisplaySize    722 406
        Modeline "1280x768" 79.464 1280 1360 1488 1664 768 771 778 798 -Hsync +Vsync
EndSection

2. Make sure your Screen include the Option UseEDID and ExactModeTimingsDVI like so:

Section "Screen"
        Identifier      "Default Screen"
        DefaultDepth    24
        Monitor         "Default Monitor"
        Option         "UseEDID"        "false"
        Option         "ExactModeTimingsDVI"    "true"
        SubSection     "Display"
                Depth      24
                Modes      "1280x768"
        EndSubSection
EndSection

3. And of course, make sure you use the nvidia driver:

Section "Device"

        Identifier      "Default Device"
        Driver "nvidia"
        Option "NoLogo"        "True"
EndSection

That's it.

New features in Spring MVC 3.0

2010-01-17T15:13:00.000-05:00

This webcast gives an overview the new features in Spring MVC 3.0. The data binding and validation has been improved dramatically. This talk is useful if you are using version 2.5 and also want a sense of good practices to follow.

REST-style URLs for older Java web applications using UrlRewriteFilter

2009-12-30T19:31:00.002-05:00

Say you have an old old Java Web application that uses URLs like this:

/queryVehicles.jsp?make=Ford&model=Fusion

You want your URLs to be pretty and more RESTful like so:

/vehicles/ford/fusion

Well, you have two options. You can re-write your web application to use newer web frameworks that supports REST-style URLs such as Spring MVC 3.0, which will probably take months to do. Or you can use UrlRewriteFilter which should take no more than 30 minutes and will work with any existing Java web application.

UrlRewriteFilter very easy to use. You basically:

Add UrlRewriteFilter as a servlet filter in your WEB-INF/web.xml
Populate WEB-INF/urlrewrite.xml with mappings of REST-style URLs to the corresponding URLs of your legacy web application (with query params and what not).

That's pretty much it.

UrlRewriteFilter is extremely powerful. It supports regular expression pattern matching, allowing you to perform pretty complex mapping. Check out the manual page for details.

Remove ifs/switches from your JSPs through feature labeling

2009-12-14T21:39:00.026-05:00

In this post, I outline a technique I call "feature labeling" as a means of organizing your web application's HTML views into features that can be selectively enabled and disabled without unmaintainable if/switch statements. I will use JSP and Spring in my example though this technique can be generalized to any view technology that allows for custom tags and any dependency injection container.

Say we are writing a prototypical blogging web application. All blogging applications give authors the ability to edit a blog entry. One straightforward way to implement this is to check if logged user is the author of the blog and then displaying the edit link to the user like so:

<c:if test="${user == blog.author}">
  <a href="/blog/233/edit">Edit Blog</a>
</c:if>

Months later, say we decide that the administrator should also have the ability to edit blogs. We can add an 'or' condition to the if statement like so:

<c:if test="${user == blog.author || user.role == 'admin'}">
  <a href="/blog/233/edit">Edit Blog</a>
</c:if>

The good developer, however, should see that we are going down the path of littering our JSP/HTML view with too much logic, which will ultimately become harder to test and less maintainable. The "right thing" to do is to push this logic to a middle tier.

First, remove the if logic and replace it with the custom JSP tag "dm:feature" (to be created) like so:

<dm:feature name="blogEditing">
  <a href="/blog/233/edit">Edit Blog</a>
</dm:feature>

Note the attribute name="blogEditing" which will effectively label the inside body as the blogEditing feature.

Second, create a custom JSP tag that will:

Get a FeatureService object from your Spring web application context.
Do a featureService.isEnabled(featureName) to determine whether the body should be evaluated or skipped.

Here is a tutorial that covers the topic of creating custom JSP tag. Hint: Extend TagSupport instead of creating it from scratch. Then to get the Spring web application context, do:

context = (ApplicationContext)pageContext.getAttribute(
  WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,
  PageContext.APPLICATION_SCOPE
);

Third, create your FeatureService interface and implementation. In this example, the implementation would need to be aware of the current user and the current blog so you can do the check "if current user is the blog author." Leave a comment if you want more details.

This should dramatically reduce unnecessary logic in your view and make it more testable because you are pushing the logic into a middle-tier.

Keep in mind that this only eliminates blog editing from the view. You still need to disable the controllers/services for blog editing as well. This is where Spring's Aspect Oriented Programming comes in. Here's a brief outline of what you need to do:

Create an @Feature annotation that requires feature name (e.g., @Feature("blogEditing"). This annotation will basically label methods as being part of a feature.
Create a FeatureAspect bean with FeatureService as a dependency.
Create an around advice (method in the FeatureAspect bean annotated with @Around). This advice should check if the feature specified in the @Feature is enabled. If enabled, execute the method. Otherwise, throw a runtime FeatureNotEnabledException and add top-level handlers to redirect user to a 403 unauthorized page.

Note that the FeatureAspect uses the same logic (i.e., FeatureService) that is responsible for determining whether a feature should be enabled. There's no need to duplicate logic both in the view and middle tier.

Helpful? Let me know.

Usability findings: You look where they look -- False!

2009-12-09T20:07:00.006-05:00

I came across this article on 10 Useful Usability Findings and Guidelines. Points listed are not too surprising. However, I disagree with #2. Essentially, the author is concluding that you can increase people's attention if you have a picture with a face looking at the target text. I think the "study" lacks the proper control to warrant such conclusion.

It could be that a frontward face draws attention away from the text. In other words, the frontward face has a negative affect on attention as opposed to directional face having a positive affect. A simple control stimulus with a face looking in the opposite direction of the text would have revealed whether a directional face actually increases attention. There should have also been a control stimulus of no face or a non-face image to establish a baseline.

The author is also concluding that glances directly translates into attention. The peer-reviewed eye tracking literature have shown that while this is generally true, there are many levels of attention that must be considered. The level of attention desired by content providers is one where the user is reading and comprehending the text, in other words, a high level of attentional processing. It could be the case that a significant number of the glances are accidental or reflexive glances as a result of being steered by the directional face. One way to tease out these accidental glances is to subtract the data from the first few glances across all the images. The glances remaining would be the more intentional ones, the ones that reflect higher level processing.

This is a demonstration of the lack of rigor in non-peer reviewed studies.

Flashing BIOS in Ubuntu Linux without floppy

2009-11-21T15:54:00.014-05:00

I was trying to update the flash BIOS of an old ECS K7SOM+, a 1 Ghz-era AMD Athlon motherboard. The problem is that most older motherboard flash upgrades are designed with a DOS bootable floppy in mind. I have no DOS, no Windows, no floppy drive, and no floppy disks. Fortunately, there's UNetbootin, a tool design specifically to make bootable USB flash drives from Linux. Here are the general instructions for Ubuntu Linux users:

Use gparted to create a single FAT16 formatted partition on the flash drive.

You can install gparted using apt-get install gparted
You may need to first umount the USB flash drive before you can partition and format it.

Use unetbootin to install a bootable FreeDOS onto the flash drive.

Install unetbootin using apt-get install unetbootin or read WestCoastSuccess' comment.
Run unetbootin and:

Select the distribution FreeDOS.
Select your USB flash drive
Click OK. This will download FreeDOS to create a DOS bootable flash drive.

Copy your motherboard's BIOS update and flashing utility files into the root of flash drive. These files will be located in B: or C: drive when you boot into FreeDOS.

That's it. Boot off your flash drive -- you may need to configure your CMOS setup to do so.

Update 2010/01/02: Updated instruction as per WestCoastSuccess.

Maven database migration plugin

2009-11-16T21:55:00.003-05:00

I finally got around to testing c5-db-migration -- a database migration plugin for Maven. Essentially, it's tool for managing your database changes. The plugin is very straightforward to use:

Copy and paste the plugin configuration to your pom.xml.
Add a couple of SQL scripts into your src/main/db/migrations in the format of yyyyMMddHHmmss_some_description.sql
And run mvn db-migration:migrate to run the SQL scripts against your database.

The plugin tracks your migration in a table called schema_version. It's not as comprehensive as Rail's database migration tool (e.g., it doesn't support downward migrations). Nevertheless, it's simple and unobtrusive.

If you're managing database changes manually through collections of SQL scripts, there's no reason why you shouldn't give this plugin a try.

SpringSource tc Server Developers Edition

2009-11-11T21:40:00.003-05:00

At the risk of becoming a SpringSource shrill, check out the video on Spring's Tomcat server for developers.

http://www.springsource.com/products/tcserver/devedition

It's basically a modified version of Tomcat that makes it very easy to profile web applications. It's free but NOT open source.

Saros Pair Programming Plugin for Eclipse

2009-10-19T23:48:00.004-04:00

Saros is a pretty impressive open source plugin for Eclipse that allows collaborative editing (i.e., pair programming). It requires only a Jabber server. Check out this 11 minute video of Saros.

Java Beans without getters/setters using lombok

2009-10-17T11:58:00.009-04:00

Project Lombok is probably going to be one of the most useful library for Java. The library (requires Java 1.6) provides annotations that generate getters, setters, toString, hashCode, & equals for your POJOs. For example:

@Data // Lombok annotation
public class Person {
private String firstName;
private String lastName;
}

// Now your class has all the getters, setters,
// equals(), hashCode(), and toString()

C#/.NET has had this syntactic sugar built into the language for years but I was ambivalent about the approach. I'm more of a fan of languages with sparse syntax set such as C but the downside is that you end up writing much more boilerplate code. I think Lombok's approach is a nice compromise between bloated language feature set and having verbose code because of sparse language feature set. And it's supposedly supported in Eclipse.

Integration testing with Spring

2009-10-06T22:49:00.006-04:00

Watch this Rod Johnson talk if you're not already familiar with rolling back transaction as a means of performing integration tests:

http://www.infoq.com/presentations/system-integration-testing-with-spring

You can probably skip to the 30 minute mark if you're already familiar with the reasons for testing.

Languages for JVM

2009-09-27T19:31:00.010-04:00

The Java language is mature and that in the software development world means that it's dying. The Java language was designed around object-oriented programming but the trend now is moving towards more functional programming (which is arguably better suited in concurrent environments). I've been looking at newer languages built on top of JVM: Groovy, Scala, and Clojure.

Groovy is basically a dynamic version of the Java language with some new language features such as closures (a feature in functional programming). In essence, Groovy is "Java scripted" inspired from Python and Ruby.

Scala is an object oriented language with functional language features. It is not a scripting language and has features such as type inference:

var t = new Tiger();

The compiler knows that t is a Tiger -- no need to do:

Tiger t = new Tiger();

This type information is available at compile-time which allows for compile-time optimizations, making Scala on par with native Java performance.

Clojure essentially Lisp-inspired language running on the JVM.

All the above languages do not differ much with their Java interop (i.e., you can pretty much call existing Java code directly). All reduces the verbosity of Java. If I had to learn one language, I would pick Scala. I think Groovy is too small of an evolution over Java (i.e., not much benefits). Clojure just seems to radical for object-oriented developers.

Here's some additional points in no particular order:

- Martin Odersky, father of Groovy, said "I can honestly say if someone had shown me the Programming Scala book by by Martin Odersky, Lex Spoon & Bill Venners back in 2003 I'd probably have never created Groovy." http://java.dzone.com/articles/scala-long-term-replacement

- Scala is available both JVM and .NET. http://programming-scala.labs.oreilly.com/ch01.html

Integration test hell

2009-09-16T07:16:00.008-04:00

For those of you spending lots of time fixing up integration tests, J.B. Rainsberger explains why he thinks integration tests are a scam:

http://www.infoq.com/presentations/integration-tests-scam

I think the point he is driving home is that we should be focusing more on comprehensive unit tests rather than comprehensive integration tests. I've started changing how I write my integration tests: They should only be verifying the interactivity of components, rather the expected results of the component.

Let's say that a User Service class (UserService) that calls a User Data Access Object class (UserDAO). The unit tests for UserService should use a mock of UserDao and asserting exact equality with the data and exceptions returned from UserDao properly (-- nothing new here). Your integration tests for UserService should use a real UserDao that is connected database (-- again, nothing new here). However, these types of test should NOT be asserting data and exceptions equality. Rather, these integration tests should just be verifying that some data/exceptions are returned. Integration tests should be testing the seams between the UserService and UserDao components, rather than asserting the equality of the value themselves.

Overally, I recommend watching this talk if you have done lots of unit and integration tests writing and wondering if you are duplicating effort.

Review: The Cathedral & The Bazaar

2009-08-31T20:23:00.005-04:00

I finished reading Eric S. Raymond's The Cathedral & The Bazaar (catb). Just a couple of points I want to metion:

- Raymond makes a critical distinction between sale versus use value. I think this is the seminal point in the book. Closed source software that derives most of its value from sales price. Providing technical support eats away at the sale value so it's fundamentally in the interest of closed source companies to limit technical support for at given sale price. In other words, the ideal situation for closed source software companies is for people buy their software and never use it. In contrast, open source derives most of its value from use. The business model of open source companies is centered around support. The more people use the software, the more support resources that will be consumed which benefits these companies that center around support.

- Raymond is not as hardcore open source advocate as I assumed. He does acknowledges places where open source would not be suitable.

- Open source excels in domains where software is a commodity, e.g., infrastructure such as operating system, middle ware space, browsers.

- Open source development is analogous to academic peer review. I would what would Raymond say about more artistic work?

Raymond's writing style is like that of a hacker: It may not be pretty at times but he gets his point through. There's plenty of self-citation which hurts the credibility of some of his arguments. Overall, I'd recommend reading catb primarily as a historical reference. Those of you aware of the open source revolution probably will not benefit much from it. I think it is a must read if you want to start a business centered around open source.

Lean start-ups

2009-08-01T21:07:00.004-04:00

Here's a thoughtful webcast talk about 'lean start-ups':

http://www.youtube.com/watch?v=EnaLQiQL9ec

Lean start-up is not limited to your traditional start-up company. Rather, it can also refer to a small department in a large company. Essentially, the speaker, Ries, believes that an effective lean start-up can be boiled down to rapid releases. Ries suggests a couple of techniques to get to rapid releases. One of the more radical technique is continuous deployment where source check-ins that pass integration tests are deployed automatically. Of course, there would need to be a mechanism in place to revert back quickly. Ries also describes split testing where new features are tested in parallel with existing code, essentially a control and experimental group comparison. Ries also recommends asking the 5-why's on every issue (e.g., asking why did this bug occur 5 times at different level from the programming level to the management level).

This talk is worth the hour if you are interested in improving your development process.

Java Templating APIs

2009-07-24T07:59:00.020-04:00

Many web view technologies are very difficult to unit test. This includes JSP/JSTL, PHP views, Rails views, and probably ASP.NET views. The problem is the lack of the ability to set an arbitrary model to a view and doing a string assertion on the view. (Correct me of I'm wrong.)

I did a bit of research on templating engines for Java. Here they are:

Freemarker - Not specific to the web, unit testable without servlet container, replacement of JSP. Last update in December 2008.

Velocity - Greater community than Freemarker (according to Freemarker themselves). Also not web specific and a replacement for JSP. Last update in May 2009.

String Template - Very minimalistic approach to templating with ports to Python and C#. Also not specific to the web. Last update June 2008.

All of these technologies basically solve the problem of making the view accessible without a servlet container. This makes it easier to pass the responsibility of HTML/CSS design and JavaScript coding off to other developers. Spring supports Velocity and Freemarker though it shouldn't be too difficult to write an adapter for String Template. Right now, I'm leaning towards Velocity because of the better community support.

In addition to templating engines, I also looked at page composition frameworks:

Tiles - Originally part of Struts. Employs the composite pattern where each page explicitly define header, footers, and etc. to include. Support for Freemarker and Velocity templates. Last release in February 2009.

SiteMesh - Alternative to Tiles. Employs the decorator pattern where pages are not aware of the header and footer. Can work with other web technologies (CGI, PHP, and etc.) -- this is COOL. Last update in March 2009.

I am really excited about using SiteMesh. Here's a SiteMesh tutorial.

Database anti-patterns that all developers should know

2009-07-19T17:26:00.004-04:00

Josh Berkus, one of the core developers of PostgreSQL, gives a tongue-in-check talk on 10 ways to wreck your database.

http://www.oreillynet.com/pub/e/1371

The talk is about 40 minutes long -- a decent enough talk. However, the Q&A portion that followed the talk is stellar. Unfortunately, you can't really just skip to the Q&A portion and you definitely don't want to stop watching after the talk because you would get the wrong impression.

The most important point for me was that I need to start using natural keys in my database and normalized through natural keys rather than primary keys.

Why and how of test first development

2009-07-14T18:29:00.009-04:00

Test-first development is the process of writing your test code before your implementation code. I have always felt this was the ideal approach but NOT necessarily the pragmatic approach to development. The thought of writing a full test before writing the code was essentially writing the specifications first and feels almost like a micro-waterfall approach to development.

I attended a couple of talks recently that made me realize that test-first is not necessarily about writing the entire test case before the implementation. Rather, you can take a very iterative approach. The idea is that you write just enough of the test code to get your implementation code to fail followed by just enough implementation code to get it to pass. Then you write just enough test code to get your implementation code to fail again and repeat the process until your test and implementation code is complete.

To be more specific, the first line of test code could simply be calling a method that does not exist in your implementation. This will cause a compile error (for those of us on stronger typed languages). Then you write just enough code to get the compile error to go away. Some of you may be thinking that compiling is not unit testing which is true but it is a form of testing nevertheless.

The second line of test code could simply be an assertion that the returned object is not null. This should result in a test failure. To pass this test, you can simply return a dummy object. Now obviously your implementation code should not be returning dummy objects. So, the third line of test code could compared the return value with an expected value which should cause the test to fail since it was initially returning a dummy value. Then at this point you would modify the implementation method to return the appropriate value dummy object.

Note that this approach breaks up your test into finer grain assertions. Had you write the test first, you would probably have never thought about performing an assertNull which would aid in debugging. In more complex methods, there would probably be many forgotten assertions. This finer grain approach also makes the test easier to write since we are taking a small bite at a time.

I have been using this approach for the last few months and this has actually become my preferred means of development. In fact, I now get that dirty feeling when I write tests after implementation, much in the same way a test-infected person feels dirty pushing code without unit tests.

Rolling your own security authentication/authorization?

2009-07-11T19:11:00.003-04:00

Before you do, watch this 50 minute video on Spring Security:

http://www.viddler.com/explore/oredev/videos/22

Make sure your implementation of security rolling matches the ease of implementation and features of Spring Security. If not, use Spring Security.

Database Connection Pooling: c3p0 versus dbcp

2009-07-04T09:43:00.005-04:00

I was looking at database connection pooling the other day and was trying to decide between c3p0 and Apache Common's dbcp. Both are open source (of course) and implement the standard DataSource interface, which means that you can pretty much swap out one for the other without breaking functionality. Both are not very up-to-date with their last stable releases being over two years ago: The last stable release of dbcp (1.2.2) was 2007-04-04 while for c3p0 (0.9.1.2) was 2007-5-21. The consensus appears to say that dbcp is better for single threaded applications while c3p0 is better on multi-threaded applications (which would include your webapp). Based on this alone, I favor c3p0.

Reference:
Spring Forum posting
Javatech comparison of c3p0 versus dbcp
Stack Overflow discussion

Spring versus Hibernate Validator

2009-07-01T20:33:00.006-04:00

I looked at both Hibernate and Spring Validation briefly today.

Hibernate is annotation-based and works something like this: (1) You annotate with the proper validation rule (e.g., @NotNull) on the fields of your bean; (2) You call Hibernate's ClassValidator to validate, which returns the validation errors. Presumably, it inspects the annotations on the bean fields and performs the appropriate validation.

Pros: Easy declaration based validation.
Cons: I haven't figure out a way to perform database check for uniqueness.

Spring's validation is programatically-based. You implement the Validator interface which contains two methods, one of which is the validate method. You perform your validation manually, either writing the rules yourself or using Spring's utility methods, e.g., ValidationUtils.rejectIfEmpty(...)

Pros: Very flexible which allows for database record-based validation
Cons: More complex than Hibernate's Validator.

Neither solution is particularly ideal. Hibernate seems too simplistic while Spring's requires too much programming. I lean towards Spring's Validator mainly because it's very apparent as to how one would perform database record validation.

Reference:
Tutorial: Getting Started with Hibernate Validator
[Chapter] 6.2 Validation using Spring's Validator interface

Groovy over Java

2009-06-20T23:33:00.005-04:00

Dynamic languages, once relegated to hobbyist and small mom-pop development shops, now (as in the last 2-3 years) seem to be the latest fad in "enterprise" development shops. I think this was largely due to the success of Ruby on Rails and Python which showed that you can write maintainable large scale software using dynamic languages.

Groovy appears to be the Java community's answer to dynamic languages. Groovy is a superset of Java which means that your existing Java code should mostly work in a Groovy interpreter. Groovy provides many of the syntactic sugar that you see in dynamic languages such as key-value dictionaries (hash tables), named parameters, closure, and etc.. Groovy has been submitted to Java Community Process program for standardization.

I'm still a bit mixed about using dynamic languages because I like the security of compile-time type checking. However, I do see myself using Groovy to write my unit tests since the syntactic sugar can potentially make my unit tests easier and faster to write.

Spring MVC

2009-06-09T21:46:00.008-04:00

Here is a nice link describing the features of Spring MVC:

http://www.infoq.com/articles/spring-2.5-ii-spring-mvc

The information may be outdated with Spring 3.0 just around the corner.

One of things I like about the Spring Framework in general is that it's not very intrusive. Depending on your requirements, you can use the Spring Framework without: extending any class, implementing any interface; nor writing any adapter classes. This makes the framework extremely flexible because you are not locked into their application programming interface (API). If you're reading this blog, then you probably know that using open source frameworks is a way to avoid vendor lock-in. However, using open source alone is not enough to prevent vendor lock-in. We also have to think about API lock-in. The more your framework requires implementing/extending framework specific interfaces/classes, the more at-risk you are to API lock-in.

The Spring Framework also has a la carte style approach of integration into your existing software components. You use what you need and can add the incrementally framework as you evolve as a developer. In my current project, I started off using Spring's mock (stub) objects for testing (instead of writing my own MockHttpServletRequest). Then I used Spring's Object/XML Mapping (OXM) framework to domain convert objects to XML and vice versa. Now I'm looking to use Spring's MVC framework and eventually move all my object configuration and construction using Spring's core bean container.

Failed Searches

2009-06-05T21:40:00.008-04:00

I'm lazy. Very lazy. I don't like keyword searches that do not return what I want on the first page. I don't like it because I have to make extra mouse clicks to find what I want. And I don't like extra mouse clicks because I'm lazy.

I'm sure I'm not alone. As obvious as this may seem, many commerce websites don't get it. They develop interfaces that make me perform unnecessary mouse clicks. They make me turn pages. If I have to turn to the next page of a results set, then your search has failed. Your search should have return the relevant results on the first page. Many sites also make me sort my search results. If I have to waste mouse clicks to sort my results, then your search has failed. Your search should have returned in the order of most relevant results. Some sites have even gone as far as making me filter my results set. If I have to filter the results set, then your search has failed. Your search should have returned only filtered results.

This all may seem a bit harsh. The point, however, is not to set unrealistically high criteria of what constitutes a good search engine. Rather, I'm suggesting that as developers we need to value mouse clicks. Every mouse click is precious and should not be wasted on paging, sorting, and filtering -- none of which would be needed if the search was done right in the first place. In the end, paging, sorting, and filtering are all crutches for broken searches.

Review: Java FTP Servers

2009-05-24T00:18:00.002-04:00

I needed an FTP server to perform functional testing of some FTP client Java code (commons vfs). The top 5 Google results for "Java FTP Server" were:

Apache MINA FtpServer - Runs as standalone or embedded; free and open source (Apache License)

FtpGoServer - Runs as standalone; source can be purchased

jftpd - Runs as standalone; appears outdated (last release in 2001); incomplete implementation

Java Secure FTP Server - Runs as standalone; free and open source (GPL)

Colorado FTP - Runs as standalone; free and open source (LGPL)

My pick is Apache Mina FtpServer. It's an active project. It can be easily embedded into any functional test -- the alternatives require peering into the source, writing adapter classes, etc.. It's also the only one that shows significant activity in Google Trends.

UPDATE 5/26/09: Documentation of Apache Mina is pretty thin (as with the other FTP packages).

Reduce IDE clutter with Mylyn

2009-05-24T00:07:00.001-04:00

One of the problems with working on a large project in Eclipse (or in any IDE) is navigating through various project resources (e.g., classes, methods, and etc..). Mylyn, a Eclipse feature, attempts to solve this problem by providing a focused view that shows only the relevant resources for a given task:

http://tasktop.com/videos/mylyn/webcast-mylyn-3.0.html

Skip the first 4 section because the speaker blathers on and on about various impediments to a software developer's productivity. Begin at section 5 and watch until you get bored (~30 minutes).

Key features of Mylyn include:

Integrated view with ticket issue tracker software such as Bugzilla, Trac, and JIRA. Issues assigned to you are downloaded into the Eclipse project so that they can be viewed offline without the delay of launching a browser and waiting for a page load.
As you work on an issue, Mylyn tracks your visits to classes, methods, and resources to create a task context. You can upload the task context to share with other developers who would be able to view the classes, methods, and resources relevant to the ticket issue.
Bug numbers inlined in code comments can be clicked to bring the ticket issue into view.

In other words, Mylyn integrates Eclipse with your issue tracker so that only the relevant project resources are visible at any given time.

JavaScript is elegant

2009-05-17T20:01:00.000-04:00

I used to think that jQuery made JavaScript elegant. I was wrong. JQuery just helped me understand what is already a quite elegant language. Watch this entertaining 1 hour Google Tech Talk by Douglas Crockford, author of JSLint, JS Min, and several essays on JavaScript misconceptions.

http://www.youtube.com/watch?v=hQVTIJBZook

Among the things he discusses are:

The origins of JavaScript and the design flaws
General constructs to avoid in JavaScript
How closures are used to create objects
Benefits of using as a functional language
Uses of the triple equality (===) operator

Probably his best statement about JavaScript is that most of us know how to use JavaScript without taking the time to understand it.

If you've done or will do any work in JavaScript, please take the full one hour to watch this talk. It's worth it.

Inspirational talk

2009-05-16T08:22:00.001-04:00

Damien Katz talks about the path that led him to develop CouchDB, an open source document oriented database. It's not very technical and it's inspirational in an ordinary down-to-earth way.

http://www.infoq.com/presentations/katz-couchdb-and-me

Clean code talks

2009-05-14T00:59:00.001-04:00

Below are four fantastic talks (~30 min each + Q&A) on clean code and unit testing. I wish I came across them a few years ago when I was first starting out unit testing -- would have saved me so much pain.

http://www.youtube.com/results?search_type=&search_query=clean+code+talks+misko

If you're a developer with a few years down your belt, you should know why:

if statements are bad
new statements are generally bad
singletons are an anti-pattern
service locators were the pre-cursor to dependency injection

If not, watch the talks and you will feel much smarter!