myThoughts.each { println it }

Moving to wordpress.com

2009-05-17T16:51:00.002-04:00

It's been a while since I posted. I've been busy. But, I'll continue to blog. I will be moving the blog to wordpress.com under kopylenko.com domain name. Will see you there.

The year 2008 is done

2008-12-31T09:35:00.005-05:00

That's it. The year 2008 has come to an end. Overall it was a very tough year - endless presidential election in the US (it felt like it), the global financial crisis, economic recession, etc. Personally, all of this didn't effect me that much (knock on the wood). Quite the opposite - it was more or less successful year for me:

Despite all of the political bullshit at work, I was able to go through it and successfully accomplish the given tasks, projects, etc.
I became a better Groovy and Grails hacker
I was able to finish and launch GrailsCrowd (which I really wanted to do)
I learned and therefore could "speak" Python, Erlang, and Scala
I started diving deep into FP (Functional Programming) via Erlang and Scala and started to appreciate its power and benefits
And last but not least, I became a better father!

My resolution for 2009 will be simple: I'd like to have a healthier lifestyle, work hard and care more for my family. Everything else will come.

Happy NEW 2009 YEAR!

Later...

Groovy script as a *nix command line utility

2008-11-26T07:54:00.005-05:00

I was having some fun with Groovy the other day as I created quick and dirty simple script to find out the duration between 2 dates. I've always wanted a handy utility that could answer more or less precisely questions like 'how much time has passed since I bought my MacBook pro?' or 'how old was I when I moved to the United States?', etc.

So, without doing much research on what's available, I set out to use an excellent Joda time library in the Groovy script setting. And after 'shebanging' it (#!/usr/bin/env groovy) and installing it for example into /usr/sbin (provided that I have Groovy installed, $GROOVY_HOME set, and joda jar available ~/.groovy/lib), it's now available as a handy CLI utility where I could use it like this (how old was I when I started working at Rutgers): 'duration oct-9-1976 dec-9-2002' and the answer is: 26 years 2 months :-)

I like Groovy's seamless integration with Java and its libraries as well as 'low ceremony' approach such as simple script without 'main method noise' requirement, implicit availability of the args array, etc.!

There could be better ways to do this, but I had fun nevertheless :-)

Here's the script:

Later...

Trying out Gist widget

2008-09-18T11:40:00.004-04:00

Ok, I've been a user of Git distributed SCM system for a few months now. The Grails Crowd lives on GitHub as an open source project. I must say I've been pretty happy so far with Git and GitHub. Few months ago GitHub guys introduced 'Gist' - a GitHub backed directory of code snippets (yes, versioned in Git repo, so all the benefits of Git apply).

Here I'm just trying out an embeddable Gist widget:

When Gist will officially release an API, I might think about integrating it with Grails Crowd.

Later...

Grails Crowd has launched

2008-08-18T17:02:00.002-04:00

After working on this project on and off for around 9 months (funny coincidence with pregnancy time frame :-) [life took precedence], I was finally able to finish and launch Grails Crowd - "the friendly online community (or directory) for Grails developers Worldwide".

I will most likely open source the code and let the community drive the innovation and the future direction of the site. I have pretty much decided that the home of the code will be GitHub :-)

Later...

Getting closer

2008-07-18T13:53:00.006-04:00

As I'm getting closer to finishing up the essential code for GrailsCrowd, I noticed that I'm doing on the fly refactorings more seamlessly than I was able to do when I first started hacking with Groovy/Grails. And Groovy Closures are my friends these days :-)

Here's a small example from the GrailsCrowd code base - 2 simple controller actions to query for Grails projects by tags, only with the difference that the first action gets all the projects within a system for a specified tag (globally) and the other one gets projects for a tag for a specific member. Both actions operate on the Tag instance, so I refactored the common functionality of querying for Tags into a method which takes a closure:


class GrailsProjectController {
 
  ...
  private def withTag(callable) {
       if (!params.selectedTag) {
           redirect(uri: '/notAllowed')
       }       
       def tag = Tag.findByName(params.selectedTag)
       callable(tag)
   }
   ...
}

And then the above mentioned actions became:


class GrailsProjectController {
 
  ...
  def findByTagGlobally = {
       def total = 0
       def projects = []
       withTag {tag ->
           if (tag) {
               total = Tagging.countByTag(tag)
               //Using CrieteriaBuilder here, so we could query by 'taggings' association
               projects = GrailsProject.createCriteria().list(params) {
                   taggings {
                       eq('tag', tag)
                   }
               } //Criteria builder
               //Sort by name since GrailsProject implements Comparable and the name property is its natural order
               projects.sort()

           } //if
       } //Closure
       render(view: 'list', model: [projects: projects, navMenu: 'discoverNavigationByTag',
               paginatingController: controllerName, paginatingAction: actionName, total: total,
               menuContext: [tag: params.selectedTag]])
   }
  
   def findByTagForMember = {
       def total = 0
       def projects = []
       def member = Member.findByName(params._name)
       withTag {tag ->
           if (tag) {
               if (!member) {
                   redirect(uri: '/notAllowed')
               }
               total = Tagging.countByTagAndMember(tag, member)
               //Using CrieteriaBuilder here, so we could query by 'taggings' association
               projects = GrailsProject.createCriteria().list(params) {
                   taggings {
                       eq('tag', tag)
                       eq('member', member)
                   }
               } //Criteria builder
               //Sort by name since GrailsProject implements Comparable and the name property is its natural order
               projects.sort()
           } //if
       } //Closure
       render(view: 'list', model: [projects: projects, navMenu: 'memberProjectsNavigationByTag',
               paginatingController: controllerName, paginatingAction: actionName, total: total,
               menuContext: [tag: params.selectedTag, member: member]])
   }
   ...
}

Also notice the use of GORM CriteriaBuilder which allowed to nicely query m:n 'Tagging' association class!

Keep Groovying.

Later...

Programming with closures

2008-06-07T07:40:00.007-04:00

Recently I caught myself thinking that my programming habits are changing while programming in Groovy. In particular, I started using closures more and more to clean up my code, make it more DRYer, e.g. by not just merely using existing closures provided by libraries such as GDK, GORM, etc., but by creating my own closures.

Here's a small example from GrailsCrowd. The idea here is to either 'accept project participation invitation' or 'reject project participation invitation'. So, in the Controller, I factored out the common code of retrieving the Member, Project, redirecting to the appropriate action afterwards, etc. to a private method which takes a closure, and calling that closure for the actual action of 'acceptance' or 'rejection':


