Scribefire

Pro:

• This is a Firefox plug-in. And that is both a good and a bad thing.
• Conceptually, integrating an editor in my favorite browser looks like a winner. I’ve got all my prefered plug-ins and on-line tools right there, so this sounds like a winner.

Against:

• This is a Firefox plug-in. And that is both a good and a bad thing.
• The interface is a mess. I tested this plug-in a few years ago, but the interface doesn’t seem to have evolved much. I’m not sure if this is a technical reason (it’s build on XUL) or laziness.
• The integration really isn’t quite as I imagined. I’m not sure what I expected, but certainly a little more than a Technorati search.
• Really, the interface. Buttons are all over the place. Most elements aren’t properly aligned which gives a cluttered impression.

BlogDesk

Pro:

• BlogDesk offers a fairly intuitive one-window interface with every option you need close-by.
• An extensive image wizard, with which you can create some pretty neat effects, right out of the box. No PhotoShop needed.
• Post templates. I haven’t tested this feature yet, but this could be mighty useful if you publish a series of articles or regularly returning special features.
• It’s possible to add custom fields to a post on a WordPress blogs.

Against:

• No multi document interface. For me, this is a fairly major drawback, as I tend to work on many things at once. You can save draft posts, but they aren’t easily browsable.

Raven

Pro:

• Raven has great content management options. First, there’s a specialized explorer-like interface to quickly manage blog posts (published and drafts), links, images and tags. And secondly, you can add a number of media storage sources. I haven’t experimented with this feature yet, but it looks promising.
• Recently, Raven has been open sourced. It’s a Python application that is freely available from Google Code. The disadvantage is that the original creators no longer have time to seriously work on the application.

Against:

• There’s a pretty annoying bug where you can’t insert H2 and other header tags in the WYSIWYG editor. You can still use the XHTML editor to add them, but in a tool this good, this little blemish stands out.
• Sometimes, the interface isn’t very intuitive. For instance, if you want to schedule a post for future publishing, you need to click on the “configure” drop-down and select the appropriate tab. Not very intuitive at all.

There’s still one thing missing in all of these editors, and that is the possibility to add a thumbnail. Since version 2.9, WordPress has implemented a standardized way of adding a thumbnail to a post. Something that I solved via custom fields, but that never felt right. So I was happy to implement the thumbnails in the new design. Too bad, none of the clients support this (probably with very good reason, this isn’t exactly anything standardized).

So for now, I’m in a limbo, either set the thumbnail manually every time, or not use the thumbnail functionality at all.

But one thing is sure, typing in a proper text entry application is truly a relief from the on-line editor.

Do you have a preferred blog editor?

Recently, Keith Peters has been putting overtime into his Minimal Comps library. It’s an ActionScript 3 library that offers a large number of typical user interface components. Easily and quickly you can construct basic user interfaces in ActionScript. When Flex is a little too heavy, this is a really neat solution.

This is basically the most minimal minimal component application you’re going to see:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package 
{
	import com.bit101.components.PushButton;
	import flash.display.Sprite;
	import flash.events.Event;
	import org.flashdevelop.utils.FlashConnect
 
	public class Main extends Sprite
	{
		public function Main():void
		{
			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}
 
		private function init(e:Event = null):void
		{
			removeEventListener(Event.ADDED_TO_STAGE, init);
 
			new PushButton(this, 100, 100, "Click me", onBtnClick);
		}
 
		private function onBtnClick(e:Event):void
		{
			FlashConnect.trace("clicked");
		}
	}
}

Inspired by this minimal tutorial and written for FlashDevelop (remove the FlashConnect statements if you’re working in another editor).

BTW I wanted to give a demonstration where I integrated the YouTube data API, but it appears that none of the libraries are really up-to-date and/or well enough documented to get started in under 15 minutes. This one comes closest, but if you have a good suggestion, please let me know.

(image credit)

In the spirit of cleaning up some of my older projects, I’ve completely overhauled my little Amazon store and added an entirely new category. I know this sounds like a commercial message and yes, I will earn a small commission if you order anything, but the store is something I take seriously. I only offer things I’m absolutely sure you will like if you like this blog.

Previously, I explained the philosophy behind the store. It’s a glimpse into my private office, a look at my bookshelf and at my hard discs. I love to get an idea of the ideas behind people. I hope you’ll like this look too.

Although it wasn’t easy, I have gone over all the existing categories in my store and thrown out all the stuff that is no longer available. For instance, I really hated to remove “Grim Fandango” from the list. But I think I’ve found some very very good alternatives.

Also new is the “reading list”. It’s a mixed bag, but you’ll certainly find something you’ll like. I have tried to avoid the purely technical books, because they usually don’t remain very fresh for long.

