Wintermute Blog

Easy XSLT without installing anything

2011-11-08T19:50:00.005+03:00

Sometimes you need to apply an XSLT to some XML, and there are (at least) a couple of ways to do it:

(a) Install a processor like Saxon and run it through the command line;
(b) Reference an XSLT from your XML file, and then open it in a browser;

Both are somewhat problematic - the first one requires installing and running something, and the second requires modifications to the XML. I propose a useful and effective alternative, which I've been using successfully for quite a while. The idea is as following: you simply open a special HTML in a browser. This HTML contains a JavaScript that loads both XML and XSLT files, applies the transform and renders the result into its own DOM. Here is the HTML I use, it is really simple and works in both IE and Mozilla. All you need to do is replace the filenames (input.xml and template.xsl):

<html>
<head>
<script>
function loadXMLDoc(fname)
{
 var xmlDoc;
 if (window.ActiveXObject)
 {
  xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
 }
 else if (document.implementation && document.implementation.createDocument)
 {
  xmlDoc = document.implementation.createDocument("","",null);
 }
 else
 {
  alert('Your browser cannot handle this script');
 }
 xmlDoc.async = false;
 xmlDoc.load(fname);
 return(xmlDoc);
}

function displayResult()
{
 xml = loadXMLDoc("input.xml");
 xsl = loadXMLDoc("template.xsl");
 if (window.ActiveXObject)
 {
  ex = xml.transformNode(xsl);
  document.getElementById("content").innerHTML = ex;
 }
 else if (document.implementation && document.implementation.createDocument)
 {
  xsltProcessor=new XSLTProcessor();
  xsltProcessor.importStylesheet(xsl);
  resultDocument = xsltProcessor.transformToFragment(xml,document);
  document.getElementById("content").appendChild(resultDocument);
 }
}
</script>
</head>
<body onLoad="displayResult()">
 <div id="content" />
</body>
</html>

A sample use case: you have an application which logs some data into an XML file at a given location. You write an XSLT that filters errors in this log, and adjust the filenames inside the HTML above. You save this HTML on your Desktop, and every time you open or refresh it, it shows you the current errors in the log. It is easier and more user-friendly than running BAT-files saving output of transform into some temporary HTML and then opening it.

Meet Flowkeeper, a new open-source software timer for Pomodoro Technique

2011-01-14T22:57:00.003+02:00

I want to present you the very first version of Flowkeeper - yet another free software timer for Pomodoro Technique. Initially it was designed as a desktop UI for Pomodoro Server - my another project supporting teamwork for PT. Despite the almost-ready-for-production state of the latter one, I decided to implement both online and offline modes in Flowkeeper, and release offline-only version first. So here it is, ready for download :)

Some of its features:

Your plans are persistent and can be viewed after the program is closed;
Configurable timer sounds and system tray notifications;
Some basic single-day statistics;
Supported platforms: Windows (with installer), Linux KDE, Linux Gnome (no system tray), MacOS (reported, but no details yet);

I am pretty ambitious about this project. Here are some of the features to be included in the next version, just to name a few:

New multiplatform installer;
Activity Inventory;
Better statistics;
Source code will be published on SourceForge;

So, keep tuned and don't hesitate to contact me.

Oracle driver in Maven

2010-06-30T17:15:00.002+03:00

This is just a short reminder how to add Oracle driver as a dependency in POM.

In pom.xml:

<dependency>
<groupid>com.oracle</groupid>
<artifactid>driver</artifactid>
<version>10.14</version>
</dependency>

In command line:

mvn install:install-file -Dfile=PATH_TO_DRIVER/ojdbc14.jar -DgroupId=com.oracle -DartifactId=driver -Dversion=10.14 -Dpackaging=jar

Fluent Interface Inheritance

2010-04-17T22:55:00.007+03:00

Fluent Interface is a convenient way of writing DSLish code in the general-purpose programming language. Some of the examples are quite impressive. But there comes a problem when you try to reuse this pattern via inheritance, because the basic method chaining implementations do not actually support it very well. I will use a JPA example found in Wikipedia to demonstrate the problem:

public Collection<Student> findByNameAgeGender(String name, int age, Gender gender) {
 return em.createNamedQuery("Student.findByNameAgeGender")
  .setParameter("name", name)
  .setParameter("age", age)
  .setParameter("gender", gender)
  .setFirstResult(1)
  .setMaxResults(30)
  .setHint("hintName", "hintValue")
  .getResultList();
}

Looking at this code we can now create a naive Query implementation:

public interface Query {
 Query setParameter (String name, Object value);
 Collection getResultList() throws SqlException;
}

public class PreparedSqlQuery implements Query {
 protected Map params = new HashMap();
 public Query setParameter (String name, Object value) {
  params.add(name, value);
  return this;
 }
 public Collection getResultList() throws SqlException {
  // Execute query and return results
 }
}

public class SimpleQueryUser {
 public static void main(String[] args) throws Exception {
  new PreparedSqlQuery().setParameter("name", "value").getResultList();
 }
}

No problems at all, our Fluent Interface is clean and elegant. But what happens when you create a subclass for executing prepared statements? You don't want to implement all that multiple setXxx methods once again, and instead decide to inherit from PreparedSqlQuery:

public class StoredProcedureCall extends PreparedSqlQuery {
 protected String outputParameter = null;
 // Stored procedures may have both input and output parameters
 public StoredProcedureCall setOutputParameter(String param) {
  outputParameter = param;
 }
 public Collection getResultList() throws SqlException {
  // Execute stored procedure and return results
 }
}

public class SimpleQueryUser {
public static void main(String[] args) throws Exception {
 // This works fine
 new StoredProcedureCall().setOutputParameter("OUT").setParameter("name", "value").getResultList();
 // This produces compilation errors
 new StoredProcedureCall().setParameter("name", "value").setOutputParameter("OUT").getResultList();
}
}

The second oneliner produces a compilation error because Query object returned by setParameter() does not actually have setOutputParameter() method. To address this problem we can use return type covariance, which is a language feature added to Java 5. Here goes a fixed version of our StoredProcedureCall:

public class StoredProcedureCall extends PreparedSqlQuery {
 protected String outputParameter = null;
 public StoredProcedureCall setOutputParameter(String param) {
  outputParameter = param;
 }
 // Compiler allows us to use StoredProcedureCall instead of Query as the return type here because StoredProcedureCall implements Query
 public StoredProcedureCall setParameter (String name, Object value) {
  super.setParameter(name, value);
  return this;
 }
 public Collection getResultList() throws SqlException {
  // Execute stored procedure and return results
 }
}

Actually you can see exactly the same approach used in the real-world Query implementations, like OpenJPAQuery. Now what if you don't want to override all that numerous setXxx methods in all subclasses just to change their return types? Here is my solution utilizing another Java 5 language feature - Generics:

public interface Query <T extends Query >{
 T setParameter (String name, Object value);
 Collection getResultList() throws SqlException;
}

