Kategori: Programmering (Side 2 af 2)

This year I had the opportunity to participate in the JAOO conference sponsored by my employer, which was quite nice. I was able to join in on Tuesday and Wednesday and my plan was to follow the Performance in Modern Enterprise and Open Source Enterprise Java.

Tuesday
Tuesday’s keynote was held by Guy Steele where he presented a new programming language he’s working on at Sun, namely Fortress. Fortress is designed with parallel computing in mind which means that by default for-loops, etc. will be parallel instead of sequential. Also the language is made for scientific computation, which pretty much means maths out of my league, so I didn’t quite get the computation of vectors, etc. he talked about, since I’ve never worked with that before. Anyway, the first half of the presentation was quite interesting, but in the second half Guy went into too much details with the maths.

After the keynote I heard the first four talks on the Performance track. The highlight was definitely the talk on Performance Anti-Patterns by Kirk Pepperdine, which had a couple of interesting points and I have to say, at least some of the code I write fits all too well with these patterns. Kinda bad 🙂 Anyway, the talk inspired me which is a huge plus in my book.

The talk on The Art Of Micro-Benchmarking In Java by Angelika Langer wasn’t too exciting, but the part where she talked about the Java HotSpot VM was quite interesting and I learned a lot.

The rest of the day I switched to the Java Rich Client Development track, which meant the talks on the Google Web Toolkit by Bruce Johnson and the Echo2 framework by Tod Liebeck.
The Google Web Toolkit (GWT) is bad ass and caught my interest from the beginning and Bruce Johnson was quite good at entertaining the listeners and getting his message through. In many ways GWT is AJAX made easy, as it wrap the entire JavaScript thing in well-known Java code.
The Echo2 Framework was in many ways the same thing in a different wrapping. Unfortunately for the presentation, Tod Liebeck seemed very nervous and he had a hard time getting the message through. Still the Framework looks quite interesting, but doesn’t run quite as smooth as I would’ve expected on my machine. (I’m running the development version of Ubuntu Edgy, so perhaps it’s my own fault!)

Wednesday
On Wednesday I was supposed to followed the Open Source Enterprise Java track, but I decided to listen in on the Hot Old Ideas – Experiences Of An Old Country Programmer by Dave Thomas. Dave Thomas talked about all the various programming languages he had worked with or at least have touched in some way during his career and this was quite a few. It caught my interest and I felt like following the Back To The Future track, but I figured it would be of mostly nostalgic value, so I decided to follow the Open Source track as planned anyway.

I heard a talk on JMS and Apache ActiveMQ by Bruce Snyder and after that a talk on Spring and Patterns by Eberhard Wolff, where he talked about how Spring uses patterns. I really like working with Spring, so I had high expectations for this talk, but (obviously) I was disappointed as I didn’t really learn anything new.

Next up was Are We There Yet? by Rod Johnson. Rod talked about how Java Enterprise have progressed since 2003 to where we are today, and talked about which direction Java Enterprise could potentially go in the next years. This was interesting and gave me some insight into technologies I haven’t worked with before such as Aspect Oriented Programming (AOP) and Spring 2.0.

That was the last real talk on the Open Source track, so I decided to follow my co-workers to the Kevlin Henney talk on the Architecture Quality track. This turned out to be a great decision, since Kevlin made some really good points and did it with a sense of humor that was very entertaining.

Finally I went to the keynote panel on How Will We Be Programming in 2016?. This panel turned out to be quite entertaining as well and the listeners had a few laughs, but we didn’t really get a definite answer on the question, which was kinda expected I guess 🙂

Overall the two days at the JAOO Conference were great and I look forward to next years event.

For a project at work we need some search engine like functionality. We’ve tried to do it ourselves, but usually our implementations were too slow, too memory intensive or too much work to maintain. I was recently recommend by one of my coworkers to have a look at the Apache Lucene project, so I’ve spent the last couple of nights studying it and doing a test implementation. Coincidentially, Lucene released the 2.0.0 version in late May. 🙂

First impressions are quite impressive – Lucene is a very easy to use search engine and it’s quite fast as well. It is possible to implement a fully working search engine with only a few lines of code. To do this you need two parts – an indexer and a searcher.

The indexer can be implemented with the following lines of java code.

IndexWriter indexWriter = new IndexWriter("/tmp/index", new StandardAnalyzer(), true);
Document document = new Document();
document.add(new Field("article", "This is a sample article to test the Apache Lucene search engine", Field.Store.YES, Field.Index.TOKENIZED));
indexWriter.addDocument(document);
indexWriter.close();

These lines of code creates the index for the Lucene’s searcher. Of course the index is rather small with just one document, but it’s easy to add more fields to a document and more documents to the index.

The searcher can also be implemented with a few lines of code.

IndexReader indexReader = IndexReader.open("/tmp/index");
Searcher searcher = new IndexSearcher(indexReader);
QueryParser parser = new QueryParser("", new StandardAnalyzer());
Hits hits = searcher.search(parser.parse("sample"));
System.out.println("First hit: score " + hits.score(1) + " - " + hits.doc(1).get("article"));
indexReader.close();

This code creates a Searcher that will search the index for the search word “sample” and print the first hit to System.out. This is really all that is required to build a basic search engine. You will of course need all the glue code to make it user friendly and customize it to your needs.

All classes are from the Lucene project, so all that is required is the lucene-core-2.0.0.jar file somewhere in your classpath. Oh.. yes.. you need to catch a few exceptions as well, so the above code won’t run directly. 😉