Enjoy the shop.

(image credit)

One problem that you’ll face in practically any application, including a Vaadin-powered one, is getting hold of data or external services. Usually this functionality is put in some kind of service facade, or for instance a repository. Vaadin presents a problem in this regard, because it uses classes on both client (compiled to JavaScript) and server. You can’t (and don’t want to) execute service methods on the browser. Luckily, thanks to modern frameworks and good old Java, this turns out to be incredibly easy.

If you want to decouple service from client classes, there used to be a time when you would either go for some static factory pattern (please, don’t) or use some kind of JNDI lookup to get a hold of the service objects or repositories.  In modern times, you’re probably going for a dependency injection container (I like Spring, but the latest JEE6 beans have similar possibilities).

Using Spring, it’s as simple as defining a service in the Spring configuration and injecting it with the @Autowired annotation. With a little setup, this works perfectly in Vaadin.

I don’t think I’m telling anything new here, neither is the next part, but the combination makes for very non-intrusive, clean code.

If you start adding @Autowired annotations everywhere, you’ll soon end up with errors: Vaadin requires that any Java class is serializable. This is necessary to transmit information between the JavaScript web browser client application and the Java server code. Serialized object are sent between the two, to keep the internal states in sync.

However, many service classes won’t be serializable. A typical JPA repository will depend on an entity manager, which is not serializable.

The solution, is to mark those fields as “transient“, an often forgotten Java keyword that excludes fields from being serialized (among other things). The great thing about the @Autowired annotation is that it will inject dependencies every time a Java object is constructed. Also when it is de-serialized.

So each time the client sends an object, when it is constructed on the server, it will get autowired with your services.

It’s just that easy:

1. Mark your dependencies toward services with @Autowired.
2. Make them transient so that they don’t get serialized.

(image credit)

For a long time, I’ve maintained a guide featuring some of my favorite online radio stations. Over the last 2 year, however, it had become a bit neglected. So today, I’m proud to present the updated 2010 version of the guide. I’ve purged the defunct stations, added a few new ones. I’ve also cleaned up the layout and added a little bling. So if you haven’t checked out the guide, or even if you have, now is the time to click through.

(image credit)

Reader Nacho Coloma got me thinking. A few weeks ago he mentioned Gradle as an alternative for Maven. Now I’m not ready to throw out Maven, but the alternatives are at least interesting. Most popular alternatives have one thing in common: they shy away from XML in favor of domain specific languages (DSLs). Those DSLs are in many cases a subset of some of the more popular scripting languages.

Read on for more about Gradle, Gant, Rake, Raven and Buildr.

Gant

Groovy Ant scripting, no dependency management or extras.

If you’re still used to Ant build files and presumably doing most of the dependency management by hand, than Gant is probably a great choice for you. It hides the Ant XML that can become very unwieldy and syntax heavy in favor if more focussed Groovy.

That’s all there is to it. And that’s the attraction.

Gradle

An up-and-coming star in the build world. Groovy, Ant and Ivy combined.

Wherever you go, Gradle is on the lips of many developers. Aaron explains it a lot better, but if you like the Groovy syntax and want a little more substance to your build tool than Gant, this might be your best choice.

The result are very small, condensed build files. Reading them feels natural, most of the things I see in the documents, I can guess what it will do. I’m not sure if writing the files is just as easy (but than again, Maven is difficult both reading and writing the files)

Rake

Ruby Make

Personally, I must confess, that I found Rake the most inaccessible of the bunch of tools I describe here. I’m sure it’s not because of the documentation (there is a lot and most of it pretty clear). Even Martin Fowler seems to like it, although the linked document is fairly old.

I think it’s because Rake files are not only written in Ruby, but it’s also very focused on Ruby development. I haven’t really developed much in Ruby, so I think that’s why some of the most basic constructs look slightly outlandish to me.

I also didn’t look too deep, because if you want to use Ruby to build Java, there are better options.

Raven

Java building with Rake

As the site proclaims, this is really Rake adapted for Java building. It further combines this with Ruby Gems. At its most basic, you could compare this with Maven’s dependency management. In fact, there is an adapter available that allows you to convert a Maven repository to a Ruby Gem one.

Raven has specific tasks for Java development (javac, war, etc.) which makes it easier to use than plain Rake.

Buildr

Ruby Java building with Maven repositories

Buildr is the second Rake spin-off for Java development. For me, it has one major advantage, it uses the Maven repositories directly and also has the “Maven style” of specifying dependencies (group, artifact, version, scope). Buildr claims on the front page, it’s a drop in replacement for Maven. That is a very powerful selling point.