private def withProject(callable) {
    def invitee = freshCurrentlyLoggedInMember()
    def creator = Member.findByName(params.creator)
    def project = GrailsProject.get(params.projectId)
    //Call the closure
    callable([project:project,creator:creator,invitee:invitee])
    redirect(controller: 'mailbox')
}

def acceptParticipationInvitation = {
    withProject {projectMap ->
        projectMap.project.acknowlegeParticipationAcceptance(projectMap.creator, 
        projectMap.invitee, params.messageId.toLong())
    }
}

def rejectParticipationInvitation = {
    withProject {projectMap ->
        projectMap.project.rejectParticipationInvitation(projectMap.creator, 
        projectMap.invitee, params.messageId.toLong())
    }
}

IMO, this makes code cleaner, reusable, and more maintainable. Also, this style of programming with closures kind of replaces good old Template Method design pattern.

Keep on Groovying, folks!

Later...

Spice things up

2008-05-02T08:05:00.002-04:00

I'm gonna do an unusual departure from posting work-related and technology-related stuff here.

You know that things between you and your significant other are starting to "spice up" again (the busy schedule at work for both, 16 months old at home, the daily routine, etc., cause some tension between spouses, etc) when you receive [funny] email like this from your spouse:

Dear Mr Kopylenko,

I'm writing you to inform that I will require some private time in order to complete the required documentation in order to process my Medicaid and Medicare applications , as well as some other paper work

Your full cooperation will be greatly appreciated and rewarded that same night.

Thank you in advance,

Dr Z Kopylenko

I did enjoy it :-)

Later...

Access RESTful API in 2 LOC

2008-04-15T18:05:00.003-04:00

Today I was playing with json-lib and FriendFeed API in Groovy console and was able to fetch feed's JSON representation and do a simple result filtering in 2 lines of code! So, for example, here are all my recent twitter entries (filtered from all the other content e.g. different services like flickr, amazon, etc.):


import net.sf.json.*

def friendFeedJsonResponse = new URL('http://friendfeed.com/api/feed/user/dima767').text
JSONObject.fromObject(friendFeedJsonResponse).entries.
  findAll { it.service.id == 'twitter' }.
      each { println it.title }

I know it is a very simple example, but IMO, with an 'expressiveness' and 'compactness' of Groovy, in the majority of cases, there is no need for a 'wrapper' library and various web APIs could be used 'as is'

Later...

Grails in a 'Cloud'

2008-04-10T06:02:00.005-04:00

These days, the new generation of computing, so called 'cloud computing', where the infrastructure of the entire data centers is outsourced, abstracted, and hosted somewhere in the 'cloud' (on the Internet), is getting hugely popular. In a nutshell, it provides a so called 'low barrier to entry' for smaller internet companies to make their presence on the Internet market place without spending a fortune and ridiculous amount of time and energy buying their own hardware and maintaining their own data centers.

Amazon EC2 service hugely popularized this type of computing and early this week, Google jumped on the bandwagon with their App Engine exposing the power of their computing infrastructure, as well as the entire web development stack (Python-based - what else did you expect from Google) :-) to the army of ordinary, but creative software development minds.

After the announcement, Google has received feedback from developers requesting support for different programming languages/frameworks, and among Perl and Ruby, the requests for Java/Groovy/Grails are overwhelming.

Now that we have a rock-solid RAD web framework for Java (Grails that is), we are just missing the last piece of the puzzle: a rock-solid and affordable Grails hosting in a 'cloud'. The demand seems to be there. Hint, hint for ambitious start up companies :-)

Later...

So enjoyable

2008-04-04T16:25:00.005-04:00

While hacking GrailsCrowd today, I caught myself thinking that programming in Groovy is such an enjoyable experience (for me). Take this method for example:


// Social feature: gets a list of 'colleagues' working on the same projects as *this* member
   def getProjectColleagues() {
       getActiveProjects().collect
           {it.participants}.flatten().findAll
               {it.participant.id != this.id}.collect {it.participant}
   }

Is it possible to navigate "deep" object graph and express the same intent with the similar compactness in 'raw' Java code? I think not :-)

Later...

Simple "Feedback" service

2008-03-16T11:28:00.002-04:00

At our organization, I keep observing a recurring struggle to gather requirements and design public facing products. I mean, for example, when development teams are tasked to design systems that are targeted for students, all the requirements come from deans (supposedly 'product managers') without any kind of usability study and feedback from real users e.g. students. Also, the growing amount of 'phantom use cases' is being pushed into public facing products by our internal IT management without any real analysis of what the actual users would want and how they would actually use the system in question (or so it seems to me).

I was just discussing with my colleagues the fact that it would really be beneficial to gather feedback about systems from our student users, analyze it and then derive use cases from it for future product developments. IMO, that would really be more useful than simply coming up with those 'phantom requirements' ourselves.

To realize that, I'm thinking of creating a simple generic "Feedback" web application/service that would contain a 'rating', 'feedback/suggestions/comments' that users can submit. This should be a generic service that could gather feedback/reviews/ratings from students and/or internal corporate users for any systems, etc. (think Amazon reviews). And once we have all the data, we would be able to do all kinds of "collective intelligence' (data mining) analysis with it which would hopefully help us improve our products and make our product development more 'user-centric' instead of 'corporate-centric'.

I'm planning using Grails for the first prototype.

Later...

Hidden gem: grails.war.resources

2008-02-12T13:06:00.000-05:00

