ducktools

Redmine + thin + nginx on Debian GNU Linux

2011-06-02T16:25:28Z

Redmine is a nice tool for managing projects or at least it is a great bug tracker. Of cause, there is an official guide on how to install Redmine on your own machine. But Debian users have also the option to install redmine with the Debian package manager. There is short documentation on the Redmine wiki on how to install and use these packages, but it isn’t very detailed and doesn’t come with a complete setup including the thin application server and the awesome nginx webserver to run Redmine.

Why to choose the Debian package?

It is possible to install Redmine from source and setting up eveything by hand. You can install Ruby 1.8 by rvm and create a Gemset for Redmine. You can even install nginx from source. But one of the reasons, why people choose Debian as their operating system on servers is the stability of the system. During the lifetime of a Debian release everything just works and nothing breaks. The only updates you get are bug fixes and they are just making your system more stable and secure.

This is also true for Redmine. So instead of taking care on new Redmine versions and doing updates by hand, Debian gives you a simple command

apt-get upgrade

to get all the bug fixes for the whole system including Redmine.

Another good reason is, that Redmine has – as most other software too – a couple of dependencies. This includes a Ruby runtime, Rails and a database to name a few of them. Installing the Debian package resolves these dependencies for you, what makes the installation process much easier.

Install everything!

First let’s look on what to run exactly. Redmine is a Ruby on Rails application. Installing Rails and Ruby is handled by the Debian package manager, but to run the application after installation, a Ruby webserver is required. There are a couple of great open source Ruby webservers out there, but I prefer thin, since it works really well with nginx. On Debian 6 thin is also available as a Debian package from the stable repository. The next point is the database. Redmine offers you to run on MySQL, PostgreSQL or SQLite. So let’s choose MySQL, which might be the choice of most people. And of cause we need the nginx webserver! So let’s get the requirements with

apt-get install mysql-server thin nginx

For Redmine there are to versions available, 1.0.1 in Debian 6 stable and 1.1.2 in Debian 6 backports, but the installation and set up shouldn’t differ between both. So install Redmine with

apt-get install redmine redmine-mysql

Well a point one should know about the Redmine package is, that it’s made for running multiple instances of redmine. Each instance might have it’s own database and configuration. We can use

dpkg-recofigure redmine

to create and set up these additional instances. Each instance’s configuration is placed under /etc/redmine/INSTANCE_NAME. During the installation process you will be prompt for configuring at least one Redmine instance. To get a single instance set up, just configure an instance named default.

Getting Redmine runnig with thin

Now we have Redmine installed and set up a MySQL database for it, but to access Redmine from the browser, we must run it on thin. This is a pretty easy task after we have installed thin allready. Thin is configured under /etc/thin1.8, this means that thin started by

/etc/init.d/thin start

will load each configuration file from this directory and run the configured apps. For our Redmine instance we can simply create a file called /etc/thin1.8/redmine.yml with the following content

user: www-data
group: www-data
chdir: /var/www/YOUR.DOMAIN
pid: /var/run/redmine/default/thin.pid
socket: /var/run/redmine/default/thin.redmine.sock
log: /var/log/redmine/default/thin.log
environment: production
servers: 2

For a multi instances set up, such a file is required for each instance. What thin does is running two processes (servers) for an application placed in /var/www/YOUR.DOMAIN. Each of these processes can be accessed through an unix socket under /var/run/redmine/default/thin.redmine.0.sock and /var/run/redmine/default/thin.redmine.1.sock. Both processes are running as www-data user. To get this configuration working, the path /var/www/YOUR.DOMAIN must point to the redmine installation directory under /usr/share/redmine, so simply create a link on it:

ln -s /usr/share/redmine /var/www/YOUR.DOMAIN

That’s it. Start thin and Redmine is running.

The last step

Since nginx will be used as the webserver, we need to configure it. I won’t show how to configure the whole webserver, since this is documented ways better in the nginx wiki. But to get Redmine running, you can add a configuration like the following to nginx

upstream redmine {
  server unix:/var/run/redmine/default/thin.redmine.0.sock;
  server unix:/var/run/redmine/default/thin.redmine.1.sock;
}

server {
  server_name YOUR.DOMAIN;
  root /var/www/YOUR.DOMAIN/public;

  location / {
    try_files $uri @ruby;
  }

  location @ruby {
    proxy_set_header  X-Real-IP  $remote_addr;
    proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header  Host $http_host;
    proxy_redirect off;
    proxy_read_timeout 300;
    proxy_pass http://redmine;
  }
}