Buildr too is built on Rake, so it’s pure Ruby, which will take a little getting used to. However loosing the endless xml-tags is something you’ll probably get used to right-away.

Conclusion

I think I summed up the most important innovations in Java building, as always, please correct me! If you like Groovy, I’d suggest Gradle. If you prefer Ruby, go for Buildr (especially if you already have Maven repositories set up). But mind you, none of the others are bad choices, they just serve slightly different purposes than what I am currently looking for in a build tool.

Feel free to use the comments and share your personal preferences.

(image credit)

In this post, a summary of some of the most interesting posts that have appeared on this blog related to Java. There’s a bit for everyone, there’s some Maven and Android, as some good documentation resources. And something about Java applets, because, for some odd reason, I still like them.

Over the last few days, Streamhead has seen a major influx of new readers. I hereby welcome you all. There is something for every one here. Because many of you are new, I thought it might be nice to show you some of, what I consider, to be my best and most valuable posts. So you can get an idea of what you’ve missed and catch up. I’m going to do this at most once every month or two and I’ll be trying to make these posts thematic. This time, it’s all Java.

Automation

photo credit: Jeremy Brooks

Most recently, I’ve been obsessed with automation. Especially automated dependency management is a pet-peeve of mine. Most Java programs are constructed from many external libraries and those libraries in many cases also need libraries. It quickly becomes a hassle to manage this by hand.

In this regard, Maven is sort of a one-stop-shop for most Java programs. It’s most known feature is dependency management, but it can do so much more. A well configure Maven project can be fully automatically build, tested and deployed.

Two posts are of special interest here:

1. Using Maven to create a project with Spring, Vaadin and Google AppEngine. Not as easy as it might sound.
2. A Maven way to configure Seam and Facelets. Where I also mention the ugly side of Maven (hint: xml, xml and some more xml)

Something new

photo credit: DenisGiles

I’ve done a bunch of posts on the latest and greats. Still for now there is one language in particular that keeps holding my interest (I really, really should program something with it): Clojure. It’s Lisp for the Java Virtual Machine.

Next to new programming language, Java has also recently moved to mobile devices. For a second time. First there was the Java Mobile Edition, which was plagued by half-assed implementations, a scattered hardware platform and many proprietary APIs. Now there’s is Android. A Google backed, entirely free mobile development platform.

Although I think we still need to see some really good tools before Android will boom.

Something old

photo credit: toastforbrekkie

For some reason, I’ve always liked Java applets. In principle they allow you to use Java in the browser, just as you would ActionScript. That’s the principle, sadly applets have been plagued by many problems, not the least the slow startup time.

However, I believe Java applets are long overdue for a comeback. They can be used for web 2.0 business application development, but just as well for hardware 3D. Applets have had it for a long time, while Flash has only recently caught up. Check out this short tutorial on how to get started.

Documentation

And if that wasn’t enough, there’s one other incredible thing about Java: Java and the many libraries are extremely well documented. And it’s all free. Just check out the DZone Refcardz for quick reference cards that are great to keep right on your desk.

If you want to get into game development after you’ve seen the 3D, head on over to this list of prime documentation and tutorial resources. Not all Java, but it should get you started.

Enjoy! If you have suggestions for things to write on, just leave a comment or send me a message. If you like to keep up-to-date with this blog, there are a few subscription options to your right.

(image credit)

About 10 days ago, De Morgen, a Belgian (Dutch) newspaper, published the 60 best dance tracks of the last 10 years. 6 DJs and radio celebrities take their pick of what was good in the last 10 years. Unlike what you might expect, the lists where not littered with fluffy pop stuff. Most of it is quality material. Pleasantly surprised, I think this was a great idea. The only problem is that it’s quite difficult to listen to the lists as they are all embedded as separate tracks. So I’ve put them in a few YouTube playlists, which make them a lot more manageable .

6 DJs entered their choice, and here they are:

• (Please open the article to see the flash file or player.)
• (Please open the article to see the flash file or player.)
• (Please open the article to see the flash file or player.)
• (Please open the article to see the flash file or player.)
• (Please open the article to see the flash file or player.)
• (Please open the article to see the flash file or player.)

If you clicked through (come on, you know you want to try it), you will have noticed that they open in a nice JavaScript popup. Originally, I wanted to create the code to make that happen myself. jQuery with a few plugins make it possible to quickly create something like this. However, it turns out some one already did the work: the pb-embedFlash plugin for WordPress is the perfect solution if you want to embed Flash, but also other media types. With tons of options, this is really a one-stop-shop, which I hope will see continued development.