In the process of packaging up the Grails application as a WAR in preparation for deployment to Tomcat, I needed to figure out a way to exclude the Oracle JDBC drver from WEB-INF/lib (we use 'shared' Oracle driver for our web apps which gets loaded by the Catalina's common ClassLoader). So I was thinking of a way to provide an "event hook" script, and while reading Grails' War.groovy I found a "hidden gem". That is a closure which is defined in the application's Config.groovy. So when this closure is defined, the War.groovy calls it with "staging directory" as a parameter and sets Ant as its 'delegate' right before zipping it up as a war.

So I was able to do the following (... from Config.groovy):


//Closure to customize the packaging of a war. In particular it excludes the Oracle JDBC driver
//from the war as it is loaded by the Catalina common ClassLoader when deployed to Tomcat
grails.war.resources = {stagingDir ->
 delete(file: "$stagingDir/WEB-INF/lib/ojdbc14-10.2.jar")
}

This is real nice, but I don't think this feature is documented anywhere.

Later...

Script event hooks are cool

2008-02-11T15:04:00.000-05:00

Grails has had the so called 'event hooks' for Gant scripts since 0.5. It basically is a way to tap into the Grails Gant scripts execution flow to customize build process, etc. It is elegantly implemented (as everything else in Grails) as a collection of closures in the Events.groovy script. The 'event closures' get called by Grails when the corresponding 'events' get generated in the Gant script e.g. a method 'event' is called with the event name as a parameter. So for example, event("StatusUpdate", [ "Status update event is called"]) would result in eventStatusUpdate { msg -> } closure defined in Events.groovy being called.

So, at work, for the typical Spring web applications we use Ant-based "common build" system originally created by the Spring guys. The common build uses ivy for the dependency resolution, so we have a custom ivyconf.xml which contains definitions for our local dependency repository, etc.

Grails has an ivy plugin, but when installing it for each web app, it puts the default ivyconf.xml into the root of the web app. So, I needed a way to 'tap' into the _Install.groovy script of the plugin to copy our local invyconf.xml. Sure enough the script 'statusUpdate' hook did the trick.

Here is the Events.groovy:


static final ESS_IVYCONF_FILE_LOCATION = "$userHome/.common-build/ntg/common-build"

eventStatusUpdate = { msg ->
   if(msg ==~ /.*ivyconf.xml.*/) {
       println "Copying ESS ivyconf.xml from common-build global directory ..."
       Ant.copy(todir: "${basedir}", overwrite: true) {
           fileset(dir: "$ESS_IVYCONF_FILE_LOCATION") {
               include(name: "ivyconf.xml")
           }
       }
   }
}

Later...

Plugins for local needs

2008-02-11T07:43:00.000-05:00

The Grails plugin system is great not only for creating all kinds of useful functionality available publicly, but also is a perfect framework to extract bits and pieces of reusable logic suitable only for internal corporate projects.

At our organization we started finally using Grails for internal projects. The first small web application was done in a matter of a few days. But then when it was time to package it up as a 'war', we had a little dilemma and that's where Grails plugin system came to the rescue.

In a nutshell, we use Spring Security (formerly known as ACEGI) together with JA-SIG Central Authentication Service, for all our auth/authz needs. For Grails applications, I did not choose Grails Acegi plugin as it does not seem to provide CAS authentication support (yet?). So we reverted back to good 'ol Spring resources.xml and dropped all the verbose Acegi bean definitions there (hopefully Spring Security 2 should reduce the 'configuration chaos' dramatically). Works just fine. But we have 3 "String" bean definitions there pertaining to CAS properties, such as 'casServiceUrlPrefix', 'casLoginUrl', and 'casValidateUrl'. So, for the typical Spring web app., we define those as JNDI-bound resources, like so:


<bean id="casServiceUrlPrefix" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName"><value>java:comp/env/casServiceUrlPrefix</value></property>
</bean>

<bean id="casLoginUrl" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName"><value>java:comp/env/casLoginUrl</value></property>
</bean>

<bean id="casValidateUrl" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName"><value>java:comp/env/casValidateUrl</value></property>
</bean>

So, when packaging application as a 'war' and deploying it to Tomcat, this is fine, but in the 'development' mode, in embedded Jetty, I would have liked to put this config somewhere else. Like conf/Config.groovy for example. That's where Grails plugin system came in, and with its wonderful SpringBeanBuilder I was able easily dynamically create those 3 bean definitions during assembly phase of the ApplicationContext, depending on the environment the application was running in.

Here's the plugin:


import grails.util.GrailsUtil as GU
import org.springframework.jndi.JndiObjectFactoryBean

class CasPropertiesResolverGrailsPlugin {
 def version = 0.1
 def author = "Dmitriy Kopylenko"
 def title = "This plugin is used to provide cas related properties to the Spring beans used for Spring Security config"
 def description = ''' The plugin participates in the creation phase of the Spring application context
                       which is used to configure Spring Security related beans and dynamically provides
                       'configuration beans' namely 'casServiceUrlPrefix', 'casLoginUrl', and 'casValidateUrl'
                       depending on the environment in which Grails application is preparing to run.

                       More specifically, if the environment is 'development' then the value is sourced from
                       Grails Config instance. On the other hand, if the environment is 'production', the value
                       is sourced from standard ess JNDI namespace.
                    '''

 def dependsOn = [:]

 def doWithSpring = {
     switch (GU.environment) {
         case 'development':
             casServiceUrlPrefix(java.lang.String, application.config.casServiceUrlPrefix)
             casLoginUrl(java.lang.String, application.config.casLoginUrl)
             casValidateUrl(java.lang.String, application.config.casValidateUrl)
             break
         case 'production':
             casServiceUrlPrefix(JndiObjectFactoryBean) {
                 jndiName = 'java:comp/env/casServiceUrlPrefix'
             }
             casLoginUrl(JndiObjectFactoryBean) {
                 jndiName = 'java:comp/env/casLoginUrl'
             }
             casValidateUrl(JndiObjectFactoryBean) {
                 jndiName = 'java:comp/env/casValidateUrl'
             }
             break
     }
 }
...

I'm sure there are other ways to do this, but that was fun nevertheless :-)

Later...

Grails 1.0 is golden!

2008-02-05T11:01:00.000-05:00

Yes, after more than 2 years in the making, with the development team hard at work, the Grails 1.0 final has been officially released. IMO, this event is historical and a great milestone for "lightweight" web development on the JVM platform.

Happy Grails hacking!

Later...

A year of blogging

2008-02-01T09:46:00.000-05:00

Just a small milestone for me: a year of blogging. It hasn't been that bad, and I really enjoyed it. I will certainly continue to do so.

Later...

Inspektr: open source audit trail and logging aspects for Java

2008-01-08T06:39:00.000-05:00

After creating a lightweight audit trail and log capturing (for example to capture and log Exceptions in the structured way) "common" library for my organization, we've (2 of my colleagues) reviewed it, cleaned it up, added the statistics capturing module, and released it as an open source under Apache license.

At its core, the library makes use of Spring's @AspectJ POJO-style aspects together with Java Annotations.

Check it out, it's called Inspektr, and it's available here

Later...

The Web has won... through open source

2008-01-08T06:32:00.000-05:00

Some good and true observations in this post :

In other words, open source lets enterprises focus on delivering customer value, rather than on the "overhead" of software (licenses, contract negotiations, closed APIs, etc.). "Old school" enterprises get this. "New school" web properties do, too. In fact, just about everyone is getting on board...except 20th-century software companies.

Later...

2008 resolution

2007-12-27T13:35:00.000-05:00

Since it is 'fashionable' to have 'New Year resolutions', here goes mine. Not for the 'publicity', as no one should really care, but just for myself and for my personal record.

So, in 2008, I would like to not judge anyone for anything. Do what I do best at work, try to help others achieve the level of experience and professionalism. And also, not to bother myself with all the intra-office political bullshit and think and care more about my loved ones, not "pointy-headed' bosses with 'tunnel vision'.

Here you have it... Happy New 2008 YEAR!

Later...

Fetch random GORM model

2007-12-15T06:38:00.000-05:00

Despite busy schedule at work and a year old daughter at home, who now requires constant attention, I was able to get some time to work on the Grails community site (Grails Crowd).

As a part of it, I wanted to have a feature to display a 'random' user (a 'member') In fact, keep displaying a random user as long as 'Discover users' link is being clicked. You know, kind of like Flickr's "Explore" feature. So with a help of standard JDK library features i.e. 'java.utils.Collections.shuffle()' and Groovy closures, here's what I've come up with:

MemberController's action:


...

def findRandom = {
        def member = null

        withMemberIds { memberIds ->
            //Pick the last one
            member = Member.get(memberIds[-1])
            //Then remove it from the list
            memberIds.pop()
        }

        if(member) {
            render(view: 'discover', model: [member: member])
        }
        else {
            //No one is registered yet - just 'go home'
            redirect(uri:'/')
        }
    }

    private def withMemberIds(closure) {
        def memberIds = session.memberIds
        if (!memberIds) {
            memberIds = Member.withCriteria {
                projections {
                    property('id')
                }
            }
            if (!memberIds.isEmpty()) {
                //Some members are in the database:
                //Shuffle 'em up
                Collections.shuffle(memberIds)
                session.memberIds = memberIds
            }
            else {
                //No members are in the database
                return
            }
        }
        closure(memberIds)
        if (memberIds.isEmpty()) {
            session.memberIds == null
        }
    }

...

It works like a charm.

Later...

"Agile" labs environment

2007-12-09T16:51:00.000-05:00

I was asked by our management to lead the innovative software research of new technologies at our organization. I'm all for it. But personally I think what would be the first step in this undertaking is to have a little bit of freedom for our engineering team. By that I mean it would be great if our management supported and approved to have a some sort of a "labs" environment, consisting of a say Linux box with full root given to the engineering team, so the full freedom of experimentation could be achieved without the usual hurdles and roadblocks of a day-to-day operational and engineering teams interaction.

If that somehow happens, I would have a hope :-)

Later...

Why Grails is so 'close to home'

2007-12-07T09:22:00.001-05:00

Here's another [big] reason why Grails is not a "foreign" technology for Java developers. I know, it's been said before, but this is a real world example of a Java person coming to Grails and experiencing this familiar state of things: 1) Create war; 2) Drop into any of the available Java Servlet container/app server 3) Sit back and relax (in the ideal world) :-)

