The websocket server implementation is pretty simple as Go already has some build-in websocket support. The server sends out the sine function with a value range from -1 to +1 to the client. The result can be seen in the following pictures and all source code be downloaded from github: https://github.com/svenlange/websocket

New value every 500ms. Alternation +0.05

New value every 5ms. Alternation +0.01

The second pictures sine curve looks a bit creepy because my computers CPU utilization was at a maximum and somehow my computer was not able to take a better screenshot. The chart was smoother on my monitor.

This setup/technology could maybe be used to visualize real-time stock exchange trends or the current bandwidth utilization in a data center etc. within a browser. Very nice.

Thanks to Gary Burd for his websocket example. It helped me to get my job done.

I stayed at the Java Dev-Room for most of the time. The speakers there were not the best presenters (cause they are real geeks) but still they gave me inspiration and I could widen my horizon by learning new stuff from them.

One nice thing was that some companies (Oracle, tarent, …) were sponsoring a dinner. The conversations with the participating Java folks were very nice. We talked a little about everything concerning IT stuff. From different hardware architectures to design patterns and political stuff.

One neat tool I have to look into is SystemTap. It enables one to do sophisticated application diagnosis on a Linux OS. For example trace down a Java method call through the JVM down to the native system call. Pretty detailed and interesting tool if one is faced with very tricky performance or functional problems.

Just use a command line tool that is lightning fast: Subversion for Windows

To checkout some source code simple type: svn co <host>

Neat top down

Neat left right

Conclusion: yUML looks nice, but is only usable for very simple diagrams.

Remove the user from cache

The Acegi plugin provides a userCache bean which can be injected automatically. With a removeUserFromCache method call on the userCache bean a user can be removed from the cache.  The next time the user is requested by the system the user will be retrieved from the database and all updates to the instance are available immediately. Following code fragment shows the described solution.

def userCache

def someAction = {
	GrailsUser user = authenticateService.principal() as GrailsUser
	userCache.removeUserFromCache(user)
}

Disable the cache

The second solution is to simply disable the cache. This should not have any impact on applications with little usage. This of cause increases the communication between your application and a database server. To disable the cache add the following line of code to the <app-root>/grails-app/conf/SecurityConfig.groovy file.

cacheUsers = false

Testing Frameworks

• Silverlight Unit Test Framework (SLUT) included in the Silverlight Toolkit
  • Code Coverage Howto
  • Tech Ed 2010 – Unit Testing in Microsoft Silverlight (Video)
  • Jeff Wilcox – Blog of the developer behind the framework
• NUnit
• MBUnit
• xUnit.net – Unit Testing for .NET
• CThru and SilverUnit
  • Unit Testing Silverlight with SilverUnit (Video)
• TestApi – a library of Test APIs
• dotCover – .NET Code Coverage Tool
• NCover – Code Coverage for .NET Developers
• White – Framework for automating rich client applications based on many different platforms
  • Seems not very mature
  • Silverlight 3 not offically supported yet as of 31 Oct 2010
• StatLight – Silverlight Testing Automation Tool
• Telerik – Automated Testing Tools for Web Application Testing (Webcast)
  • WebUI Test Studio QA Edition – $2,499 USD
  • WebUI Test Studio Developer Edition – $1,499 USD
  • WebUI Test Studio Bundle – $2,999 USD
• Telerik free WebAii Testing Framework
• silverlight-selenium
  • Too old

IDE Extensions

• ReSharper – Visual Studio productivity tool
  • AgUnit – Silverlight unit testing with ReSharper
• dotTrace – Performance and Memory Profiler
• TestDriven.Net – Zero Friction Unit Testing Add-In
• Telerik JustCode – Plug-in for Real Time Code Analysis
• Typemock Unit Testing Tools – Isolator 2010 (Test any code, …, Increase coverage)
• Red Gate .NET Developer Bundle
  • ANTS Performance Profiler Pro – Identify bottlenecks and ensure code is performing optimally
  • ANTS Memory Profiler – Find and fix memory leaks in your .NET applications
  • Exception Hunter – Locate the unhandled exceptions your method can throw
  • .NET Reflector Pro – Seamlessly debug into third-party code and assemblies, even if you don’t have the source code for them