public class PreparedSqlQuery<S extends PreparedSqlQuery> implements Query<S> {
 protected Map params = new HashMap();
 public S setParameter (String name, Object value) {
  params.add(name, value);
  return (S) this;
 }
 public Collection getResultList() throws SqlException {
  // Execute query and return results
 }
 // Hide constructor, use factory to ensure users won't try to do something like: new PreparedSqlQuery<StoredProcedureCall>().setOutputParameter
}

// We make it generic too to enable further extension
public class StoredProcedureCall<R extends StoredProcedureCall> extends PreparedSqlQuery<StoredProcedureCall> {
 protected String outputParameter = null;
 public R setOutputParameter(String param) {
  outputParameter = param;
  return (R) this;
 }
 // Note we don't have to override setParameter here
 public Collection getResultList() throws SqlException {
  // Execute stored procedure and return results
 }
}

public class EntityManager {
 public static StoredProcedureCall<StoredProcedureCall> createStoredProcCall() {
  return new StoredProcedureCall<StoredProcedureCall>();
 }
 public static PreparedSqlQuery<PreparedSqlQuery> createNamedQuery() {
  return new PreparedSqlQuery<PreparedSqlQuery>();
 }
}

public class SimpleQueryUser {
 public static void main(String[] args) throws Exception {
  EntityManager.createStoredProcCall().setParameter("name", "value").setOutputParameter("OUT").getResultList();
 }
}

All that trickery with generics is done to fool the compiler. Good thing about it is that no additional methods are created, that means there are no super calls, which can potentially improve runtime performance. Bad things are obvious too:

It is not safe unless you are using factories to instantiate that builders;
It is definitely not obvious and looks ugly;

Disclaimer: this is a hack, never use it in your code :)

WebSphere + GWT + Comet

2010-01-29T15:19:00.012+02:00

IBM supports Reverse AJAX (AKA Comet) in a form of WebSphere Feature Pack for Web 2.0 for WebSphere Application Server 6.0+. It is shipped by default with the latest fix packs for WAS 6.1 and in all 7.0 versions. Actually this Feature Pack has a lot of nice Web 2.0 features, but at the moment we are interested in Web Messaging Service only.

To install and enable FP you need to follow the documentation, it won't take long. As the result you will get the ability to push data to your client's web browser by publishing it to the special JMS topics. As an alternative, you may also use a more specialized API for doing this, but the Publisher object is stored in the Servlet context, therefore it can be somewhat tricky to access it from an arbitrary part of your application, which is not true with JMS.

I assume that you have successfully installed and tested your Web Messaging, and now want to upgrade your QuoteStreamer sample application to GWT. For example, you have a widget and want its methods to be called when some data arrives from the backend.

It is possible to use JSNI to achieve exactly this goal. The idea is simple: when you need to push some object to the client (for example, out of your Message Driven Bean), you first serialize it using GWT RPC mechanism, then put the resulting string to the appropriate JMS Topic. This string is wrapped to JSON envelope, sent to the client via WFP and unwrapped there via Dojo. Your JavaScript listener should be triggered at this moment. But as we use GWT for all our JavaScript programming, we should implement that listener as JSNI snippet:

private native void initCallbackAndSubscribe (String someParam) /*-{
    if ($wnd.dojox) {
$wnd.dojox.cometd.subscribe("/test/" + someParam, this, function (comet) {
            module.@com.test.MyCoolWidget::onReverseAjax(Ljava/lang/String;)(comet.data)
        });
}
}-*/;

// This is a normal Java code
public void onReverseAjax(String msg) throws SerializationException {
    SerializationStreamReader r = ((SerializationStreamFactory) svc).createStreamReader(msg);
    Object data = r.readObject();
    // Do something with that data arrived
}

As you see, the data is deserialized later in your normal Java code called by this listener. That's it. If you have initialized everything right (in your index.jsp or some similar place), this scheme should work fine. Now I will show you how to send data using GWT RPC. It should be simple via RPC.encodeResponseForSuccess method, but there is one problem - it requires SerializationPolicy object for the security reasons. This mechanism restricts serialized objects to the limited set described in *.gwt.rpc files, generated during compilation. Another problem is that there can be several such files. I haven't found a good way to get the SerializationPolicy other than by concatenating these files altogether:

public SerializationPolicy getSerializationPolicy() throws Exception {
    String result = "";
    for (File file : new File(PATH_TO_YOUR_GENERATED_STUFF).listFiles(new FilenameFilter() {
        public boolean accept(File dir, String name) {
            return name.endsWith(".rpc");
        }
    })) {
        result += (FileUtils.readFileToString(file));
    }
    return SerializationPolicyLoader
        .loadFromStream(new ByteArrayInputStream(result
            .getBytes("UTF-8")), null);
}

public void publishObject(String topic, Object obj, Method method) throws Exception {
    String r = RPC.encodeResponseForSuccess(method, obj, getSerializationPolicy());
    publishStringViaJms(topic, r.toString());
}

I forgot to mention that RPC.encodeResponseForSuccess requires a Method instance, but it is used only to extract the return value type, so any method returning the object of the obj.getClass() type will do.

In general, there are some good things about such WebSphere + GWT + Comet integration, the major one is that it uses WFP, which is a pretty powerful Comet server, compared to some custom-built solutions. For example (at least on WAS 7.0), it uses connection multiplexing, nio and all that cool stuff you expect from the modern web server. Also, it naturally integrates into your ESB, so you can use it in your Process Server applications with ease. Some limitations are obvious too, for example it won't work in GWT Hosted Mode with Tomcat. Also it seems to me that this should be implemented somehow simpler, but I was unable to find it. So if you have any other ideas, please give me a clue.

P.S.: Actually, there are some alternatives to this approach. For example you can use gwt-comet-streamhub to enable Reverse AJAX for your GWT applications. But it provides its own Comet server called StreamHub which is definitely not a part of the IBM WebSphere product line :)

P.P.S.: The described method should work with other Comet-enabled J2EE servers like Jetty with minor modifications.

P.P.P.S.: There is left one more issue with security. As for now, it is not really clear for me how to implement role-based security for Comet... I can think of using several update servlets at the same time, and it should allow me to use webapp security. But this issue definitely needs further investigation.

WADL toolbox

2010-01-26T09:30:00.008+02:00

WADL stands for Web Application Description Language and currently is in a state of W3C Member Submission, that means at the early stage of W3C standardization process. The purpose of the "language" is similar to WSDL, with the orientation towards RESTful APIs in the first place. What is essential for me is that this language perfectly suits the task of Pomodoro Server API description. There are surprisingly few tools utilizing this format, I guess this is due to the immaturity of the language. Though I can name some of the most useful ones:

Jersey, a reference implementation of JAX-RS. It is able to generate WADL at run time based on the metadata found in your Java classes.
soapUI, a great tool for testing web services. As one of its numerous new features in version 2.5 it can utilize WADL web service description and generate sample test cases automagically. It can even do the trick in the opposite direction, i. e. infer both WADL and XSD from the existing test case structure! Unfortunately I've found some aspects of this generation somewhat ~~buggy~~ not really obvious. For example, it does not inherit template parameters for nested resources. And despite the ability to specify application-wide settings for HTTP Basic Auth, it does not get applied somehow, so it should be specified for each test case separately. Anyway, it is a great tool and I'm looking forward to see it in a bit more stable state.
WADL to HTML is an advanced XSLT stylesheet to generate documentation from your WADLs. It seems that either my WADL is all wrong (then why it conforms to the WADL Schema?), or my XSLT processors are broken (both Saxon and Xalan running on Windows and Linux), because I was unable to get any output. But they say it works for them, so I tend to think it is actually my own problem. Anyway, I've already wrote my own simple XSLTs and going to put it here in a matter of few days :)
wadl2java generates a web service client based on WADL. It uses JAXB to create the necessary representations based on XSD referred in grammars section.
REST Describe & Compile is yet another client generator. It can infer WADL from the set of supplied request URLs, and then generate client code in several languages, namely Java and Python. The tool looks promising, but as for me, the UI is not intuitive enough. Also, you have no control over code generation, so good chances are that you will have to modify your clients manually after generation. Here you can find a great deal of documentation for the tool and underlying concepts.

P. S.: You can find WADL for Pomodoro Server here. Also you can see some generated documentation in the Google Code wiki.

Some useful JSR-168 resources

2009-12-23T12:56:00.004+02:00

While trying to figure out the essentials of portlet development, I found few useful resources on this topic:

Here goes a mindmapped extract of those two:

Using Spring in server side of GWT

2009-12-17T17:43:00.003+02:00

Thanks to this post, I was able to use Spring in my GWT-RPC services. Though, I had to fix it a bit - use autowireBeanProperties instead of autowireBean (otherwise my services didn't get populated).

Relational storage using JAXB, JPA and HyperJAXB

2009-11-07T19:36:00.008+02:00

Let us imagine a situation when you are writing an application sitting on the ESB, or providing a web service enabled interface. In both cases you will probably end up having some XML Schema describing your data transfer format. Also, good chances are that you will have to have a RDBMS schema, too. Usually both are designed, implemented and documented separately. But when you write your application from scratch, you have a unique possibility to seriously reduce amount of work need to be done. Here I want to share some of my ideas how to achieve this.

Few variants are possible. You can start with DDL, generate JPA-annotated beans using Hibernate Tools for example, and then annotate it with some JAXB stuff (or use something not requiring annotations at all, like XStream). You will be able to get an XSD using some JavaBeans-to-XSD tool (like you have in IBM Rational tools when generating WSDLs for given beans), or just generate a bunch of sample XML files by marshaling some test data and use any modern XML editor to generate XSD by example. But I must warn you that the XSD will be rather ugly, because usually you don't have too much control over the whole process, that's why the proper tooling is vital for success. Nevertheless, this approach is quite common and supported by many powerful tools, such as my favorite IBM Rational Software Architect 7.5.

From the other hand, you can start with some UML and generate Java Beans, then put all the necessary annotations (both JAXB and JPA) inside. But you will have to do a double amount of work fixing the beans structure and hardcoding annotations for both technologies. Once again, you will need to fix the resulting XSD manually, that's for sure.

What I prefer to do is design the data layer entirely in XSD (which maps to Java classes in a more natural way than DDL), then generate Java beans using JAXB or something similar, enrich it with JPA annotations and generate DDL as the result. Sounds pretty nice, but there are some problems, particularly at the JPA annotations stage. The major one is that you lose flexibility in XSD changing, because after each change your beans will be generated again and you will lose all your precious annotations (yes, you can keep JPA configuration in XML, but this approach has its own drawbacks, and it's beyond the scope of this post anyway).

Fortunately there exists a tool which reduces (and in some cases can even eliminate it at all) the amount of the manual work at the JPA stage. It is implemented by Aleksei Valikov and called HyperJAXB 3 (version 1 is outdated and version 2 supports Hibernate instead of pure JPA). It is more-or-less a plugin set for XJC, adding JPA annotations to JAXB-generated beans. It is distributed as an easy to use bundle containing everything (including build.xml) to start converting your XSDs to JAXB + JPA enabled Java Beans.

Here comes the concepts of relationships and keys. The problem is, when not specified explicitly, HyperJAXB creates an autogenerated integer ID for every entity, which is not always what you really want to get. Let me explain. I want to automate not only the data schema creation, but also the API to access data. For example, when there comes an XML from the client, I don't want to check if the same piece of data is already present in my DB (in fact it can be a hell lot of work to do, especially when some complex, deeply nested XML structures are considered). I want the intelligent middleware to merge it automatically with the existing data. But it won't happen by default, because of the autogenerated IDs, which are always issued new. So, if you will try to persist the same XML twice, it will put two copies in your DB, which is probably not what you expect to see.

To fix this behavior, you need to explicitly specify the meaningful IDs for your entities. With HyperJAXB you can specify it directly in your XSD by marking some of the entity fields with the special XSD annotation in the same way you document your schemas (For details please consult HyperJAXB documentation. Yes, you still can't use the XSD uniqueness constraints support because it's a bit too hard to parse by XJC-like tool). Same is true for the relationship options – for example, you can define one-to-many with all the possible JPA attributes, so it's quite flexible in case you need it.

So far, so good. Things start being complicated when you have compound IDs (and I think it happens really soon in the real life applications). Fortunately HyperJAXB gained support for IdClass few weeks ago. But here comes another problem of “cascading” IDs – when you have a complex primary key (in entity A) used as a foreign key in another entity (B), which at the same time is a part of its (B's) primary key. We had a brief discussion on this topic with Aleksei (BTW, I want to say THANKS! for his great instant support for HyperJAXB and related stuff), and it seems to be too hard to implement in the foreseeable future due to some limitations of XJC extension mechanisms. So, the only way out is to tweak generated beans manually. Well, I think it is something like 20% of the job, and another 80% is done automatically.

So, in the end the results are pretty sweet. You design your data structure as XML Schema (which itself can be generated based on XML samples). Then you put some metadata (mostly ID information) inside to make sure it is complete. Now you run HyperJAXB against your XSDs and fix the generated Java Beans in case you need to handle some “complex” situations. Then, using one of the tools (either Hibernate Tools or OpenJPA Mapping Tool) you get DDL in a matter of seconds. After that you are able to (un)marshal your entities in a single line of code using JAXB, and load / merge them from / to any RDBMS in a single LOC using JPA. That totally eliminates all the serialization and storage-related code, reducing complexity, improving reliability, bla-bla-bla :)

P. S.: I must warn you that there are some issues when using this approach with different JPA providers. I've tried both Hibernate and OpenJPA and they seem to be not really compatible with each other for anything but the most trivial models. It worth a separate post and I'm not going to explain it here, just to make it short: I prefer OpenJPA over Hibernate nowadays, because I find it less restricting in defining relationships and complex IDs. Also, from the tooling point of view, those are pretty close.

P. P. S.: HyperJAXB functionality is growing rapidly, so I won't be surprised to see the majority of the issues mentioned in this post addressed in the upcoming releases. I wish this project good luck and can't wait to see it gaining popularity in the JEE development community.

P. P. P. S.: Code samples and / or detailed tutorial will come later, because it is a considerable amount of work and I'm pretty busy nowadays. Though, if you have any questions regarding the aforementioned approach, please feel free to ask.

Web 3.0 Explained

2009-08-28T12:38:00.000+03:00

Very Simple RESTful Web Services in Python

2009-08-17T13:43:00.009+03:00

I was trying to find something for easy implementation of web services in any CGI language. Firstly I considered PHP. A lot of negative emotions, nothing really simple and a wasted day. Perl has some better support for the stuff, but I've chosen Python (mostly because I've got less experience in it and wanted to give it a try).

Python has a CGI-like standard called WSGI, which makes Web Services implementation much easier. But still not that easy, as I want it. So, spent a day writing my own "library", which you can find here, hosted on Google Code. Now you can write RESTful Web Services like this:

@url_pattern("/users/${username}/plans/${year}", ['GET', 'PUT'])
def get_plans (username, year, request):
   return "Inside get_plans('%s', '%s')" % (username, year)

I'm gonna use it to implement a very first version of Pomodoro Server. Some brief impressions:

Python is very easy to learn and has a lot of great metaprogramming capabilities, very similar to Ruby. Great language, it's a pleasure to code it!
Python's documentation is just awesome!
Some Web Frameworks provide the similar functionality, but it's painful to install and comes with a lot of other heavyweight features, such as MVC and ORM.
Google Code is a nice place to host your projects, though there are some limitations (for example, wiki is very basic and not compatible with anything else).

Update: I've just found a similar thing in Java, defined in JSR-311: JAX-RS - Java API for RESTful Web Services and implemented as Jersey. Just a short sample from its tutorial:

@Path("/users/{username}")
public class UserResource {
  @GET
  @Produces("text/xml")
  public String getUser(@PathParam("username") String userName) {
  }
}

Update2: found a very similar solution for Python called Bottle. Sample code:

@route('/hello/:name')
def hello_name(name):
  return 'Hello %s!' % name

run(host='localhost', port=8080)

DSL Killer Application

2009-08-05T16:57:00.000+03:00

Now I want to point at a really mind-blowing tool called JetBrains Meta Programming System. You see, some time ago to implement your own Domain-Specific Language it was necessary to develop a grammar, implement a parser (or use such tools as GNU Bison for example) which normally operates in XML SAX manner and finally do something with the results obtained. Nowadays these new tools enable you to do virtually all this stuff in kinda type-safe way. It strictly watches at all your manipulations and alerts violations.

The whole process somehow resembles XDoclet and XSLT a bit, but it's much more reliable, because of the advanced IDEA editor, which takes into account all the necessary constraints, disallowing to misprint something. Still (due to verbose syntax) logical errors at source generation stage are highly possible. Good news is that you can use the whole power of modularity in this process to reduce such risks. Maybe the most striking thing about it is that its own language to define grammar and generate artifacts is also a DSL implemented in the same environment!

You can download JetBrains MPS here for free and try a tutorial. It will take some time to get used to the tool's UI. Its strangeness is in fact that there's a pretty complex tree representation behind a text you see on the screen, and it contains a lot of meta-information displayed as special markup signs, different colors, etc. So you shouldn't think of it as of a plain old source code anymore (to see what I'm talking about, just look at XML files inside a simple test project).