I'm not sure if the same is true for JRuby (On Rails), so I'm not going to speculate here ;-)

Later...

Web 2.0 "bubble" video

2007-12-05T20:07:00.001-05:00

Here is a great "web 2.0 bubble" video!

Gravl - a full-featured Grails-based blogging software

2007-11-28T13:16:00.000-05:00

Glen Smith, the man who created groovyblogs.org in around 20 hours, is doing it again. This time around, Glen is planning to create a full-featured blogging software and use all the latest "bells and whistles" of Grails like flexible UrlMappings, different plug-ins, tag libs, custom filters, Ajax integration, etc.

The main motivation is to have it as a learning tool, demonstrating how to implement great web 2.0 (yes, I said it) :-) style of software in Grails.

And the ambitious plan of Glen's is to have all of that implemented in around 1000 LOC (excluding GSPs, JavaScript, CSS)!

Way to go, Glen! And I'll be waiting for Gravl.

Later...

Flight Level 'three niner zero'

2007-11-26T18:35:00.000-05:00

If you are fascinated with commercial aviation, like I am, here is an excellent blog of the senior captain of the major US airline (Airbus A320 family of aircraft). When I read it, it really feels like I'm right there on the flight deck, flying with him! :-)

Later...

Rails vs [___]...

2007-11-23T23:19:00.000-05:00

There is a series of Apple vs PC commercial parodies called Rails vs [PHP, Cold Fusion, Java, .NET, etc.] from railsenvy folks. There is a funny one about Rails vs Django :-)

I wonder, what Rails vs Grails would look like...?

Later...

Dude, where's my plug-in?

2007-11-10T11:38:00.000-05:00

These are exciting times for Grails community. 1.0 RC1 is out in the wild and 1.0 final is well on its way to the big and long awaited release.

As Grails core team is hard at work shaping up Grails core to be ready for the big 1.0, the Grails plug-in community has exploded with all kinds of useful plug-ins ranging from Rich clients to Security, performance and utility functionality, augmenting the core feature set of Grails.

For example, the two recent plug-ins that guys at Cantina consulting have provided are Amazon S3 and Video

It's definitely a great time to be a "Grails hacker".

Later...

Fun with tags

2007-10-09T10:05:00.000-04:00

I've been playing with groovyconsole the other day to experiment with some 'tag' (yes, the web2.0 tags) :-) manipulations, etc. Let's say I wanted to build the del.icio.us style 'for:username' tag trickery, to send a message, save bookmark, etc. to any particular user's 'private inbox', etc. Extremely easy with Groovy:


tags = ['tag1', 'tag2','for:dima','tag4','for:someoneelse']

usersWhoShouldRecieveSomething = tags.findAll { it[0..3] == 'for:'}.collect { it - 'for:' }

assert usersWhoShouldRecieveSomething == ['dima','someoneelse']

Later...

Grailscrowd: open invitation

2007-09-09T12:08:00.000-04:00

I've mentioned this idea before. I think it would be a great idea to design and develop a Grails community site similar to WorkingWithRails , which I think is great. So, whoever is interested in joining grailscrowd.com project (will be built with Grails, of course), you are more than welcome to contact me.

Later...

Grails is gaining velocity

2007-09-02T10:11:00.000-04:00

