Andrew Powell

Today we launched the new set of Universal Mind websites:

www.universalmind.com

and

blog.universalmind.com

Adam has gone into a great deal about the technical specifics of the new www.universalmind.com, so I will go into the technical specifics of blog.universalmind.com, since I wrote it (skin by Nahuel and Laura).

Previously, the UM Blog Aggregator had been an experiment in combining Hibernate and ColdFusion with Mach-II.  This, over time, proved to be a bit unstable, to say the least.  About a month ago, I took on the initiative to re-write the entire aggregator using Java.  Under the hood, we're still using Hibernate, but we're also using Spring and SpringMVC to manage the transactions and Hibernate sessions a bit better.  One thing you'll probably not notice, but is the coolest to me, is that the post search is now powered by Hibernate Search.  What does this mean?  Well, every time a new post is aggregated and persisted, Hibernate transparently indexes the object and makes it searchable.   It's powerful stuff.  

Anyway, I hope you enjoy the site and please give us some feedback.

I have had a Sprint Mobile Broadband card for a long time.  I love it.  It gets me online wherever I am and whenever I need it.  One thing i noticed about it when I bought it was that it has a GPS receiver in it.  Up until now, Sprint has not been very forthcoming in how to get to the GPS to use it.  Well, it turns out you need to use their Activation & Location Tool.  This app must be running if you want access to the serial port that provides the GPS data (as NMEA sentences).  While in this mode, you can also use the device as a GPS inside of Google Earth.  Sounds like this little piece of hardware would be a good candidate for Merapi......

So, first there was GPS.  Then, there was Growl integration.  The next progression is to see what we can do with other hardware.  There is a great site called Phidgets that contains a bunch of different input devices and controllers that you can hook up to your computer.  The best part of their selection is that they offer a NATIVE Java API.  So leveraging this API, we can use Merapi to broadcast RFID events into AIR.  Pretty cool stuff, if I do say so myself.  This screencast is just demo of watching for events when a RFID tag enters the sensor area and exits the sensor area, but it conveys the general point.  Enjoy and, as always, comments are welcome!

The other day, I showed you how to talk to a Garmin GPS with Flex (AIR), Java, and Merapi. Well, today I'm back to talk to you about how to leverage the Java APIs to the growl notification service via Merapi and Flex. Growl is a notification service for OS X that a lot of applications are starting to make use of these days. They have a SDK which includes Java libraries. Using Merapi, you can leverage these libraries and send true Growl notifications directly from AIR applications. Enjoy the screencast below and feel free to drop me a line in the comments if you have any questions.

So, my co-worked Adam Flater started up the Merapi Project a while back and asked me to contribute. Up until now, the only thing I've had time to contribute was the name. Well, after seeing the cool stuff that he and Jordan were doing at 360|Flex, I decided it was time to step up to the plate, get my shit together, and produce my own kick-ass Merapi demo.

Anyone who has been following the blogs knows that we at UM are real big into GIS and data visualization. Don't believe me? Take a look at SpatialKey to see what we can do with it.

I recorded a screencast where I walk you through the setups and the code of the application:

Java Code:

package com.universalmind.merapi;
import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.NoSuchPortException;
import gnu.io.PortInUseException;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import com.diddlebits.gpslib4j.GPS;
import com.diddlebits.gpslib4j.IDate;
import com.diddlebits.gpslib4j.IGPSlistener;
import com.diddlebits.gpslib4j.IPosition;
import com.diddlebits.gpslib4j.ITime;
import com.diddlebits.gpslib4j.Position;
import com.diddlebits.gpslib4j.PositionRadians;
import com.diddlebits.gpslib4j.Garmin.GarminGPS;
import merapi.Bridge;
import merapi.MerapiObject;
import merapi.messages.Message;
public class GPSReader extends MerapiObject implements IGPSlistener{
   GPS gps;      
   Position position = null;
   IPosition current = null;
   BufferedInputStream input;
   BufferedOutputStream output;
   
   public Bridge bridge;
   
   public static void main( String[] args )
   {
      
      new GPSReader();
   }
   
   public GPSReader()
   {
      super();
      
      bridge = Bridge.getInstance();
      
      CommPort port;
      
      try {
         port = CommPortIdentifier.getPortIdentifier("/dev/tty.USA19H1d1P1.1").open("GPSReader", 3000);
      } catch (NoSuchPortException e) {
         System.out.println("/dev/tty.USA19H1d1P1.1 not found!");
         return;
      } catch (PortInUseException e) {
         System.out.println("Port already in use by " + e.currentOwner);
         return;
      }
      
      try {
         input = new BufferedInputStream(port.getInputStream());
         output = new BufferedOutputStream(port.getOutputStream());         
      } catch (IOException e) {
         System.out.println("Error opening /dev/tty.USA19H1d1P1.1");
         return;
      }      
            
      gps = new GarminGPS(input, output);
      gps.setAutoTransmit(true);
      gps.addGPSlistener(this);
      
   }
   
public double getLat() {return __lat;}
   public void setLat(double lat) {
      this.__lat = lat;
   }
   public double getLon() {return __lon;}
   public void setLon(double lon) {
      this.__lon = lon;
   }
   public String getTime() {return __time;}
   public void setTime(String time) {
      this.__time = time;
   }
   public String getDate() {return __date;}
   public void setDate(String date) {
      this.__date = date;
   }
   