The above configuration let’s nginx serve everything from the directory /var/www/YOUR.DOMAIN/public, if it could find a static file there. Since Redmine is a Rails application all static content is placed here. If there is no file, nginx tries to call the redmine upstream to serve something else. The upstream is our unix socket connection to thin, we have configured in /etc/thin1.8/redmine.yml.

GWT hosted mode in Eclipse with Tomcat and Maven – v2

2010-07-08T17:00:08Z

I’ve already posted about running GWT in development mode from Eclipse, if you’re using a different server project or you’re using Maven. The problem is, that there was an update on the GWT Eclipse plugin. So let me show you how to it do again (and now with screenshots).

This time we will use a real project and you can try it out, since the source code is available as open source on Github. If you’re using Git you can get it here. If you’re using Subversion, Github provides also Subversion access. If you are not using one of these versioning systems, download the code directly. The code repository contains two Maven projects, but for this case only the project slf4gwt-samples is required.

Getting the code into Eclipse

For getting the code running in Eclipse, you need of cause Eclipse and a server. In this sample Tomcat 6 is used. I expect, that you know how to get Tomcat or another server installed to Eclipse. For handling Maven projects, you will need to install m2eclipse, which enables Eclipse to read project configurations from Maven POMs. To do this, you will first have to add the following two Eclipse update sites http://m2eclipse.sonatype.org/sites/m2e and http://m2eclipse.sonatype.org/sites/m2e-extras and than install the Maven Integration for WTP plugin from the second update site.

If you just downloaded the code from the above link, go to the menu File -> Import and choose Maven -> Existing Maven Projects to get the code into Eclipse. Under Root Directory select the directory, where you downloaded the code. You should know see something like below, where the two Maven projects and their submodules are shown. We just want to import the samples project, so unselect the other one.

Well, now in Eclipse you should see four projects.

Enable GWT in Eclipse

After getting the code into Eclipse we want to enable GWT. So first install the GWT plugin and the development mode plugin for your browser. M2eclipse excludes the content of the src/main/resources directory from the Eclipse build path, but the GWT plugin requires them on the build path. So you have to fix this manually in the Java Build Path properties (right click -> Properties). On the Source tab, you will have to remove the Excluded configuration for the src/main/resources directory like below.

You should do this for the both projects, which names start with slf4gwt-samples-client. Now select the slf4gwt-samples-client-app project and make it a GWT project (right click -> Google -> Web Toolkit Settings -> Check Use Google Web Toolkit).

Now you should add the slf4gwt-samples-server-app project to the Tomcat. Make sure that there is a directory src/main/webapp/client in this project. Else run mvn install on the slf4gwt-samples project (e. g. from the terminal or m2eclipse). Try to run the server and open http://localhost:8080/slf4gwt-samples-server-app in your browser, you should see something.

Run GWT Development Mode

Now it’s time to get the GWT development mode running and try to debug the code.

Go into the Run Configuration menu and create a new Web Application configuration (this little Google g). Select the slf4gwt-samples-client-app project and set com.google.gwt.dev.DevMode as the Main Class. On the Server tab uncheck Run built-in server and on the GWT tab set the URL as http://localhost:8080/slf4gwt-samples-server-app.

Save and run!

The big surprise is a file dialog requesting for the war directory. Select the src/main/webapp directory from the slf4gwt-samples-server-app project and you are done. Now the GWT development mode runs.

There will be an Eclipse view called Development Mode, that shows you the URL for development mode. Copy it into your browser. If you launch the above run configuration in debug mode and set a break point, it should stop as expected.

GWT hosted mode in Eclipse with Tomcat

2010-04-09T16:25:50Z

In my last post I showed how to work with Maven and Eclipse and a multi module GWT project. Well, I did not discuss, how to run the GWT application in hosted development mode. The problem is not related to Maven, instead it is a common problem with GWT’s development mode and server side applications, that are located in different projects.Well let’s take the same project structure as in the last post:

photo-album-project |- photo-album-server |- photo-album-client |- photo-album-client-ui |- photo-album-client-services

As you can see, photo-album-server, which contains the server side code, is in a different project than the GWT client code, which is splitted up into three projects. The problem is, that the Google plugin for Eclipse by default is configured for having all (server and client code) in one project.

Making the client application GWT ready