Now that Grails 0.6 is out with a development speed improvements and bunch of new and exciting features i.e. a DSL for Spring Web Flow, Joint Java/Groovy compiler, better REST support, etc., and the focus of the Grails team is now shifted towards getting 1.0 out of the door, it's time again for me to allocate some time for some serious hacking of the Grails "side projects"

My tiny "web 2.0" project I mentioned about several times in the past, is kind of on hold now, pending the web UI design phase, which is going very slowly at the moment.

I hope to pick up the speed on the development of the Grails Camelot again.

And I am also seriously thinking of creating a networking site for the Grails community with developer's profiles, sites built with Grails, Grails projects, etc. i.e. grailscrowd.com. If anyone is interested in this idea, just let me know :-)

So many things to do, so little time (plus I have a 8.5 months old daughter who needs constant attention at this stage of her life) :-)

Later...

Groovy to the rescue

2007-09-02T09:47:00.000-04:00

Last week, out of the blue, I was tasked with coming up with an automation of integration of two systems. I was given a week to complete it and bunch of words like "...this is an emergency project", "it needs to be done ASAP", "this is coming from the higher management and this is very important for us", etc., the usual corporate B.S.

I was so tired of "fighting" this corporate politics nonsense, so I just got right to it.

The problem turned out to be quite simple. I needed to automate the daily feed of the photos (jpg files) of the students that our main photo department takes, from their "photo server" (NT, MS SQL Server to keep student's records) to our main class rosters and grading web based system (Spring web app deployed on Solaris).

I didn't think twice and chose Groovy to do the job. The simple script does query the SQL Server, iterates over the result set, renames the jpeg files (according to the naming scheme required by rosters app) and SFTPes them to the Solaris box.

Using GroovySQL and AntBuilder, it turned out to be a very elegant, expressive and tiny solution. It was done in a couple of days and the script is now doing its job in production!

Conclusion: I love Groovy! :-)

Later...

The adoption of JPA

2007-08-16T10:21:00.000-04:00

I've been meaning to start introducing JPA for the persistence layer of our web applications for a long time, but there was never a "right time". That is, in our organization, every project is "an immediate need", needs to be delivered ASAP, and it always feels like we're in some kind of a "panic mode". So introducing the "new piece" of technology stack to our developers in the middle of projects with high deadline pressures did not feel feasible to me. Plus the relationship with our DBAs and the state of our databases (highly de-normalized "legacy" and even new tables, for the reasons unknown to me, etc.) kind of leaves bad taste in the mouth. But that's all internal corporate politics that I have no control over.

So, the last week a new such an immediate project came in and I decided to review it. It is a very simple CRUD application to maintain records of "emergency contact" for our students (and later for faculty/staff). It's a simple 1 web form backed by one de-normalized table. One of our developers assigned to this project started hacking (it is a typical Spring MVC app) with a Repository implemented as Spring JDBC (raw SQL - Oracle MERGE statement). It would be OK to leave it as it is, but I decided to "bite a bullet" and do the JPA implementation.

Thankfully, the JPA spec authors took care of the poor souls like us who have to deal with "legacy DB schemas" and equipped with @Embeddable, @AttributeOverride tools I was able to map this denormilized table structure into our simple model. This eliminated a lot of LOC of manual SQL craft code and manual mapping of result set into the JavaBeans. The solution turned out to be very elegant with only few lines of code! My colleague, who is the assigned developer on the project, really appreciated it.

Furthermore, with this JPA persistence model, we now could easily rewrite the front end in Grails and totally re-use it! That is my other plan - start introducing Grails to our organization, once 1.0 is out.

Later...

Need a web designer

2007-07-26T23:39:00.001-04:00

As I mentioned previously, I was doing my little side Grails based web 2.0 fun project on and off (time permitting). I've reached the point where the very basic set of essential features are implemented and I need to "dress it up" nicely. I was hoping that our web guru at work would be able to take care of that for me, but it didn't work out. So now, I'm looking for someone with great web design skills to transform the "beast" into the "beauty". I really like the layout and look and feel of flickr and want something similar.

Again, my little web app is not intended to be a "next big thing", but I really want to finish it and deploy it in "wild".

So, are there any web designers out there willing to help/participate? :-)

Later...

My web 2.0 application progress report

2007-07-09T16:23:00.000-04:00

Just wanted to say that even though I do not have a lot of time to spend working on my little web 2.0 Grails based site, I've made quite a good progress with it. I must say that even though I have tons of ideas for new features as I go along with it, I need to draw a line and scope out the feature set for the initial release. Also I'm building it on the development SVN snapshots versions of Grails, so in this respect the ride is a little rougher, but I personally like to "live on the edge" :-)

I'm almost at the point where I need to turn it over to a web designer for the best layout/UI possible (I just want it to look beautiful, as the site itself might not serve a great purpose other than be a nice looking "social time waster") I will speak to our Web designer guru at work to see if he could help me out, but if that doesn't happen, I'd be willing to seek help from "outside".

I have some other plans e.g. build some cool web apps with Grails i.e. work on Grails Camelot , build a social web app for the Grails development community (grailscrowd.com) similar to the one for the Rails community, etc.

If anyone else is interested in building something cool with Grails, just let me know :-)

Later...

Grails Camelot - the open source project

2007-06-09T10:08:00.000-04:00

After a good discussion on the Grails users list, the exciting Grails-based open source project was born. The vision is to have a web 2.0 style application for community generated software ideas. I hope that a great development team would form around this project and it would become a successful Grails "show case" application.

Later...

RESTful web services - the book

2007-05-28T12:14:00.000-04:00

Few days ago I've received a copy of the RESTful web services book. As far as I understand, this is the very first comprehensive text on the subject matter. Since REST seems to be the "hot" topic these days, the book immediately drew my attention. I bought it, so I could learn in-depth about this topic.

I just started reading it and all I could say that the book is excellent (IMO). Authors give "no bullshit" explanations about the "architecture of the world wide web", what are the advantages of using simple, yet powerful and ubiquitous architecture of HTTP to deliver lightweight services. They also define some architectural patterns (they call it ROA for Resource Oriented Architecture), show the comparison between "The big web services" (WS-*) and give plenty of examples (in Ruby, which is actually fine with me, since Ruby is a very easy to read and understand language). The examples include real world RESTful services from Amazon (S3 storage service), the various incarnations of the Atom Publishing Protocol, Google Maps, and del.icio.us.

I like the foreword by DHH:

"A renaissance of HTTP appreciation is building and, under the banner of REST, shows a credible alternative to what the merchants of complexity are trying to ram down everyone's throats; a simple set of principles that every day developers can use to connect applications in a style native to the Web... Every developer working with the Web needs to read this book"

As I learn more about RESTful principles, I start to appreciate it more and more and favor it over the "Big web services".

Later...

Could it be any easier?

2007-05-20T09:37:00.000-04:00

Well here I am again, on the second week of development of my Grails based 'addictive time waster' web2.0 site (I'm not rushing and spend may be an hour a day on it). As I described in the previous post, I was having a blast with Grails custom codecs feature which enables adding various 'encoding/transformation' features to any arbitrary Java types with ease! Well, I'm continuing "abusing" custom codecs with a great level of success and most importantly with a lot of fun.

As I noticed on almost all of those user generated content web2.0 style sites, there are some kind of a 'Submitted by: user234 x days ago type of a piece of info. So, I've decided to add 'time ago' type of a stat to my web app. I'll continue to show the 'Submission' class for the examples, representing user's submission of any kind. So in order to track when Submissions are created, I've added a 'createdOn' property:


class Submission {

 ...
 Date createdOn = new Date()
 ...
}

That will take care of recording the date of submission. Now, when retrieving and showing the the submissions, there would need to be some kind of a calculation to show the 'x minutes/hours/days/weeks/months/years ago' info. So, I've decided to "abuse" the codecs feature and "attach" the "encoding" of the date type into the 'time ago' string to the java.util.Date type. Thanks to the "richness" of the Joda time library, I was able to do that easily and put the code into the custom codec:


import org.joda.time.*

class TimeAgoStringCodec { 

 static encode = { date ->
  def start = new DateTime(date)
  def end = new DateTime(new Date())
  def ago = Minutes.minutesBetween(start, end).getMinutes()
  if(ago == 0) {
      return 'less then 1 minute ago'
  }
  else if(ago < 60) {
       return "$ago minute" + (ago > 1 ? "s ago" : " ago")
  }

  ago = Hours.hoursBetween(start, end).getHours()
  if(ago < 24) {
      return "$ago hour" + (ago > 1 ? "s ago" : " ago")
  }
  ago = Days.daysBetween(start, end).getDays()
  if(ago < 7) {
      return "$ago day" + (ago > 1 ? "s ago" : " ago")
  }
  ago = Weeks.weeksBetween(start, end).getWeeks()
  if(ago < 4) {
      return "$ago week" + (ago > 1 ? "s ago" : " ago")
  }
  ago = Months.monthsBetween(start, end).getMonths()
  if(ago < 12) {
      return "$ago month" + (ago > 1 ? "s ago" : " ago")
  }
  ago = Years.yearsBetween(start, end).getYears()
  return "$ago year" + (ago > 1 ? "s ago" : " ago")
 }
}

And equipped with this codec, I am then able to call: submission.createdOn.encodeAsTimeAgoString() and viola, I have the proper 'time ago' for any Date type application-wide!

Here I could conclude that adding 'codecs' to any arbitrary Java type application-wide is piece of cake in Grails, and also here is a great example of the advantage of Groovy's seamless integration with "raw Java" where I was able to make use of an existing Java library (Joda time) with zero integration overhead.

Later...

Permalink codec

2007-05-13T09:59:00.000-04:00

So, for about a week I've been working on my fun little "social" Grails web application and I've been having a lot of fun.

Yesterday, while jyting I've been taking a note of its URL structure. Let's say you have a claim, and then in order to see it, the URL to it is not something like http://jyte.com/claim/show/12345 , but rather more readable, like http://jyte.com/cl/dima767.myopenid.com-is-the-only-grails-hacker-on-jyte

That's called "permalink" (for permanent link) and is done by converting the text of the claim (or any user submition for that matter) into permalink string (removing all the special characters e.g. \W, and replacing them with '-'). Then permalink essentially becomes a searchable attribute of the submission, so instead of doing something like Claim.get(1234) you do Claim.findByPermalink(params.permalink). It's just a way of creating "user friendlier" interfaces.

Thanks to Grails and its nice custom URL mapping, and custom codecs facility, I was able to implement "permalink" functionality very easily!

Lets' say I have a domain class "Submission":


class Submission {
  String title

  //permalink property here is for nicer URLs
  String permalink

}

So then I simply create "PermalinkCodec" utility class and place it in grails-app/utils so the Grails "ExpandoMetaClass" machinery could "weave" this functionality into all Strings!


class PermalinkCodec {

   static encode = { str ->
       str.toLowerCase().replaceAll(/\W/,'-')
   }
}

Then in my "SubmissionController's" "save" action I do something like this:


...
def save = {
   def s = new Submission()
   s.properties = params
   s.permalink = params.title.encodeAsPermalink()
   s.save()
   ...
}

And finally, i define the custom mapping:


class MyAppUrlMappings {
   static mappings = {
      ...
      "/s/$permalink" {
         controller = 'submission'
         action = 'show'
      }
      ...
   }
}

So this will give users nice URLs like http://myapp/s/my-shiny-and-the-best-in-the-world-submission instead of http://myapp/submission/show/1234

I think it's a little thing, but nice, nevertheless.

Later...

Groovy actors

2007-05-07T09:11:00.000-04:00

I've been reading up yesterday about an interesting concept called groovy actors:

IMO, this is a very interesting and powerful programming model. Now, my brain is working hard, trying to figure out some interesting ideas that could be implemented with 'actors'.

How about a "loosely-coupled demand/supply engine" where some people submit their "needs" and others submit their "offers" and the system does the matching and bring the parties together. Kinda like craigslist, but without people actually manually searching through the classifieds. Instead, they just express their needs and the system does the rest...

Another one, could be the automated "matchmaking engine", etc.

Does something like this exist already?

Later...

Jyting

2007-04-26T21:58:00.000-04:00

Ever since I've signed up for a Jyte account, I've been "jyting" more and more every day. It is actually quite addicting, so now I'm convinced that our upcoming "community" site should be Jyte-like. Please note, not a Jyte clone, but Jyte-like ;-)

Later...

Twitterfeed

2007-04-23T10:07:00.001-04:00

Testing twitterfeed.com ...

OpenID enabled...

2007-04-22T19:27:00.000-04:00

I've been reading some blogs and watching some introductory videos about OpenID today and I kinda like what I heard/saw. I think that by OpenID-enabling a "social" web site will help its adoption as there are many web 2.0 startups embracing OpenID and many more are coming aboard including giants like AOL and Microsoft.For the users of those sites, OpenID makes it easier to manage their identity and enables to participate in many, many, many "social networks" (OpenID-enabled) without a hassle. Plus a sea of endless possibilities to inter operate between OpenID networks, etc.

I'm seriously thinking of building support for OpenID into our upcoming site. I will be reading the OpenID spec in the upcoming weeks to get myself familiar with the technology. What would be cool is Grails support (plugin) for OpenID!

Later...

New adventure

2007-04-20T16:48:00.000-04:00

After thinking about doing something exciting e.g. building a web 2.0 style site that one day could become "the next best thing" :-) for a while with my colleagues, we've finally decided to go ahead with one idea. We would go ahead and build it, test if it will work or not, etc. No VC, no big expenses, no day job quitting, etc. The only thing we've decided to do is to register an LLC., get a cheap web hosting (for now), then "hack" the application and put it out there. The only investment would be our spare time and some money for expenses like registering a company and web hosting.