   public void dateReceived(IDate d) {
      String dateString = d.getMonth() + "/" + d.getDay() + "/" + d.getYear();
      System.out.println(dateString);
      this.setDate(dateString);
   }
   public void positionReceived(IPosition pos) {
      current = pos;
      this.setLat(toDecimalDegrees(current.getLatitude()));
      this.setLon(toDecimalDegrees(current.getLongitude()));
      Message message = new Message();
      GPSPoint point = new GPSPoint();
      point.lat = this.getLat();
      point.lon = this.getLon();
      point.date = this.getDate();
      point.time = this.getTime();
      message.setData(point);
      try {
         bridge.sendMessage(message);
      } catch (Exception e) {
         
         System.out.println(e.getMessage());
      }
      
   }
   public void timeReceived(ITime t) {
      String timeString = t.getHours() + ":" + t.getMinutes() + ":" + t.getSeconds();
      this.setTime(timeString);
      System.out.println(timeString);
   }
   
   private double toDecimalDegrees(PositionRadians rads){
      return Math.toDegrees(rads.getRadians());
   }
   
   private double __lat = 0;
private double __lon = 0;
private String __time = "";
private String   __date = "";
}

Excited about BlazeDS, but not really sure what it means for you?  Are you a Java developer coming to Flex who wants to learn how to connect your services to Flex?  Want to see a new spin on the ubiquitous chat application?  Come to my 360|Flex session, Implementing BlazeDS, and you'll get all that and more.  This session is the first of a three-part "Flex/Java Track" that you will get at 360|Flex.  Major topics covered will be:  Remote Objects, Messaging, Integrating Spring & Hibernate, & Binary Remoting without BlazeDS.  Stop on by Monday at 4:00PM if you're interested in learning more.

Hibernate Search is an addition to the powerful ORM, Hibernate, that allows you to perform full text searches against your domain model.  Under the hood, it's powered by Apache Lucene.  How does it work?  Well, Hibernate Search is smart enough to index your objects as you insert and update your data.  On a delete, it will remove the data from the index.  All this happens transparently.      

There are a few requirements, first is JDK 5, the second is the Hibernate core.  All configuration for Hibernate Search is done via annotations ( I think this is where all the Hibernate config is heading ), so there's no need for lines and lines of XML configs.

Go download it, give it a try and see what you can do with full-text searching of your domain model.

Until recently, I've always used the XML mapping files to define my persistence model with Hibernate. I was not real keen on the idea of using meta to define persistence in the objects themselves via annotations. However, I decided to give it a shot recently. My main argument had always been that by using the XML mapping, my persistent objects are not tied to Hibernate, exclusively. When I stopped to think about it though, one thought really hit me hard: I don't use any other ORM for my Java code. Why would it matter if the meta for mappings is in the code?

This being said, I wanted to pose a question: Is there a benefit to using annotations over XML mapping (other than JVM compatibility)? Your thoughts in the comments, please.

IntelliJ IDEA, the most kick-ass Java IDE available, is now out and better than ever.  The main thing about 7.0.4 is that it now has great support for Ruby/JRuby.  This means that, essentially, IntelliJ is a viable Ruby IDE now, as well as a Java IDE.  It's also got some support for Flex, but it's not quite ready for prime time yet, IMO.

What's new in 7.0.4

The other day I heard someone define iTunes as a RIA. I started to correct them because, until then, I had only thought of RIAs as being built with AJAX, Flex, Silverlight, etc; with these new RIA technologies. That comment though, got me to thinking. What does really define a RIA? Is it the technology that is used to build the application or how it leverages the power of the Internet (via SOA, etc.)?

After a bit of consideration, I have to say that an RIA is any application that leverages the power of the Internet to enhance the application. An RIA is not simply an AIR application, a Flex application, an AJAX application, or a Silverlight application. Any application that uses the internet to leverage new user experiences is a RIA.

So, that being said, iTunes is probably one of the best examples of an RIA out there. It changed the game when it came to music applications, adding the ability to subscribe to podcasts, share your library, listen to Internet Radio broadcasts, and the iTunes store itself transformed iTunes into the most ubiquitous and indispensable RIA we've seen yet. All that and it wasn't even built in Flex, AJAX, OpenLazlo, Curl, or Silverlight. It was built in Objective-C.

In the coming months and years as we see RIAs and the influence of SOA proliferate through ordinary desktop applications, we're going to have to take a long hard look at how we, as a community, define a RIA. I think we're heading towards a point where we really do define a RIA as any application, regardless of the development language, that leverages the Internet to deliver new user experiences to the end user. In the end, it would seem, we are all RIA developers.