It is not required to make all three client projects a GWT project in Eclipse, instead this only required for projects, you want to use the GWT tooling on. If you want to use the GWT Java editor (provides support for JSNI code) instead of the standard Eclipse Java editor, you will have to enable GWT tools first. The same if you want to create new UIBinder, it only works if your project is GWT enabled. At least the project containing the EntryPoint of our GWT application requires to be GWT enabled.

To make it GWT ready, right click on the project, go to Google -> Web Toolkit Settings and enable Use Google Web Toolkit. That’s it.

Running in development mode

Now create a new lauch configuration and select the type Web Application. Well the trick is now to disable the build in server and enter the following line as Programm Arguments:
-startupUrl http://localhost:8080/path-to-my-host-page
This will tell the development mode to choose the given URL for the host page. This can also be an URL on another machine. The only requirement is, that the GWT application is compiled once as JavaScript and this JavaScript is included in the HTML page at this URL.

Note that your server project does not require any GWT specific stuff. It only needs a compiled version of your GWT application, since the GWT development mode needs to detect the correct module.

Maven and GWT – a never ending story?

2010-05-07T09:43:56Z

One of the cool things on GWT is, that you cannot just use Java as a programming language, you can also use all your cool and great tools, like Eclipse, JUnit, or build tools like Ant, Gradle or Maven. Sure you can, but this Maven thing seems not to be so easy. So lets take a look on how to solve it.

The project structure

Assumed you are not doing a simple one project thing, instead you want to rock on GWT and build a really big project. In this case you want to make use of Maven’s cool module concept, that allows you to split up your project in parts – so called modules. Additionally it is recommended to keep the structure clean by separating client (GWT) and server (maybe Java or even any other language) code in a strict way. This means, that your GWT code will not be in the same project as your Java EE web descriptor (web.xml).

But lets take a closer look to our structure:
photo-album-project |- photo-album-server |- photo-album-client |- photo-album-client-ui |- photo-album-client-services
The above structure is not compatible to Eclipse, since it has a project inside a project from an Eclipse point of view. But there is a nice plugin for Eclipse called m2eclipse. It will do the thing for us (Make sure you installed the WTP integration for m2eclipse too). You can simply import the Maven project including it’s modules as a Eclipse projects. Additionally the plugin provides a special editor for Maven‘s POM files and does the dependency magement. If you have done the import, our photo-album-server module will be a Dynamic Web Project in Eclipse and you can add it to your Tomcat, JBoss or whatever server runtime. You can start it and run it as you like.

Separating client and server code

As we decided above, we want to separate the client and server code in different projects. But if you run a Maven build, you want your GWT code to be compiled into the resulting WAR as JavaScriptt. You also need a host page to launch your app in the browser.

Well the host page should be a JSP like any other in a Java EE project and it will contain a script tag loading the GWT application. Since each GWT application requieres a module declaration with an entry point it might look like the one below.

<module rename-to="client">
  ...
  <inherits name="org.ducktools.photoalbum.client.ui" />
  <source path="client" />
  <entry-point class="org.ducktools.photoalbum.client.ApplicationEntryPoint" />
</module>

You can see that the long name of this module will be renamed to client which results in simpler JavaScript name after compiling. So our host page might look like the following.

<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
    <title>Photo Album</title>
    <script type="text/javascript" src="client/client.nocache.js"></script>
  </head>
  <body>
  </body>
</html>

But how can this be compiled with Maven? First the photo-album-client module must be a dependency of our photo-album-server module. The second point is, that the GWT compiler configuration is done in the web application project. This is the best place, since you can just change the dependency and the GWT module and the compiler will compile a completly different GWT client. With other words, the web application pulls the right JAR out from the Maven space and uses it. This is much better than letting another project compile some JavaScript and than copy the JavaScript to your web application, or whatever solution you might find. So just add the GWT Maven plugin configuration and dependency below to the photo-album-server module’s POM.

...
<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>gwt-maven-plugin</artifactId>
  <configuration>
    <webappDirectory>${basedir}/src/main/webapp</webappDirectory>
    <module>org.ducktools.photoalbum.client</module>
  </configuration>
  <executions>
    <execution>
      <goals>
        <goal>compile</goal>
      </goals>
    </execution>
  </executions>
</plugin>
...

You should also configure Maven’s clean plugin to delete the JavaScript:

...
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-clean-plugin</artifactId>
  <configuration>
    <filesets>
      <fileset>
        <directory>${basedir}/src/main/webapp/client</directory>
      </fileset>
    </filesets>
  </configuration>