I'm excited about it for several reasons, because:
a) it's something different from doing my day to day job (working for "uncle Sam")
b) we will be building it with Grails!
c) Grails community is great!
d) and if we're lucky, we could "make some money" somehow ;-)

If anyone reading this could give a word of advice about decent/modern Java web hosting solution, that would be appreciated.

We will be registering a domain name for our LLC., putting "the new project" blog there, and will be doing updates about our "new adventure" in that blog.

Stay tuned...

Trip to Indiana

2007-04-02T19:40:00.000-04:00

Here I am, in my room of a nice Marriott hotel, located in a beautiful small town called Bloomington. That's in Indiana, about 50 miles from Indianapolis. We (me and my colleague) are here on the business trip to IU (Indiana University) to meet the technical team behind Kuali Rice project. Our organization is at the phase of evaluating different enterprise workflow and rules engines, and since Rice effort is built by higher education institution(s), it kind of makes sense for us to get involved with, I guess.

Anyway, Kuali is built on Spring, CAS, Acegi (in the future). Our management has "donated" both me and my colleague to join the architecture team for the purpose of helping out with the architecture of Rice, since I am an expert in Spring and my pal is a CAS (http://www.ja-sig.org/products/cas/) project lead.

So we met the team this afternoon (nice bunch of guys) and they showed us around Kuali and the Kuali Rice. I can't say that I'm impressed so far (heavy, heavy use of XML, XSLT, which I'm not a big fan of; use of Apache OJB for the persistence layer, etc.), but I could say that only time will tell as we dig deeper into it. May be we will be able to convince them to re-evaluate some of the technology choices i.e. use of JPA for the persistence and Mule for the KSB (Kuali Service Bus), and may be I'd be able to sneak in some Groovy in there to define a nice DSL for the Workflow and Business Rules definitions ;-) But until I could fully understand the architecture, I'm not going to speculate anymore.

Hopefully everything goes fine this week, so on Friday I could safely return to my beautiful, young wife and my adorable daughter, whom I already miss!

Later...

Time to look back

2007-03-26T14:38:00.000-04:00

It's that time of the year again. No, I'm not talking about the Tax submission time. I'm talking about the "annual performance review" period at my organization. So, I'm going to be busy at work trying to craft a fancy "self appraizal" with a list of great accomplishments that helped my organization be the best of the best and stay in business.

[Update: I just received a word from my boss that he needs it ASAP]

Now I just need to remember, what the hell did I accomplish...?

Later...

Groovy adoption continues

2007-02-25T14:16:00.001-05:00

There are a lot of heated debates lately about Java vs dynamic languages such as Ruby and Groovy, the Ruby vs Groovy, RoR vs Grails, etc. Some folks say that Groovy is a failure, that it's a hacker's toy language and that it's much slower (cause it's doing all the wonderful meta object magic at runtime) than "raw" Java. Of course it's slower, but come on, we live in the 21st century and with the computing power available and type of work we do (for typical web applications, anyway) does it really matter? And of course, as we all might know, that the most time is spent in the database and passing data over the wire. After all, if one needs pure real time performance or builds aircraft management system, than yes, choose the right tool for the job i.e. real time C, Ada or even Assembly.

Anyway, I've got this new project assignment - it's a small and simple CRUD application with several screens backed by Oracle. I didn't choose Grails yet, as the DB schema is so twisted that it wouldn't map naturally to the domain. Instead I've decided to introduce some Groovy via Spring 2.0 dynamic language integration. I've written controllers, validators and repository in Groovy. Here's the code snippet from simple Spring controller implemented in Groovy:

class AvailableCourseSearchController extends AvailableCourseBaseController implements InitializingBean {
  
   AvailableCourseRepository availableCourseRepository
  