There are some alternatives to this environment, namely Microsoft Visual Studio Domain-Specific Language Tools and MetaEdit+, though I haven't tried any.

P.S.: Thanks to Martin Fowler's bliki for the link - it's a really visionary source of information! Here you can also watch his video on this topic.

Code City

2009-07-14T15:26:00.001+03:00

Today I was reading a book about software metrics called "Object-Oriented Metrics in Practice" by Michele Lanza and Radu Marinescu. It's abouth things like "Design Harmony" and so on.

Some of the ideas are debatable, for example on page 46 they say:

...you cannot understand the beauty of a painting by measuring its frame or understand the depth of a poem by counting the lines...

...metrics can help to evaluate and improve designs, but those have to be meaningful metrics that are put in a context of design harmony...

But at the same time it's obvious that you won't see the beauty of the poem looking on it's grammar, syntax or verse structure (these are more-or-less analogues for software design metrics), without actually reading and understanding the sense. That's why my conclusion is that for creating a harmonious software design it's necessary (but not sufficient) for the metrics to be harmonious, too.

What I liked most of all was the concept of visualizing software projects as cities. The metaphor includes classes as buildings and packages as districts. It is implemented in a tool called CodeCity. Some results of its work can be seen on Richard Wettel's page, who actually wrote it. Here is just one of them:

Though, there are few things which I think can make it even better:

It would be great to see a color scheme based on the developers responsible for changes, for example, using svn blame (it can be useful for both "normal" and "timeline" views).
Building base should be Sqrt(NOA), not just NOA - it will look more realistic. It also should have an option to scale building height to Log(NOM).
Color scheme should be configurable - for example, it's hard to see some "outdated" buildings on the dark backgrounds.

Nevertheless, thank you very much for giving really interesting food for my mind :)

A way to stress-test GUI

2009-07-13T15:43:00.001+03:00

What to do if you need to test the performance of your client-server application, which is not on the Web? For example, some kind of Lotus Notes one. The problem is - you can't even execute several Lotus instances on a single machine, so it's quite a tricky task to simulate multiple simultaneous users.

Virtualization is what you can use in this case. There's an example of working stress testing system consisting of Citrix XenApp terminal server running 10 Lotus Notes instances (eating 50 Mb of RAM each), and a load generator running IBM Rational Performance Tester (which is just a very advanced point-and-click thing), which can safely simulate 20 - 40 concurrent users.

Major bottlenecks of this setup are:

RAM on Terminal Server (it's better to use 64 bit solution)
Network bandwidth (at least 1 Gbit Ethernet)
It takes much longer (up to 4 times) to implement and debug such test cases, compared to usual web testing scenarios

XML Appliances

2009-07-13T13:01:00.000+03:00

I was surprised to find some hardware XML processors, called XML Appliances. They can do XSLT,validation, encryption and many more. Implemented as a separate network device it can be useful in SOA.

Things we should add to our build process

2009-06-07T23:25:00.000+03:00

I want to try some of these and see what happens:

Use Sonar for tracking various metrics (it uses all well-known Open Source tools like PMD, Checkstyle, etc. and compatible with Hudson, which we already use in our projects);
Use Cirr to document public API changes (to know when something really important has changed);
Use Macker (btw, its' FAQ is really informative, thanks!) to keep dependencies between different modules under control. It first requires some modeling, after which it can break builds in case someone breaks convention;

Also, what I want to do in the nearest future is some kind of retrospective metrics analysis tool. It will consist of (maybe) set of shell scripts checking out revisions from Subversion repository, compiling code, running JDepend and others against it, applying some XSLTs to its results to combine it altogether into single big XML, putting it then into some kind of 3D storage (Revision * Metric * Module), like OLAP cube in order to analyse it. Theoretically, such tool can generate a great amount of information, and what's interesting is how useful it could actually be.

The idea was inspired by one of the reports on Software Engineering Forum 2009 (link in Russian).

TeamCity by JetBrains: yet another great CI solution

2009-06-07T22:22:00.000+03:00

After some excitement about Rational Team Concert features, here comes another one about TeamCity, by JetBrains, the same company which gave us IntelliJ IDEA and ReShaper.

So, TeamCity is an all-included solution supporting tons of really advanced features, among which there are:

Remote Run and Pre-tested commit
Build Grid (just awesome!)
Code Coverage, Inspections and Duplicates Search
Build Progress and Estimation
Notifications (of all kinds)

You can try and actually use it for free until your project is huge enough. It takes just 225 Mb to download and 3 minutes to install.

Nice short article about IBM Rational Team Concert

2009-06-05T18:10:00.000+03:00

Here it is. Seems that RTC is even better than I thought... Among cool things mentioned, there are:

Support for Agile methodology out of the box
Original approach to SCM, based on the concept of "streams" (which are essentially branches)
Advanced build system, automatically collecting all supporting artifacts, such as change sets, fixed defects, etc.
A lot of great documentation (like Getting Started with Jazz Source Control)

What I can add from my personal experience, is that the Major Huge Advantage of RTC is that you get all these features integrated altogether out of the box. Installed it today on Windows 2003 Server - it took just 15 minutes (!) to install and configure a complete team collaboration solution. It normally takes few days to configure something like Trac + Subversion + Hudson, and even longer if you'd like to replace Trac with Redmine or Bugzilla on Linux, etc.

Client JavaScript data storage

2009-06-05T12:11:00.000+03:00

Cross-browser data storage made easy using PersistJS. It supports a lot of different ways of storing data on client browser, falling back to plain old cookies, when necessary. The library itself is really minimalistic and standalone (opposed to Dojo Storage, for example). Also, it can be integrated with another lightweight runtime storage solution called "Taffy DB", which will enable almost SQL-like queries in JavaScript. Looks very nice to store some user-related info, session data, etc.

Ultimate Pomodoro?

2009-05-31T14:37:00.000+03:00

What is the major problem of using the Pomodoro Technique? I think it's a sharing one. You see, when you're "in the middle of a pomodoro", no one really cares - your team mates will go on interrupting you anyway!

So, you need to synchronize it somehow. Setting a single timer per team is a bad idea, for the obvious reasons. What I suggest to do is to invent some kind of a Pomodoro Server and track your current status there (team-wise or project-wise). Of course, the policy should be invented for all team members to check this status before interrupting another person.

Sample feature list:

Notification when required person's pomodoro has finished
Integration with your ~~corporate~~ favourite IM client as a plugin
Integration with popular issue tracking systems via plugins
Speach recognition to simplify items entry
Flexible hotkeys for all frequent actions to make things even easier
Statistics gathering to analyze and boost personal productivity

Hope to find some time to figure it out in a further detail... Frankly speaking, already tried some of the most popular open source voice recognition tools. It seems that either my microphone, or my English, or these tools, or its' settings, or alltogether are too bad to recognize anything but "one [pause] two". With 25% accuracy. Sigh...

About coding

2009-05-12T23:57:00.000+03:00

I want to separate two different kinds of coding.

First is handwriting code from scratch, which is a good old not-reusable-bad-to-support approach. It gives me a great pleasure, because I know what to expect and when I solve a Task, it's clear what I've done to complete it. I mean, it's all so clear and predictable, that nothing can spoil your pleasure of getting things done. I used to code this way somewhere about seven years ago writting C++ utils in MS Visual Studio 7.

Nowadays, things are different. I'm developing Important Enterprise Java Applications, and the ~~coding~~ development sequence looks like this:

Find an appropriate Library or Framework.
Choose the one which either the trendiest one (in this case all your further actions will be more painful), or the wider used one (of course, in this case everyone will think that you're starting to lose your grip on modern hi-tech).
Try it on some sample application (though, this stage will not give you any useful information at all).
Try to plug it to your existing application, consisting of Frameworks, Libraries and running on Servers. Configure it (that's where you start hating both XML and lazy developers who suddenly appear not being able to write any meaningful documentation at all). That's where the vast majority of time gets spent.
Fix all bugs and side effects brought by that all-new yet-another Framework. You won't be able to spot all of them fast enough of course, so this stage virtually never ends.

So, in this world the pleasure of getting things done is usually comes at step 4, when you finally manage to squeeze your brand new part into the puzzle. But that's not it - it has nothing in common with the first Predictable Big Pleasure, and this makes a huge problem for me. Somehow, programming (which is such an interesting and exciting thing in fact!) doesn't make me happy anymore - it became just a job.

And exactly that's why I'm really looking forward to start coding in Ruby, to see if it's that good, as they say.

web.xml security limitations

2009-04-07T13:57:00.000+03:00

It appears that web.xml security is kinda useless in the real world - it has few severe limitations:

This will not work at all (several wildcards):
<url-pattern>/stations/*/departure/*</url-pattern>
This will not work as expected, because only one security constraint will be checked (both constraints work separately):
<security-constraint> <display-name>Station 14 constraint</display-name> <web-resource-collection> <web-resource-name>All station 14'th resources</web-resource-name> <url-pattern>/stations/14/*</url-pattern> </web-resource-collection> <auth-constraint> <role-name>STATION_14</role-name> </auth-constraint> </security-constraint> <security-constraint> <display-name>View arrival constraint</display-name> <web-resource-collection> <web-resource-name>View arrival page</web-resource-name> <url-pattern>/stations/14/arrival/*</url-pattern> </web-resource-collection> <auth-constraint> <role-name>VIEW_ARRIVAL</role-name> </auth-constraint> </security-constraint>

Had to spend three days to figure it out :( Now I'm going to investigate Spring Security (AKA Acegi Security).

Mercurial vs Subversion

2009-03-20T15:47:00.000+02:00

Mercurial is yet another version control system. According to its' book, here are the main differences to Subversion:

Mercurial is distributed, i. e. each Mercurial client has his own complete copy of repository, including whole history. That's the main difference to Subversion, which is client-server, so other differences can be considered as side-effects of this.
Merge is much better in Mercurial, which makes it easier to use branches (always a big pain with Subversion). This is really required, because it's the main mechanism of sharing code between developers.
Performance - Mercurial is in general somewhat faster.
Space - Mercurial is more efficient when consuming disk space.
3rd-party integration - Subversion has more integration means, at least now.
Locks - Subversion provides locking mechanism, which is suitable for working with large binary files. Mercurial is not that efficient in this respect, also due to its distributed nature.
Import/Export - Mercurial is able to import and export data from Subversion, CVS, git and others. It makes it easier to migrate to.

A simple way to start with Mercurial (at least for Windows users) is to download TortoiseHg installer for Windows (all included).

Also, Bazaar should be considered as an alternative (here is a good article comparing and explaining those). Yes, Mercurial appears to be much simpler in install and more than 2 times faster than Bazaar for nearly all operations.

Complete stack of Redmine

2009-03-20T11:17:00.000+02:00

When installing Redmine (which seems to be a nice alternative to Trac), I found a site where you can download complete stacks of different open source software, like LAMP, Trac, etc. Should be very useful when one needs a basic fast installation. Versions there are more-or-less fresh (i. e. 0.10.4 for Trac and 0.8.1 for Redmine).

Trac + Subversion installation on Windows

2009-03-02T17:43:00.000+02:00

Here I'll describe a 20 minute procedure of Trac + Subversion (the latest versions) installation for 32 bit Windows (successfully tested under Windows XP and Windows 2003 Server). It's really simple and straightforward.

I assume the following directory structure (my project is called "rw"):

D:\projects
D:\projects\trac
D:\projects\trac\rw
D:\projects\repos
D:\projects\repos\rw
D:\projects\tools
D:\projects\tools\Python25
D:\projects\tools\svn-win32-1.5.5

Well, let's get started!

1. Subversion server setup

There are two ways to install SVN server. I tried both of them and both work fine, so it's up to you which one to choose.

1.1.1. Download VisualSVN server
1.1.2. Download SVN binaries (also see complete downloads list)
1.1.3. Download Python bindings for Subversion (at the same place)
1.1.4. Install VisualSVN to any location, set repositories location to d:\projects\repos (you can accept defaults for all other options)
1.1.5. Create a repository (you can use management console for this) named "rw" and check a special checkbox to create a standard folder structure (trunk, tags, etc)
1.1.5. Create a new user for accessing repository. Now you can browse it using this URL and newly created login: https://localhost:8443/svn/rw/

OR

1.2.1. Download SVN server from tigris.org (also see complete downloads list)
1.2.2. Download Python bindings for Subversion (at the same place)
1.2.3. Unzip SVN server to d:\projects\tools, optionally add its bin folder to PATH
1.2.4. Create a repository named "rw" (svnadmin create d:\projects\repos\rw) and create a standard folder structure (trunk, tags, etc) manually
1.2.5. Create a new user for accessing repository (modify D:\projects\repos\rw\conf\passwd and uncomment a line in D:\projects\repos\rw\conf\svnserve.conf). Now you can browse it using this URL and newly created login: svn://localhost/rw/
1.2.6. You can start the server like this: svnserve.exe -r d:\projects\repos -d

TODO: See how it can be tunelled through HTTPS, also see how it can be run as a service.

2. Trac setup

2.1. Download Trac for windows installer (see complete downloads section)
2.2. Download Python 2.5 installer (details here, if needed)
2.3. Download genshi installer for Python 2.5
2.4. Download setuptools (instructions available here)
2.5. Install Python, for example to d:\Python25
2.6. (Optionally) add d:\Python25 to PATH system environment variable
2.7. Install setuptools, genshi and Trac to default locations

3. Integration with Subversion (this solution is kinda ugly hack. I assume it could be achieved much easier, though I was unable to find how exactly):

3.1. Unzip svn-win32-1.5.5_py.zip to d:\Python25\Lib\site-packages
3.2. Unzip svn-win32-1.5.5.zip\svn-win32-1.5.5\bin to d:\Python25\Lib\site-packages\libsvn
3.3. copy d:\Python25\Lib\site-packages\libsvn\*.dll d:\Python25\Lib\site-packages\libsvn\*.pyd
3.4. mkdir d:\projects\trac\rw
3.5. Execute this: trac-admin d:\projects\trac\rw initenv, enter the project name and d:\projects\repos\rw when asked for Subversion repository location. Leave all other values default.
3.7. To test installation just execute this: tracd --port 8000 d:\projects\trac\rw

4. Setup authentication (see instructions)

4.1. Create a new file named trac-digest.py and fill it with code from this page
4.2. Create an administrator user (user "adm" with password "adm"): python trac-digest.py -u adm -p adm >> d:\projects\trac\rw\digest.txt
4.3. Give that user all permissions: trac-admin d:\projects\trac\rw permission add adm TRAC_ADMIN
4.4. Run this to test everything: tracd -p 80 --auth=rw,trac\rw\digest.txt,trac trac\rw

Now you should be able to see the Admin tab if you log in with "adm" / "adm" (see http://localhost/rw)

4.5. Adjust attachment limit in trac.ini:

[attachment]
max_size = 262144000

(it's 250 Mb)

5. Enable automatic ticket control via Subversion comments. See instuctions:
Download trac-post-commit-hook and trac-post-commit-hook.cmd from here and follow instructions in trac-post-commit-hook.cmd.
Place it to d:\projects\repos\rw\hooks and modify .cmd file like that:
SET TRAC_ENV=D:\projects\trac\rw

6. Update. Use Subversion authentication in Trac.
Using AccountManagerPlugin we can work with Trac users fast and easy. I'll describe the simplest and unsecure way of setting it up.

6.1. easy_install http://trac-hacks.org/svn/accountmanagerplugin/trunk
6.2. Go to Trac Admin tab and enable Account Manager Plugin and the following modules:

AccountManagerAdminPage
AccountManager
AbstractPasswordFileStore
HttpAuthStore
AccountChangeListener
AccountChangeNotificationAdminPanel
SvnServePasswordStore
AccountModule
LoginModule
RegistrationModule

(it will make your life much easier allowing not to login into that Windoze box to change some passwords).
6.3. Now you'll need to add the following line to [components] section of trac.ini (it will disable HTTP authentication):
trac.web.auth.LoginModule = disabled
6.4. Go to Accounts / Configuration (see left menu in Admin mode) and enter your passwd filename into SvnServePasswordStore box (i. e. D:\projects\repos\rw\conf\passwd)
6.5. Now you can login as adm (don't forget to add this user to your Subversion's passwd file) and add / remove Trac users via new menu items in Admin tab. The best thing about it is that now all your changes will be reflected in Subversion configuration, so this could be considered as the common place of manipulating users for your development environment.
6.6. IMPORTANT. Now you can't use --auth when starting tracd. So, my command line is simply tools\Python25\Scripts\tracd.exe -p 80 trac\rw

Now you can customize all the necessary settings, first of all authorization. Also there available a lot of useful plugins for Trac, see Trac hacks site. What I'm going to do next is install Maven proxy and Hudson continuous integration solution.

P.S. The best thing about this installation is that it can be done once and then packed into a handy (in my case 80 Mb) redistributable ZIP file and use it everywhere. The only issue in this case is that you will need to install Python anyway (because of some shared DLLs), but during installation you can choose the existing D:\projects\tools\Python25 directory and it won't override your changes.

The Pomodoro Technique

2009-02-28T14:16:00.000+02:00

Again, thanks to Henrik Kniberg's blog I've got a brief introduction to Pomodoro Technique, which is essentially a way to improve one's productivity. The PDF describing it is quite a simple one and is fun to read (for those lazy enough there exists a 5-minute guide too).

The sole idea of this technique is to split the work into fixed short time frames separated by breaks, plan it and protect it against interruptions. A set of simple yet efficient rules promises to make it work.

I was completely carried away by this paragraph, because it seems to be the thing I'm lacking most of all in my everyday work:

We can stimulate this ability to feel time in a different way by means of a series of exercises which serve to enhance consciousness of passing time among Pomodoro users. This different awareness of the passage of time seems to lead Pomodoro users to a higher level of concentration in performing the activity at hand.

BTW, the concept is thoroughly developed and there exist various tools dedicated to help using it, so it should be a fun thing to advance this technique, but I'm going to use it's simplest, hardware form. Yes, gonna try this on Monday! :)

Scrum and XP from the Trenches

2009-02-27T10:40:00.001+02:00

Just finished reading a book by Henrik Kniberg. I found it really exciting and fun to read (at least, in Russian translation). Thank you, Henrik, looking forward to read more of your books :)

Short extract follows:

XQuery for mashups?

2009-02-25T15:49:00.000+02:00

Consider this basic XQuery sample:

for $statement in document(https://www.sample.com/sample.xml)//post let $comment := $statement/comment where $statement/postedby = 'userBob' return <quotebob>{$comment}</quotebob>

Nice, isn't it?

False language

2009-02-25T15:10:00.000+02:00

I guess it's the most obfuscated programming language ever invented (and it's more-or-less useful, compared to Brainfuck for example). Meet False Language!

99 9[1-$][\$@$@$@$@\/*=[1-$$[%\1-$@]?0=[\$.' ,\]?]?]#

It's a program which prints all primes up to 100. It's so impressively smart, that inspired creation of K, F and Y programming languages, which in turn are... somewhat similar to J and Q.

Nice diagrams

2009-02-24T16:29:00.000+02:00

Take a look at Treemap diagrams:

It's like a... well, upskirts view of the tree. Really cool Javascript for automated generation of these diagrams could be found here (it's a demo).

Grid Computing made easy with GridGain

2009-02-18T18:07:00.000+02:00

I've just watched a 20 minute demo of GridGain usage for parallel computations. Looks quite impressive, at least easy due to Map-Reduce-like approach employed in a very simple form. Also it has a nice feature of transparent propagation of code changes between nodes, still it's not actually clear for me how they gonna manage changes in classpath, libraries, etc.

It seems that GridGain is not very popular (yet), at least I was unable to find a wiki article about it :) though I really sympathize its simplicity and wish them good luck.

Sun Web 2.0 tech is easy

2009-02-16T12:17:00.000+02:00

Two following links describe how to achieve famous Ruby on Rails rapid development on Java platform using Sun tools - Netbeans and GlassFish. Among pros there are really fast setup, high performance (due to clustering) and flexibility (mix Java and Ruby):

Developing MySQL-Backed Applications with Netbeans, JRuby-on-Rails & Glassfish (needs registration)
GlassFish Clustering In Under 10 Minutes (also high-resolution version is available - the link is right after the movie window)

Pushing data to browser

2009-02-13T15:50:00.000+02:00

What will happen if a server don't close the TCP/IP connection after web page has finished loading? Right, it will wait until timeout, which could be quite a long period of time. That means we can use it to establish long-live connections (keeping them alive via some kind of polling) to provide server-to-client data push, events, bidirectional data streams, etc.

With AJAX such things became simpler, because no IFrames nor page reloads nor applets of any kind are necessary anymore. Instead nowadays we have Comet, which is an umbrella term for all such technologies, for example:

Bayeux protocol providing publish/subscribe model
BOSH for establishing bi-directional connections between client and server

Usually these things are combined with some kind of non-blocking IO on the server side in order to save resources there. For example, there exists integration with Grizzly.

The shortest way to read a text file

2009-02-13T14:42:00.001+02:00

Check this out (in fact it retrieves complete web page):

new java.util.Scanner(url.openConnection().getInputStream()).useDelimiter("\\Z").next();

Thanks to CT Arrington's Weblog and Core Java Technologies Tech Tips magazine.

Update: one more short way, using Apache Commons IO:

FileUtils.readFileToString(file);

Some open-source Java tech for scalability

2009-02-13T13:01:00.000+02:00

Some articles I've read briefly and don't want to forget:

JXTA is a P2P framework for Java (here is a very nice 171 page guide about it)
Scale-up vs scale-out study by IBM (PDF): horizontal scaling wins
Compass - ORM-like Lucene wrapper. Seems it's extremely scalable

Nice IBM advertisement from 1975

2009-02-12T15:10:00.001+02:00

That's not about James Bond. The rest of slides here.

Software transactional memory

2009-02-12T13:07:00.000+02:00

I've never heard about such thing as STM, which is quite an interesting concurrency control concept, an alternative to more commonly used lock-based synchronization. It's usage could be found in Clojure programming language running under JVM, which I think makes both of these worth trying.

Though, it can't replace locking completely, well... because in fact it provides no locking :) So, some inconsistent states are still possible, therefore transaction locking should be used, which returns us back to Earth.

Tools for XSD-LDM-DDL roundrip development

2009-02-11T15:12:00.000+02:00

There are some articles suggesting to use Rational Data Architect for XSD-DDL-LDM roundtrip development. It doesn't work. None of four RDA 7.0.0.5 installations I found in my department is able to import XSD into LDM, as this article suggests. It shows all the necessary dialog boxes, but in the end it does nothing. Just sielently does nothing.

Ok, maybe my schema is all wrong (maybe because it was not created by Business Modeler), still it's very simple and I see no reason why it shouldn't work. Also, it doesn't permit to transform LDM to Physical Data Model, so no DDL generation too... Ok, I guess it should work, but only after reading some Redbook about it.

I decided to give a short try to other ER modeling tools. PowerDesigner allowed me to easily create an LDM (it's called "Conceptual Data Model" there) and transform it to Physical Data Model AKA DDL in few clicks. Altova XML Spy was able to move between XML Schema and DDL seamlessly...

Both tools also provide a lot of useful additional functionality, which I'm going to explore and describe a bit later.

Trends

2009-02-06T17:40:00.000+02:00

I asked Google Trends for the following stuff, and it gives some rather interesting results:

grid computing, soa, cloud computing
mainframe
java, c#
c++, c#, java
j2ee, microsoft .net
ruby, groovy
ruby on rails, grails
google
amazon
netbook, notebook
yahoo
scala, groovy
neural networks, artificial intelligence
wiki, blog
crisis, sex
hardware, software
netweaver, websphere
abap, sap
abap, netweaver
websphere, weblogic
ibm, oracle, microsoft
open source

Try yourself! :)

IBM Rational products I didn't know about

2009-02-06T16:01:00.000+02:00

Finally I managed to find some time and go through the complete list of IBM Rational products. Here is a list of tools I found interesting and new to me:

Rational Host Integration Solution. It looks like an advanced screen-scrambler for existing [ugly] mainframe user interfaces, powered by Rational Host Access Transformation Services. They say it's done "without changing the existing applications". Kinda telnet2ws.
Rational Software Analyzer. This static software analyzer looks promising, it supports C++, Java and something else. What I'm interested in is 500+ code review rules for Java. I tried to run it against one of our projects, and it produces some quite impressive results. I mean, something I wouldn't notice in an everyday life. The major drawback is that the installation is >600 Mb, which is just too much for such a simple thing (I would prefer to have it just as a downloadable plugin for my RSA). Furthermore, Rational Software Architect which I use as a main tool already have limited support for such analysis (providing just 200+ rules).
Rational Business Developer. After reading this: "EGL (Enterprise Generation Language) compliments the breadth and depth of Java and COBOL technology with a simplified, more abstract development paradigm", I imagined an EGL editor with a radiobutton allowing to choose one of these: "Generate COBOL code", "Generate Java code". No COBOL please. Also they compare it with .NET for a task of retreiving data from IBM mainframe (!). In the end they claim something like "yep, we knew it would happen. Dotnet sucks, it doesn't work with mainframes". In fact, that PDF is the most exciting thing about RBD, and reading it somehow resembles watching Belarussian political news on government TV channel (that's exaclty the situation when one look is worth a hundered words).

Wheeew! To be continued.

JSF in RAD links

2009-02-06T13:11:00.000+02:00

Here are just few good links found about how to easily implement JSF in Rational Application Developer. Haven't managed to read it yet, so posting it here just in order not to lose it:

Habits and motivation

2009-02-05T12:30:00.001+02:00

Recently I've read a short post by Chad Fowler about development of good habits in 20 days. In short, he says that it's easy to make yourself do something just for 20 days and at the same time that's usually enough for this activity to become a habit. I like his idea (it's so simple!) and already started gathering some good habits, mostly in the household area. Let's see and wait until March :)

Also I've looked through a Paul Gram's blog, which I frankly speaking dislike because of it's well, straightforwardness. He's an over-positive, super-optimistic, completely American businessman saying some quite obvious things trying to find some deep sense inside. Anyway, I found an interesting idea there too. Let me quote it:

If you start a new year off with massive success in the first month, it’s amazing how fast it can snowball and help propel you to your best year EVER.

I think that's a fresh idea and it's not too late to start something like that in mid-February :)

Tricky

2009-02-04T13:47:00.000+02:00

I'm really intrigued by OSGi stuff. No, really, I can't understand what does it mean. They call it "technology" and "framework", but these words are so generic that it doesn't mean anything to me... I gave up and searched in Russian, and it didn't help either! It's very, very interesting.

UPD: Finally found an easy tutorial on it. They could have told "it's a megasophisticated way of using pluging" instead of "framework" :)

Simplifying JDBC in DSL fashion

2009-02-03T14:11:00.001+02:00

I like these libs, which are way simpler to understand and learn (at least, for simple queries) and much more lightweight than full-blown ORM tools like Hibernate:

JaQu, though I can't figure out if it could be downloaded without H2
LIQUidFORM, which does its best to look like LINQ
And some other LINQ-inspired implementations for Java

To understand what I'm talking about, consider this simple example replacing all that verbose JDBC stuff:

Product p = new Product();
List soldOutProducts =
db.from(p).where(p.unitsInStock).is(0).select();

And yes, I wish you good luck, because I'm afraid, some cool features (closures, etc) which can improve DSL implementation in Java won't be included in JSE 7. That's why I'm looking at Groovy with increasing interest and can't wait to see good IDE support for it.

Update: they actually will include closures in JSE 7! Not looking at Groovy anymore :)

Functional Programming in Architecture

2009-02-02T16:12:00.000+02:00

While reading an article about Functional Programming (it's in Russian), I've caught myself that RESTful web service is a kind of Pure Function, so REST is kinda FP approach :)

BDD is too repetitive?

2009-02-02T12:55:00.000+02:00

I've got acquainted with Behavior-driven testing, though it still looks too verbose for me. The aforementioned article doesn't give the JBehave annotation "syntax" examples, which I don't like so much.

UPD: Thinking of our poor testers who were unable to document their functional tests, start suspecting that this is what they might have needed instead of using IBM Rational Functional Tester...

Cool Groovy feature 2

2009-01-29T12:38:00.000+02:00

I can't stop surprising by all that cool language features Groovy provides. I like learning them by example. This time it is calling methods asynchronously in Groovy, part two - using Categories. This is not that easy to implement (though it's easy enough) compared to methodMissing approach, however it lacks all that disadvantages of overriding handlers.

Briefly, it uses closures, and functionality provided by use keyword. I guess it could be improved to make the whole thing less verbose, but right now I have no time to think about it. Tried to do something similar in Java using AspectJ, but stuck due to Java syntax limitations due to absence of closures. Using anonymous classes here and there looks ugly and is not less verbose nor easier to understand than straightforward approach.

I wonder if some kind of closures can be implemented in Java using aspects. Haven't found the solution yet.

Some business rules resources

2009-01-27T17:55:00.000+02:00

In the recent project we used Hirix XRules business rules engine (you would barely find any information on it anywhere, because it's an IBM internal tool), which appeared to be buggy and slow in our web environment. So, we switched to native Groovy code then and implemented all our rules (supported by more than 700 pages of very brief documentation) and underlying rules engine. I've spent about three months optimizing and polishing it, and in the end it has a very good performance, outperforming the initial solution by more than 100 times.

Why haven't we used some off-the-shelf product instead? Well, mostly because we lacked information, were limited in time and virtually all other resources. So now when I have time to investigate (the project is over), I found some neat stuff about it:

Rule Based Systems: Why use a rules engine
Drools features and screenshots (damn, I love these screenshots!)
Complete site about Business Rules (still under construction I guess)

So, at the first glance, it seems that the vast majority of current BR tools have absolutely ugly syntax, too expensive or both. Seems I didn't manage to find the Perfect Business Rules Engine again...

Cool Groovy feature

2009-01-23T13:55:00.001+02:00

I found a smart article, where is described how to add very easy-to-use support for asynchronous execution to Groovy code by hooking into methodMissing.

HTTPUnit in DB2 stored procedure

2009-01-22T09:37:00.000+02:00

That was nightmare - running HttpUnit as a stored procedure (don't ask me why) on 8.2 was crashing db2fmp to heap dump. After two days tossing xercesImpl.jar here and there, I decided that was enough and upgraded DB2 to 9.5 Viper-2! Pretty cool XML support and a lot of other large-scale-supporting stuff, but all I need is stable interpretation of my precious stored procedure.

And guess what? It works! More or less... Xerces still unable to find something important inside HttpUnit, but at least no crashes. I guess it's because Xerces uses something internal as a classloader, that's why they have so many problems with shared libraries, etc. So, I've just put that nasty JARs here and there and everywhere (yes, that's not any kind of production system, just a learning application) and now it seems working fine. Well, I'm not sure yet, because it's quite a long-running procedure, but I will know for sure in about ten minutes.

Keeping my fingers crossed + +

UPD: Yes, it works finally. Also, I've found a nice article about HtmlUnit vs HttpUnit. Damn.

Artima Developer Spotlight Forum - Java Properties without Getters and Setters

2009-01-21T12:06:00.001+02:00

Here is described an elegant way of implementing C#-like properties in Java (1.4+) using AspectJ. Nice try, though quite a useless one in a modern reflection-based Java world... Such things make me consider learning AspectJ in a more detail.

My first entry AKA disclaimer

2009-01-21T11:56:00.000+02:00

Hello, I'm a software developer in a major Belorussian IT company, and I think that's all you need to know about me at the moment :)
Firstly, it was surprisingly easy to create that blog, thanks to blogger.com! I'm not a native English speaker (actually, I've born in ex-USSR country), so don't get confused with it please.
I think this will be mostly IT-related blog, where I'm going to collect my favorite links, articles, etc.