</plugin>
...

The dependency to the client will be added with the scope provided:

...
<dependency>
  <groupId>org.ducktools.photoalbum</groupId>
  <artifactId>photo-album-client</artifactId>
  <version>1.0</version>
  <scope>provided</scope>
</dependency>
...

This forces Maven, to put the JAR on the classpath during compilation, but not into the WAR. This makes sense, since the Java code is not nessesary at runtime. It will just be compiled to JavaScript and this JavaScript will be included in the WAR. Making a Java project GWT ready This is not a really big task, since our project requires GWT dependencies on the classpath and has to include the source code in the JAR:

...
<dependency>
  <groupId>com.google.gwt</groupId>
  <artifactId>gwt-user</artifactId>
  <version>2.0.2</version>
</dependency>
...
<resources>
  <resource>
    <directory>src/main/java</directory>
  </resource>
  <resource>
    <directory>src/main/resources</directory>
  </resource>
</resources>
...

This is a good practice, since our project is just a simple Java project. You can do your unit tests and be happy with it. The GWT magic is only done in the web application project like above.

Move to WordPress

2010-04-18T09:52:30Z

The last weaks were busy and it was quite around my Blog. But now it’s time to take the beautyful spring weather and start into the summer with blogging.The first step to go on is a move away from blogger.com to my own self-hosted WordPress blog. You can reach it on ducktools.org. There is also a new feed to it (http://feeds.feedburner.com/ducktools), which is free of advertisement, but you can still read on the old feed, too.

So why have I moved to WordPress?

This is a good question and the answer is simply freedom. Sure WordPress is Open Source, but in this case it is the freedom to do more with my blog than blogger.com allows. Now I can create my own layout, I can create static pages and I can install many, many plugins to my WordPress. This is a big benefit since I want to do all these things in the next months.

What’s on the agenda?

I will continue with my series about advanced GWT architecture. You can already follow my github repo, if your interessted in the changes to the sample code for the tutorial.

Currently I’m not done with my new WordPress blog. Creating my onwn layout and customizing lot of stuff will be on the agenda too.

I will spent some further time to get a first release out of my log4gwt library, which will provide a new level logging for GWT apps. Guess where this will have a little project page. It’s one of the reasons, why I moved to WordPress. You can of cause follow the project on github.

There is also this simple but very popular GWT – Grails tutorial, I’ve written a long time ago. It’s outdated totally and requires an update. I think it will get a new home on ducktools.org and there is already a new repo on github.

So you can see, there are some nice things, that should follow on this new blog, so read on.

Advanced RIA architecture with GWT – Part I (first overview)

2010-03-24T21:26:57Z

Rich Internet Applications (RIA) are not really a new thing, but currently there are just a couple of web pages out there, using a real RIA architecture. So it’s new enough to write a series of articles about creating a good RIA architecture with the Google Web Toolkit. I’m sure some of the patterns and concepts are also portable to other frameworks.

Model View Presenter Pattern (MVP)

In the last year it became very popular in the GWT community to use the MVP pattern instead of the MVC (Modell View Controller) pattern. One of the reasons is that Ray Ryan from Google introduced it as a best practice at Google IO 2009:

The pattern is supported very well by GWT since version 1.6 introduced interfaces like HasWidgets or HasClickHandlers to decouple the View from the presenter in the required way. The other great new technology that GWT 2.0 provides to support this pattern is the new UI-Binder mechanism, which allows a declarative UI creation.

The difference to the MVC pattern is, that the model is not accessed by the view directly. Instead the presenter does the job. This reduces the view just to a collection of UI elements and their layout. Below you can see the difference between both:

In the MVP pattern the presenter is the leading part of each component. It will communicate to the server, render the model to the view and thus contain the whole logic of this component.

EventBus

Since each component in the UI is build of a presenter and it’s view object, there must be any way of communication between the components.

Assume you have got a photo app like Flickr or Picasa and you want to create a list with all photo albums on left while the thumbnail view on the right will show all photos in the selected album. How will a selection on the left component be communicated to the right?

The EventBus solves this problem. If an album is selected on the left, the presenter will fire an AlbumSelectedEvent, while the other presenter has registered a Handler for this event. If your application becomes bigger, other presenters can also register for this event and react to it. There should be exactly one EventBus for the whole application and all events should be fired through this.

Command Pattern

The Command Pattern is a classical pattern widely used in software development. In GWT applications it is a great way to realize the communication to the backend (e. g. on a server). The idea is, that each presenter can give command or better action objects to one central handler, who is delegating the command to an executor (e. g. on the server or the client site service for RESTful API). The presenter does not care about, how and by whom the command is executed.

All together

Let’s take a look on an overview of our sample photo application. It’s architectre could look like the following:

As you can see, there is no backend realized in this sample, but it shows how the architectural concept from above can work together.

Grails GWT Google Group

2010-03-24T21:26:46Z

There are lots of comments with questions below my Grails / GWT tutorial. Many people are also asking questions about GWT on the Grails mailing list. To move Grails / GWT related questions to single public place there’s a Grails GWT Google Group now.

Come in and join, if you’re interested in using GWT with Grails.

Cool things with Grails URL mapping

2011-06-02T13:25:16Z

In Grails you have a lot of nice features for doing web development. One of them is URL mapping with the link tag.

Grails default mapping is this:

"/$controller/$action?/$id?" {}

This will map the URL ‘http:localhost:8080/myapp/book/show/1′ to the action show in the BookController class. To create such links you can use the link tag like this:

<g:link controller="book" action="show" id="book.id">
  ${book.title}
</g:link>

Sure this is the standard way. But now lets change the URL mapping by replacing the default mapping:

"/$book/$id?"(controller: "book", action: "show")

This will tell Grails to map the URL ‘http:localhost:8080/myapp/book/1′ to the same show action as above, but what’s happening with our link?

It’s stil working! Grails knows, that URLs, which are pointing to BookControllers’s show action have to be of the declared structure and thus, the link tag will create a URL like ‘http:localhost:8080/myapp/book/1′.

Ok, let’s go on. What else can we do with this?

By default the URL ‘http:localhost:8080/myapp/book/list?year=2009′ will point to the list action of BookController and the URL parameter year will be available with

params.year

in the action. To create this URL you can use the link tag again:

<g:link controller="book" action="list" params="[year: "2009"]">
  Books released in 2009
</g:link>

Now let’s change our mapping again by adding:

"/$books/$year?"(controller: "book", action: "list")

Well, now the above link will create the URL ‘http:localhost:8080/myapp/books/2009′ and everything else will stil work as expected.

The company zoo

2010-03-24T21:26:17Z

Today it’s raining and it was a natural choice for a little butterfly to come into my office and sit down on a dry paper. And now she’s still sitting there and sitting and sitting …

Ohh I forgot, her name is Mathilda.

GWT best practices

2010-03-24T21:26:06Z

A great talk from Google IO 2009 by Ray Ryan:

It comes with two great ideas, Dependency Injection for GWT and a pattern called MVP/EventBus.
Sounds pretty interesting.

Mercurial and moving of files.

2011-06-02T13:18:55Z

A problem, when you’re using Mercurial forversioning is, that Mercurial only knows about files and there paths. This results in two types of trouble.
First you cannot commit an empty directory. It will be just ignored. To solve his, create a hidden empty file (one with a dot at the beginning of the name like ‘.hidden’) and commit it.
Second you cannot just rename, or move a file. Mercurial will think, that there is a new file and the old one isn’t available anymore and that fact crashes your commit. To solve this, Mercurial provides the command ‘mv’ (like the UNIX command). Just type

hg mv path/to/my/SourceFile path/to/my/DestFile

into your Terminal and you’re moving or renaming it. Mercurial will then understand, that both files are the same.

Git vs Mercurial and the fight of SCMs

2010-03-24T21:25:43Z

In the past I was using Subversion as a SCM (Source Control Managment) and Google’s project hosting is still using it, so Google Code was allways a good place for hosting some open source code.
But now the world has changed. I recognized the idea of distributed SCM (DSCM) first, when I heard about github.com and I gave it try. The big benefits are, that you can work offline and everyone has his own repository with full versioning and so on. The result for my own work is, that I do much more commits and of cause smaller ones. Just after doing a cupple of them, I push my changes to the server.

But What is the right system and right hoster?

This is a very interesting question and it forced me to test a little bit around. And I found a cupple of benefits on each system and each hoster. But in the end I decided to stay on Google Code and use Mercurial.
The reasons are pretty simple:

Mercurial isn’t that different from Git as I expected.
Social comopents are not so interesting for a project hosting.
Google has a much better code and history browsing than github.
Extisting Subversion projects can be converted including history.

So my desicision was clear. I mooved the DuckWiki repo to Google Code, and will use Google Code and Mercurial in the future.

If you’re thinking about Mercurial and Git, there is another point, you might be interested in, which I didn’t care about so much:
While Git only works over SSH, Mercurial provides you the choice between SSH (makes maybe more sence in a Company’s internal network) and HTTP (is much nicer, if you’re repo should be open for annonymous users).

GORM + JPA now available

2010-03-24T21:25:25Z

I was waiting for this feature so long and now it’s there:
GORM works with any JPA provider not just with Hibernate.

The first release of the plugin was just anounced by Graeme.

This is realy great news since the DuckWiki project can now make use of it. As a result, DuckWiki should work on each Java EE 5 app server without the need of having it’s own (Hibernate) persistence layer.
As a key feature the awesome dynamic finder methods, provided by GORM, are also working, except on Google App Engine (look at this bug).

Social coding and Twitter

2010-03-24T21:25:07Z

A nice feature on github.com is, that you can add your Twitter credencials to a project and all commits to this projects will be twittered. That’s a nice way to be notified on changes. The other part is, that comments on your commits get a new sence in being Twitter posts.

If you would like to be notified on DuckWiki just follow duckwiki.

Problems with Safari 4, scrolling and the colors of the page

2010-03-24T21:24:54Z

Just right after the keynode I installed Safari 4 on my Mac. I’ve allready tested the beta for a cupple of weeks and was surprised about the speed. But after the the installation of the final release I recognized, that the color was fading while scrolling. In the worst case I got a black/white page. This problem is posted in an Apple Support Discussion.

The solution provided in the discussion seams to work for me.

If you’ll get this problem, open Disk-Utility app, select your HD and press Restoring Permissions. Wait some minutes, restart Safari and that’s it.

Cooler coding with Git on github.com

2010-03-24T21:24:43Z

In the past I’ve choosen Google Code to host my open source code, but with DuckWiki, I started using Git hosted on github.com. Git is not the only distributed version control system and there are some things, which are not so cool, like there is no real native Windows support (but I kicked Windows out of my life for a while). Google Code provides Mercurial as an distributed version control system and they told the rest of the world how they implemented Mercurial on their system.

But at least their are two reasons for github.com.

Private repos: If you pay, you’ll get private repositories for non-open-source projects.
Social coding: github.com provides a cupple of cool features like following other coders, watching their projects, etc. It makes it all feeling like a real community of coders.

Even the Grails team is using it.

So get on, create a account and follow me or duckwiki project on github.com

The next big thing in my iTunes library

2010-03-24T21:24:22Z

I just found this girl from the wonderful London. First I heard it on the local radio station and now I got on my iPod, yeah.

More about her.

SWT File Drag’n'Drop

2010-03-24T21:24:09Z

Did you ever try to enable your Eclipse RCP application to handle file drops from the Explorer, Finder, or whatever your OS brings?
Here the solution:
http://alan.blog-city.com/swt_dragndrop.htm

Symbolic a Grails example

2010-03-24T21:24:02Z

While I prefer Ubuntu as a Linux OS, there is a cool Open Source application available for administration of Fedora and RedHat Linux machines, called Symbolic. It’s based on the awesome ils framework and it’s defenitiv a good example, that an Open Source application can have a pretty looking homepage

Tiny URL for your app

2010-03-24T21:23:45Z

It is a great idea to make big URLs more usable. TinyURL is such a service, who can do this for you. I use it a lot in Twitter, but what if you also want in your own app?

It’s pretty easy since TinyURL provides a nice and small API.

http://tinyurl.com/api-create.php?url=http://theurlyouwantmakesmaller

The result will be the TinyURL link, you’ll want. Try this:

http://tinyurl.com/api-create.php?url=http://www.timetoact.de/ttacms.nsf/id/EN_EmployeePages

It will create a TinyURL to a product presentation of my company. Copy the shown URL to your browser’s address bar and you’ll see, it just works.

To much snow for a wednesday

2010-03-24T21:22:55Z

I can’t belive, but this morning there were 10 cm of snow on my car. I like snow in my holydays, but today I’m working. Here some impressions from today’s ride to work:

Enabling the cool developer tools in Safari

2011-06-02T13:15:57Z

All web developers love Firefox because of the awesome Firebug Add-on. Sure, me too, but what is with all the other browsers?

Well, Microsoft will maybe offer real developer tools with IE 8. But for my favorite rendering engine WebKit (e. g. in Safari or Google Chrome), there are allready some cool tools availabe. On a Mac all you need to do is typing the following command into your Terminal:

defaults write com.apple.Safari WebKitScriptDebuggerEnabled -bool true

Now open Safari’s preferences and activate the develop menu on the advanced tab. That’s all. You’ll get a cupple of cool tools, which are as powerful as Firebug.

Here the network ananlysis of my iGoogle page:

Looking pretty nice, or?

More for Drosera (that’s the name of the WebKit developer tool) can be found here.

Now it’s official

2010-03-24T21:21:46Z

Graeme has just posted it.
Congratulations to the G2One guys.

SpringSource has bought G2One

2010-03-24T21:21:40Z

I just read it, but I’m not sure if it is realy true, what The Register writes today. G2One is the company of Graeme Rocher and the other guys behind Groovy and Grails. SpringSource is the company behind the awesome Spring framework, which is also the base of Grails.
Hopefully there will come a lot of benefit from this acquisition for Grails. My biggest wish is, that they will bring Grails to Spring Dynamic Modules for OSGi and thus onto a great OSGi infrastructure. This would also fix the most voted issue for Grails.

Girl Effect

2010-03-24T21:21:14Z

There is chrismas coming soon. So start thinking, if buying much presents for all the people you know, is the best you can do with your money.
You can also give it to someone who can do much more with it:

GroovyMag, oh yeah!

2010-03-24T20:49:26Z

I just read on the Grails homepage, that #1 of the GroovyMag is released.
You can buy it as a PDF online, which is great, since I come from Germany and a magazine printed for the US doesn’t make any sence for me.
I’ll give it try and tell you how it is.
So keep on grooving.

Groovy for Java Testing

2010-03-24T21:20:40Z

One thing I like so much on YouTube is the mass of cool videos of talks, provided there. So have a look to this cool video:

It gives a little introduction to Groovy, it’s integration to Java and it’s awesome usabillity as a language for testing your Java code.
The speaker is Andres Almiray and you’ll find his own blog here:
Andres Almiray’s Weblog

Lotus Notes 8.0.1 on Ubuntu Hardy Heron and the Mozilla problem

2011-06-02T13:14:05Z

I use Lotus Notes 8.0.1 on my workstation, but on Hardy Heron I got a stupid problem with the Firefox 3.
I know, that Ubuntu currently isn’t supported to run Lotus Notes on, but as my favorite OS, I tried to do it.
A nice introduction can be found here:
http://www.linuxart.de/index.php/archives/4

But there is still one problem: The Mozilla problem!
If you try to open a HTML email or open anything else, which uses the embedded SWT browser, you’ll get the message: MOZILLA_FIVE_HOME is set set to /usr/lib/xulrunner-addons, which isn’t a Firefox directory. The correct directory would be /usr/lib/xulrunner.
To fix this, I put a shell script into /etc/X11/Xsession.d/:

sudo touch /etc/X11/Xsession.d/200-mozilla-five

sudo gedit /etc/X11/Xsession.d/200-mozilla-five

Put the following code into your script:

#!/bin/bash

export MOZILLA_FIVE_HOME=/usr/lib/xulrunner

After restarting the X-server, Notes 8.0.1 will show you embedded HTML as expected.

Google Toolbar on Ubuntu Hardy Heron

2011-06-02T13:10:49Z

I love the Google Toolbar, because it allows me to use Google’s bookmark service embedded to my browser. So I can use the toolbar on a Mac, Windows or Linux machine and have my bookmarks everywhere I am.
But with the cool new version 3 of my favorite browser Firefox the toolbar stopped working. Firefox crashed after installing (and disabling compatibility test in Firefox ).
Now a new version is available and the Toolbar is back to my Firefox
But on Ubuntu there is still a problem with the bookmarks. To fix it, just type the following into your terminal:

sudo apt-get install libxul-dev libstdc++5 gcc-4.2 libstdc++6

Than reinstall the toolbar, if you allready tried without success. Now your bookmarks should work even on Ubuntu

Spring MVC Error Handling

2010-03-24T21:19:48Z

A typical problem in applications is to handle errors. In a Spring MVC based web app it is very easy, to create good error handling. A nice introduction can be found here:
http://developingdeveloper.wordpress.com/2008/02/20/handling-exceptions-in-spring-mvc-part-1/

Thanks
Josh

Things the world need

2010-03-24T21:19:39Z

I’ve just seen a nice new offer from Apple.
A realy cool feature to make your iPhone 3G complete.

Just check it out:
http://gizmodo.com/5015395/apple-introduces-iphone-3g-videoconferencing-kit-zomg

Being back in training

2010-03-24T21:19:04Z

I didn’t like sport so much, till I tried running some years ago. Now I’ve mapped my route:

Standard Laufstrecke auf einer größeren Karte anzeigen

The cool thing is, Google Maps shows you how long the route is. In this case it is about 10.43 miles or 16.78 km.
That’s a little bit more than I expected.

Grails/GWT Tutorial I – The first steps.

2010-03-24T21:15:32Z

After someone was asking for a basic tutorial and samle application for using the Grails GWT plugin on the Grails mailing list, I’ve just written one.
You can read it under http://code.google.com/p/derjanandhisblog/wiki/GWTGrailsTutorial.
It should show you, how to create a domain model, a service for RPC calls and a very basic GWT client, which calls data from the Grails app and displays it.

Hopefully I’ll find enough time to extend the tutorial and the application in the next weeks, to make it real book store

Grails is only Java EE with Spring

2011-06-02T13:08:12Z

Grails is defintivly a cool framework for developing nice Java EE web apps. you can do a lot of tasks with just one step and the rest ist automatically done by Grails.
But using your existing Java code in a Grails application is no problem. Grails is based on Spring and Groovy and thus there are some easy ways to embbed Java code to your app.

You can create a normal Grails controller or service and import your Java classes the normal way. This works pretty easy, if you’re developing your app mainly with Groovy.
If your app is allready based on Spring and thus provides allready Spring services, you can embbed’em directly and reference them in your Grails controller or services.

The second way can easyly be done, using some XML for configuration, but there is also the Groovy way to do, by using Grails’ Spring Bean Builder.
To use it, you can put some Groovy code to the PROJECT_HOME/grails-app/conf/spring/resources.groovy file.

The following code shows you an example resources.groovy file:

import com.duckmaps.server.imagerendering.services.ImageServiceImpl

beans = {
  imageService(ImageServiceImpl) {bean -> bean.scope = "session"     }
}

Here you’re seeing, that a bean with name imageService and the class ImageServiceImpl is defined. By setting the property scope to session, Spring instantiates this class for each session. It is important to put the import statement to the top. If you forget it, your code won’t work.
Referencing this bean is the same as XML declared beans. Just put a

def imageService

to your controller and Grails will inject it like a normal Grails controller.

Notes Conversation View

2010-03-24T21:14:19Z

One of the many innovations, brought to me by Gmail, is the conversation view, what means, that mails with the same subject will be shown as a conversation and thus you will get all your mails for a conversation just by scrolling your window down.
With Lotus Notes 8 IBM brought this idea into Notes. It requires at least a Lotus Domino 8 Server and an update of your mail database to the Notes 8 template. Than you can activate it by selecting conversation from the show menu at the top right corner of your mail view.
After opening a mail, you can select conversation from the display menu on top of your mail. This brings a list of all mails, which belong to the same conversation, to the top of your mail and you can open them by double clicking it. This is not as comfortable and cool like in Gmail, but you’ll get a quick way to open other mails from the conversation.
But one thing I don’t understand is this conversation list. It has a fixed size. If you’ve got just one mail in your conversation, you’ll have a big free area on top of your screen. That’s not very efficient.
On my MacBook with this small wide screen it takes a lot space, like you can see:

Firebug and Firefox 3 Beta 5

2010-03-24T21:13:25Z

After installing Firefox 3 beta 5 I had a lot of trouble with the Google Toolbar. After disabling the check for Extensions, Firefox didn’t start anymore.
Now I fixed the problem by removing Google Toolbar, but an Add-on I really need is Firebug. For web development, there is no better tool for debugging your page.
Unfortunately the current version of Firebug doesn’t support Firefox 3. But instead of the Google Toolbar it works after disabling compatibility check.
Or better it works pretty fine on my Mac and on a Windows XP machine, but it fails on my Ubuntu Hardy Heron machine, where Firefox 3 is the default browser.

Firebug on Firefox 3 RC1 (Mac OS X)

But thanks to Ubuntu team there is a great solution. You can install Firebug as a package from the Ubuntu repositories. This version of Firebug works great in Firefox 3 beta 5 in Ubuntu.

Getting started

2010-03-24T21:13:06Z

Hello and welcome to my new blog.
I hope, you’ll find some interesting things here over the time.