   public ModelAndView processFormSubmission(HttpServletRequest request, HttpServletResponse response,
 Object command, BindException errors) throws Exception {
       def availableCourses =
           this.availableCourseRepository.findAllByCourse(
               new Course(unitOfRegCode:request.getParameter('unitOfRegCode'),
                       offeringUnitCode:request.getParameter('offeringUnitCode'),
                       subjectCode:request.getParameter('subjectCode'),
                       courseId:request.getParameter('courseId')))
      
       if (availableCourses.isEmpty()) {
           errors.reject("courses.not.found")
           return showForm(request, errors, getFormView())
       }
       def courseHolder = new CourseHolder('courses':availableCourses)
       request.getSession().setAttribute(getCommandName(), courseHolder)
       new ModelAndView(getSuccessView(), ['courseHolder':courseHolder,'suffixAList':suffixAList,'athleteCodeList':athleteCodeList])

And then the implementation of the course repository uses groovy.Sql to query and construct Course object. It's no JPA of course, but for simple case like this it works like a charm:

class AvailableCourseRepositoryImpl implements AvailableCourseRepository {

    Sql db

    void setDataSource(DataSource dataSource) {
        this.db = new Sql(dataSource)
    }
    
   
    List findAllByCourse(Course criteria) {
        def query = buildDynamicQueryString(criteria)
        def courses = []
        this.db.eachRow(query) { courseRow ->
            courses << new Course('unitOfRegCode':courseRow.unit_of_reg_cd,
                     'offeringUnitCode':courseRow.offering_unit_cd,
                     'subjectCode':courseRow.subj_cd,
                     'courseId':courseRow.course_no,
                     'courseTitle':courseRow.course_title,
                     'suffixA':courseRow.suffix_a,
                     'unavailable':courseRow.course_deleted_ind == 'N'?false:true,
                     'required':courseRow.required_ind == 'N'?false:true,
                     'athleteCode':courseRow.athlete_cd,
                    'id':courseRow.id) }
        return courses
    }
}

This usage of Groovy in these simple scenarios proved to be simple and expressive. The next step is a full-blown Grails application!

Later...

Grails will survive

2007-02-22T11:40:00.000-05:00

Some people have an opinion that Grails will fail. I have an opposite opinion that Grails will "survive".

Later...

Founders at work - the book

2007-02-14T10:14:00.000-05:00

Today is the first significant snow storm of the season in the North East. Finally I arrived at work (after around a 3 hours of fun commute). Of course the train had to break down somewhere between Newark Penn and EWR station, so we (unfortunate passengers) were sitting there for about 40 minutes.

Nevertheless, I wasn't bored at all because I had something interesting to read. The new book called "Founders at work" has arrived last night. The book is unique (IMO) in that it's a collection of interviews of the "fathers" of successful "startups" who are now millionaires. Founders of such companies as PayPal, Adobe, Apple, Yahoo, Hotmail, del.icio.us, 37signals, Tivo, Firefox, to name a few, are talking about all the things that they had to do inside and out to make their companies where they are today - from initial idea, implementation, initial funding, and ups and downs of the early days. The stories are incredible and they show that those folks are not "super humans", but just very smart and motivated people and in many ways they are just like "the rest of us".

I have a feeling that this read will be very refreshing and motivational for me ;-)

Later...

Groovy adoption begins

2007-02-11T08:39:00.000-05:00

After virtually being in the Groovy and Grails world for a couple of months - that is reading GINA and Definitive guide to Grails books and just playing around with Grails, I finally decided to start slowly introducing this wonderful language and framework at work.

So I decided to "just do it". The first opportunity came as there is a need to rewrite a simple CRUD type of an application written in Oracle forms (BTW, this app is used by one person only one time a year) That would be the typical Spring stack app. At first one might think that it would be a perfect candidate for Grails, but then several factors decided against it: the db schema is so messed up that even "raw" Hibernate mapping would not be able to help (it doesn't have any PK for instance; tables are terribly denormalized... agrrr); and also I decided to wait until Grails matures a little, so I would have easier times of pushing it through our "red tape".

So I've just introduced a simple helper written in Groovy, using groovy.Sql to do a simple DB update. Then injected that Groovy implementation into a "raw" java DAO using Spring 2.0 dynamic language support. I'll tell you one thing - the clarity of the code is even better than using JdbcTemplate (Oops.. did I actually say it) :-)

Next step is to rewrite the SimpleFormControllers in Groovy to reduce the amount of code in half.

And then fully rewrite one of our simpler Spring apps (namely netid query) in Grails (shhh... don't tell anyone...I've already done it... When the time is right I'll introduce it to our crowd at work)

Later...

Operation "freedom from DBA's"

2007-01-24T15:59:00.000-05:00

The never ending saga continues... I mean as long as I've worked at this organization (4+ years now), one of the frustrating things remains is the relationship with our old-school Oracle DBAs. Even though we've been able to revolutionize our development process, enterprise architecture, etc. from a big "waterfall mess" to "agile", "iterative" (or name it whatever you like), one aspect remains ancient - the database administration and "gate keeping" waterfall frame of mind, which in practice totally slows the iterative development cycle and adds frustration.

The current frame of mind of our DBAs is the "total control". No development schemas with full DDL privileges exist (forget about the individual development DB snadboxes). The development teams have to develop against central "application" schemas with any slight DDL action having to have to go through the "DBA authority". Also they require that all the database design is done upfront and approved by them before doing any development: classical waterfall if you ask me.

Nevertheless, the first signs of the new direction that they're (DBAs) willing to try to take showed today (thanks to my boss who's trying hard) This means that for each individual project DBAs are willing to create a "development" schema with all the necessary DDL privileges granted to developers (that's something!). But with that they still require the up-front design, strict approval, and early "synchronization" with the "application schema" Agrrrr.

Well, may be some day, the DBAs will finally get the "iterative" development process and perhaps embrace it. But I have a strange feeling it will not be in my life time :-(

It's time to catch a bus. Later...

Philadelphia SPUG

2007-01-24T09:12:00.000-05:00

Yesterday I went to the Philadelphia's Spring user group meeting with two of my colleagues, where Thomas Risberg presented "using Groovy with Spring" (using Spring 2 dynamic language support) and Jason Rudolph of Grails fame presented "An introduction to Grails"

Thomas showed the arbitrary Spring web app with Controller implemented in Groovy and seamlessly integrated with the rest of the app e.g. dependency injected, etc. This is really cool integration and I'm definitely going to explore it by slowly introducing some Groovy bits and pieces into our existing Spring apps by perhaps implementing some Services in Groovy (where it makes sense of course) to do things much more expressively and naturally :-) One such example would be the XML parsing (agrrrrr) with Groovy's excellent XML support i.e. XmlSlurper, GPath, etc.

Then Jason did an excellent job of introducing Grails to the audience. I felt that the presentation was very fresh, dynamic and not boring. Jason used a "live coding" demo, where he coded from scratch the basic "Racetrack" application (from his "Getting started with Grails book") before our eyes. Nice job Jason! I might even steal his presentation to do it at our internal "Design and Development" meeting to introduce it to our development crowd.

And also I've won a copy of an excellent and much anticipated "Groovy in Action" book! The only caveat is that I've ordered that book from Amazon a couple of weeks ago and it actually arrived last night :-( So this one will go to our "Development library" at work to educate other developers about this excellent language.

I am very excited about Groovy and Grails development and the growing momentum it has. And I sure hope to see Grails applications being developed and deployed at our enterprise some time in 2007!

Later...

My first

2007-01-20T13:12:00.000-05:00

Today's Saturday. This is my first post. Just for fun. Just for me, not for the world to judge me. I'll try to keep this blog work-oriented as much as possible.

Anyway... Myself and Zina have just finished a "fun" activity of bathing our precious 30 days old daughter Oksana. Now she's asleep and hopefully I would have a chance to watch today's Devils vs Flyers game... Oh, the game is on...

Later on, my "mama law" is coming to babysit Oksana so we could go with Zina to my folks and finally have a good night sleep. I'll be taking my mac book with me with the latest Grails src tree where I'll be studying in details the persistence layer.

Monday I'm off. That's about it for the first post. Later...