Multithreaded Divide and Conquer

During my time as CS student the implementation of a divide and conquer algorithm was pretty straight forward:

  1. Take an amount of objects (usually an array and usually of type integer)
  2. Select a pivot element that splits the amount in half
  3. Do some computation with the two halves. E.g. for sorting make sure that all elements greater than the pivot are contained in one half and the rest in the other.
  4. Call the algorithm recursively for the two halves.

Since then one thing changed that make it possible to speed the computation up: Multiple CPU cores that allow for multi-threading.
„Multithreaded Divide and Conquer“ weiterlesen

Setting Hudson up

One of the issues in the current development of my plug-in is better testing. If you have many different tests to run manual testing becomes difficult. Here comes automated testing into play. If you want to further the quality of your code you have to test after every change. Manually this is not possible. So I decided to use an integration server. Hudson springs to mind. The installation is easy: download the Hudson.war and then start it up with java -jar Hudson.war then you can access it over the browser at http://localhost:8080. The setting up of a project is a bit more complex. „Setting Hudson up“ weiterlesen

Eclipse plug-in manifest

The Eclipse plug-in manifest is also known as OSGi Manifest(Although the page says OSGi bundle, some of the described features are specific for Eclipse). In an earlier article I already addressed some of these issues. With this one I want revisit those and describe some more features, that I found helpful in my daily work with plug-in development. „Eclipse plug-in manifest“ weiterlesen

Createing Java Emitter Templates

There are many ways you can go about to produce your Java Emitter Template (JET). During the process of developing my plug-in I gathered some experience that might make the process of creating a JET easier.
„Createing Java Emitter Templates“ weiterlesen

Immutable Objects in a class hierarchy

I have a project that has data objects that are implemented as beans. These classes form the base of a whole class hierarchy. Reading Joshua Bloch’s book „Effective Java“ I recognised this as a bad architecture. I decided to combine different items from the book: immutable object, builders and components instead of class hierarchy.
„Immutable Objects in a class hierarchy“ weiterlesen