Mocking

An interesting page about mock frameworks can be found here. One guy there is saying moq has a much cleaner API than Rhino by similar capabilities. Also the guy behind SLUT recommends moq.

• JustMock Telerik
• moq – Mocking library for .NET 3.5 and Silverlight with deep C# 3.0 integration
• Rhino Mocks – A dynamic mock object framework for the .Net platform
• Pex and Moles – Isolation and White box Unit Testing for .NET
  • Moles – Isolation framework for .NET

What I really have to look into is how concurrent programming will be done in the future on the Java platform. Brian Goetz did a really interesting talk about this topic.

Besides that I couldn’t get more inspiration from this years conference. But that is OK. Denmark is a great country and it is always a good thing to stop by. After the conference I had some time to travel up to Aalborg and Skagen and then drive back to Germany along the Danish coast side visiting Klitmøller etc.

The use case for my little example is the following: A user is offline and wants to enter some new books into a book management web application.

OK the first question that arises is: How can a client detect whether it is on- or offline? The answer is it shouldn’t be automatically and you can find a good answer to that here. So the user needs to be aware whether he is online or not and triggers a syncronisation with the web server by himself.

In HTML5 you have a client side storage where you can place stuff. It is a key/value pair storage with a maximum size of 5MB per origion. To persist an object (in my example a book) you best better use JSON. The following code snipplet shows a JavaScript function called preserve that collects all entered details for a book from an input page and places the result in the local storage. The local storage can be accessed with localStorage as you can see in line 15.

function preserve() {

	function getValueById(id) {
		return document.getElementById(id).value;
	}

	var JSONbook = {
		"title" : getValueById("title"),
		"isbn" : getValueById("isbn"),
		"author" : getValueById("author1")
	};

	var bookString = JSON.stringify(JSONbook);

	localStorage.setItem(localStorage.length + 1, bookString);
}

Due to the fact that you can only place strings into the key/value store one has to convert the JSON object into a string. This can be achivied with the help of the following free javascript stringifier/parser which I use here in line 13.

Of course localStorage.length + 1 is not a good way to generate a key, but for this experimental example it suits the needs.

So now when a user is back online and decides he wants to push all the newly created books into the database server a little Javascript like the following could do the job for him. For example by clicking on a button the persistAllBooks gets invoked. This function sequentially reads all book objects from the localStorage and calls the post_to_url function for each book. post_to_url builds up a form, fills it with the books attributes and pushes them to the server.

function persistAllBooks() {
	for (var i = 1; i <= localStorage.length; i++) {
		var item = localStorage.getItem(i);
		var parse = JSON.parse(item);
		post_to_url(parse);
	}

}

function post_to_url(params) {
	var form = document.createElement("form");
	form.setAttribute("method", "post");
	form.setAttribute("action", "/bookmngt/book/save");

	for (var key in params) {
		var hiddenField = document.createElement("input");
		hiddenField.setAttribute("type", "hidden");
		hiddenField.setAttribute("name", key);
		hiddenField.setAttribute("value", params[key]);

		form.appendChild(hiddenField);
	}

	document.body.appendChild(form);
	form.submit();
}

Thats it. Of cource the book creation page needs to be offline available to the client and HTML5 is helping here too.

Thanks to Thomas Asel for brainstorming and talking about HTML5 which led to this post.

HTML5 Resources

The following list contains some good HTML5 resources I found on the net while experimenting a little.

Dive Into HTML 5 – diveintohtml5.org
Browsers with Wings – slideshare.net/remy.sharp/browsers-with-wings
HTML5 on Wikipedia – en.wikipedia.org/wiki/HTML5
“Offline”: What does it mean and why should I care? – www.html5rocks.com/tutorials/offline/whats-offline

Here you can see youself: http://svn.terracotta.org/svn/ehcache/tags/ehcache-1.7.1/core/src/main/java/net/sf/ehcache/util/UpdateChecker.java

Fortunately you can disable this behavior by adding an Ehcache configuration to your Grails application. I have tested this with a Grails 1.2.0 application which includes Ehcache 1.7.1.

