Topic: Systems development

Grails: Controller and Action Names in GSP

Grails is a powerful framework for building web applications in Groovy. This post is about a tiny little corner of Grails development.

The presentation layer in Grails, also known as views, is built from Groovy Server Pages (GSP). The names of the controller and action that spawned a view are not automatically available in the view. This post shows you a very simple way to provide those names to views.
Continue »

NoSQL: Don’t Take the Drug Unless You Have the Symptoms

NoSQL databases are hot, and rightly so. Many of them aspire to solve some of the trickiest database problems of all, problems that have been nagging database research for decades: scaling up and scaling out.

In some trade press and other places the NoSQL discussion has to be simplified. Sometimes a casual reader may get the impression that NoSQL just makes relational databases old-fashioned. This is very far from the truth. NoSQL is there to cure specific ailments. If you don’t suffer from any of those specific symptoms, the side effects from taking NoSQL medication may cause more pain than relief. I’ll explain why and let’s see if you agree.
Continue »

Neo4j Performance: Another Notch

In a number of posts I devised various database micro-benchmarks. The idea was to set the stage for an epic battle between NoSql and relational. In less grandiose terms I tested Neo4j, an all-Java network database, Apache Derby, an all-Java relational database and PostgreSQL, trusted non-Java relational workhorse with a heritage.

This is a short closing note in the series, commenting on Neo4j performance.
Continue »

Neo4j Performance Revisited and Appreciated

My previous Neo4j performance micro-benchmark left a disturbing hole: There was no explanation why Neo4j didn’t cope well with big transactions.

A closer study uncovered the pretty obvious reason. It also turned out to be the key to zippier Neo4j performance.
Continue »

Low Level File Information For Java

This post is good news for some Java programmers. Once in a while you wish you knew a bit more about the files you access from Java. The class offers only a bare minimum of visibility.

If you are wrestling with this problem, and if you are on a Linux/Unix platform, download the filestat package from this website and get going. This post introduces the package briefly.
Continue »

The Schema-Less Database: Freedom or Bondage?

Some of the new strain of NoSQL databases are schema-less. They also claim this is a feature that brings flexibility. If the schema is such a roadblock, why was it invented in the first place?
Continue »

Why NoSQL Won’t Replace Relational Databases Anytime Soon

These days there is a lot of buzz about NoSQL databases. We hear that new databases are about to replace relational ones because the relational data model is so old.

I’m sure this won’t happen anytime soon. On the other hand, I don’t believe NoSQL databases will go away either. My prediction is that new NoSQL databases will keep popping up. Each one will fill a specific need for a time, and then fade away. No two NoSQL databases will ever be compatible. Standardization is fundamentally contrary to the reason why NoSQL databases exist.

Hang on and I will show you why.
Continue »

Network versus Relational: Part III

In previous posts (original post, follow up) I ran small database performance tests involving Neo4j (a graph or network database) and Apache Derby (a relational database). Both are Java-based.

How about running the same tests with trusty old PostgreSQL? Neo4j and Apache Derby were both embedded in the test application. There was no database server, although Derby may be run in client-server mode.

PostgreSQL is a fully featured RDBMS firmly founded on the classical client-server architecture. It’s been around for ages. The server is coded in C.

The PostgreSQL logo is a stylized head of an elephant. If you think it’s a symbol of heavy feet you are in for a surprise.
Continue »

Network versus Relational: Part II

In a recent post I ran a simplistic database performance test involving Neo4j (a graph or network database) and Apache Derby (a relational database). Both are Java-based. Relational databases are challenged by deep hierarchies, so the test was exactly that: Build a deep hierarchy and retrieve data from it.

The retrieval test was a surprise because relational Derby seemed to perform better than Neo4j.

Anders Nawroth, Neo Technology, correctly commented that the retrieval test case searches for any file in a hierarchy, i.e. the search is independent of the hierarchy. The relational test program took advantage of this fact while Neo4j traversed the the graph.

In the interest of fairness this post digs somewhat deeper into the retrieval test case. The results are intriguing.
Continue »

Network versus Relational

It’s time for the long awaited Network versus Relational database head-to-head, no-mercy showdown. Network databases is represented by Neo4j 1.0, relational by Apache Derby
Continue »