BTW Surprisingly enough, if you buy the Trentemoller chronicles, you’d already have a bunch of those tracks. It looks like there are more people that like him.

(image credit)

If you’re visiting the site, you will undoubtedly have noticed the new design. If you’re following the site via the feed or e-mail, now is a very good time to click through and check out the new incarnation of Streamhead. In this post, I go over what went in to creating the new design and what is still to come.

The new design consists of surprisingly little coding and images, thanks to some great work by other people and a little by me:

• The Thematic theme framework is an incredible useful and solid foundation to build on. Creating a child theme is child’s play and you immediately get all the good stuff of Thematic. Adapting it’s CSS is even easier. Messing with the functions was a little harder, but I didn’t need to change a lot.
• If you have a reasonably new browser, you will also notice the custom font. I tried to give my blog something unique by adding a different font. I will be evaluating this choice in about a month. In the mean time, I really love the Oregon LDO font by Luke Owens. Together with the @font-face generator, adding the font to the page was a breeze.
• I haven’t mentioned SketchUp in a while, but I used it to create the header image. I tried and liked Kerkythea to render the image. And a little Paint.NET for the finishing touches. All of those are high quality free tools that almost any one should have on their PC.

Mix all of that with a little CSS and out came the new design. I like it a lot more than the previous, but we’ll see if it stays for just as long.

As always, nothing is ever really finished, so there’s a pretty large to-do list:

• For some reason, the colors of the header don’t match in Internet Explorer (they look fine in Firefox and Chrome)
• I will be adding a few more widgets in the sidebar. I’m not sure if it was popular, but I liked the random posts.
• The posts now use the WordPress build-in thumbnail and “more” features, which means I have to go over all posts and introduce those. I’m not particularly looking forward to this task, but it will make the frontpage and category pages a lot nicer.
• I don’t like the front page, I will be adding some “themed” areas and pages with a few selected posts, which will make it easier for people to navigate the backlog of the blog.
• and probably a ton more that will popup while I’m working on the others.

So stay tuned, this blog is evolving. And let me know what you think of the new look, I’m really interested in your opinion.

In true open source spirit, I scratched my itch. No, not that itch. If you complain about open source projects, you have all the tools at your disposal to fix the problem yourself. Last week, I posted that it’s not straightforward at all to make Spring, Google AppEngine (GAE) and Vaadin work together in Eclipse. This week, I present the solution.

Update: I’ve added a necessary repository to the pom file. So if you had problems previously, please download the file again. Your issues should be solved.

download the pom.xml

It’s a fairly long Maven pom.xml file, but I believe it remains understandable and usable. Using Maven also makes it easier to integrate your project in continuous build systems and to cooperate on a project with other people. The remainder of this post discusses the details, but you can just go ahead and download the pom.xml right away.

In order to get started you should:

• Adjust the pom.xml to your liking. You probably want to change the artifact and group id’s.
• Run “mvn clean” to create a clean project with the dependencies in the right location.
• Run “mvn eclipse:eclipse” to generate the Eclipse configuration files.
• Import the project into Eclipse (or you can use the m2eclipse Maven integration if you like)
• Start programming your project. With this configuration you will be able to follow the Spring integration tutorial on the Vaadin site (including the annotation driven configuration, which is my favorite).

If you like to know a little more about what the pom.xml does, here are the various issues that are resolved by it.

photo credit: simononly

Google AppEngine

The main issue with Google AppEngine is managing the WAR structure. The Eclipse plugin for GAE cannot directly deploy a .WAR file and it needs a very rigid structure. It takes the contents of the “war” directory and deploys that. The exact directory cannot be changed, neither can the location of the dependencies. So the pom take care of:

• Java classes are compiled to /war/WEB-INF/classes
• JAR dependencies are managed in /war/WEB-INF/lib (“mvn clean” both deletes the old jar files and copies the new ones in the directory)

Eclipse project files

The second large block of code you’ll find in the pom.xml is setting up the Eclipse project files:

• Configuring the various “natures” (those are the different plugins that are enabled for the project)
• Setting up the environment with, for instance, some additional validators and builders.
• For all of this to work, you will need to have all the corresponding Eclipse plugins installed (Vaadin plugin, Spring and AspectJ)

As always, this work would not have been possible without the help of a few people. I stand on the shoulders of giants.

There are still a few to-do’s left:

• Google AppEngine has recently been update from version 1.3.0 to 1.3.1.
• Maven support inside Eclipse is not yet enabled. I think adding the “org.maven.ide.eclipse.maven2Nature” nature to the pom.xml should solve this, but I haven’t tried it out yet.

download the pom.xml

Good luck and be sure to let me know if you encounter problems or have tips.

(image credit)