Simply place an ehcache.xml file in your <app-root>/grails-app/conf folder containing your Ehcache configuration. For this post I am using the configuration that ships with Ehcache as default (ehcache-failsafe.xml) and modify it.

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="false">

    <diskStore path="java.io.tmpdir"/>

    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="true"
            maxElementsOnDisk="10000000"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
            />

</ehcache>

With the attribute updateCheck=”false” in the root tag the haunting is gone.

XML Schema for Ehcache config can be found here: http://ehcache.org/ehcache.xsd

More Information about Ehcache configuration: http://ehcache.org/documentation/configuration.html

for /f "tokens=* delims=" %%i in ('dir /s /b /a:d *svn') do (
rd /s /q "%%i"
)

Just place the above lines into a file called removeSvn.cmd, place it into the polluted folder and then run it. Done.

Another resources on this topic:

• Recursively remove all .svn directories

• Create Domain UML 0.5 created by Al Phillips (Source code)
• Class diagram plugin 0.4.1 created by Trygve Amundsen

The application I used is a small book management app that manages a couple hundred books at my workplace.

Create Domain UML plugin

First I tried the Create Domain UML plugin. This plugin is very easy to install and actually consists only of one custom Grails  script called CreateDomainUml.groovy.

To generate the diagram the yuml.me service is used. The service is totally free according to the faq section. But still his  might be a problem for some people as they cant send any source codes of there program across the internet. Well, you could run your own yuml service by buying the software and run it on an internal server.

To install the plugin into your Grails application simply enter the following command line command.

grails install-plugin create-domain-uml

To generate a class diagram just enter:

grails create-domain-uml

Ok enough texting. Let’s see what the plugin can do for us.

Scroffy Top Down class diagram

Orderly Top Down class diagram

The plugin creates a HTML-File and puts it into the applications root folder. On the page you see four links directing to www.yuml.me. Two of them will generate a Top Down class diagram (scroffy/orderly) as you can see above and the the other two a Right Left version of the class diagram (scroffy/orderly).

Class diagram plugin

Second up to try the Class diagram plugin. This plugin is not that easy to install. First you need to download and install Graphviz. Graphviz is an open source graph visualization software licensed under the Common Public License Version 1.0.

The installation can be triggered by executing the following command line command.

grails install-plugin class-diagram

After some configuring and starting up your Grails application class diagrams can be generated by invoking http://localhost:8080/classDiagram. The result could look like the following.

Class diagram generated by Class Diagram Plugin

The plugin comes with a mass of config possibilities I had not a deep look into. There you can change the diagrams direction (TopDown/RightLeft), appearance and level of detail.

Little downsite of the plugins is that its views depend on JQuery so might look ugly without. But it is still possible to generate the desired diagram.

Conclusion

Create Domain UML is way easier to install and has fancy but not so detailed diagrams.

Class diagram plugin is not so easy to install and has a lot configs. The diagram itself does not look so nice but is more detailed.

For my docs I used Class diagram plugin although it doesn’t look so neat. For me it was more important that the diagram shows all details of the model.

Hopefully we will see some improvements to the Create Domain UML plugin, because it is easy to use and looks nice.

Windows (catalina.bat)

set JAVA_OPTS=%JAVA_OPTS% -server -Xms512M -Xmx768M -XX:MaxPermSize=128m

Grails 1.2 default PermGen memory is set to 96MB. The Sun JVMs default is 64MB. (Java HotSpot VM Options)

yast -> Software -> Software management

Then invoke following command on console.

./jdk-6u14-linux-i586-rpm.bin

Afterwards create file /etc/profile.local and add following line.

export JAVA_HOME=/usr/java/jdk1.6.0_14

That’s it.

But it was not that easy to realize my task due to the lack of good documentation and finding the correct xpath expression.

The following code snippet grabs the text value from a text input field with the id surname and saves it in the ant property xyz.

def testSomething() {
   webtest('Some description') {

      // saving initial value
      storeXPath(xpath: "id('surname')/@value", property: "xyz")

      // restore initial value
      setInputField(name: "surname", value: "#{xyz}")

   }
}

Pretty simple in the end, but it took a while till I got it. Maybe it helps someone.