Interesting & Frustrating Software Developments

Reflections on (Java) reflection - isn't there another way?

2011-03-04T10:24:00.000-08:00

In general, I am suspicious when I see much use of reflection - especially when creating objects or accessing fields. It sure seems that there ought to be a better way with a proper object hierarchy.

In any case, I came across an interesting use case. In this GUI application, the requirement is to create only one window of any given type. So the class is passed into a window manager class. It looks up in its table to see if one has been created and if not, creates one. It does this by being passed the class of the window to create and uses reflection to instantiate it.

There are a couple valid justifications for this:

you would like the window management encapsulated in one class.
you would like to not instantiate one if one already exists. Using reflection enables this without having to resort to multiple method calls (although it wouldn't be the end of the world).

The other option would be for every window class to implement a singleton pattern.

Isn't there another way?

In fact, the benefits of Scala come to mind. All you would need is to pass a bit of code to the window manager which it would execute to create the window in lieu of finding the constructor from reflection on the class definition.

Or, in JDK 7 terms, pass in a closure (from what I've heard of the various proposals).

One could also emulate this with a one-method interface. Having written all this, it seems it might be useful for each window to implement a singleton pattern, especially if there are various places where the window is being created. But, that might be a bad sign in its own right.

BTW - why do I not like reflection? Primarily because I tend to use the "Find References" feature of my IDE-of-the-project. And it doesn't catch uses of reflection. (N.B. does FindBugs?)

Of JTables and ScrollPanes

2011-03-04T10:01:00.000-08:00

While working on a Swing app today, I came across some interesting code where a class named RowHeader extended JTable. WTF? In looking at it more closely, it seemed - aha! - they're creating a table to serve as the row header in the JScrollPane. Makes sense - that way when the table is the viewport of the scroll pane, the column headers don't scroll with the table... just what you want. I need to do that everywhere.
But wait - it already does that. How do it know? My tables don't do that, yet the scroll pane knows to put the row header outside the scroll view port. Even the simple example here doesn't do anything special to accomplish this task. I browsed through a bit of the source code to JScrollPane, it must be looking for a JTable instance, but I don't see where right off hand.
So I suspect this is relatively new functionality and the "legacy" code was doing the same thing before Swing did it automatically.

Now, to just get the sorting to show...

GUI Development

2010-08-19T13:32:00.000-07:00

A review of implementation and deployment strategies for GUI applications

The overall GUI implementation space:

Desktop

more secure due to limited access, not using well-known ports
easier implementation of advanced UI interactivity features
requires installation (unless using WebStart; see below)
possible to distribute load: business logic components run locally, no web browser required (see architecture drawings)
more control over context (i.e. no browser compatibility issues, no platform issues if Windows-only)
implementation platforms:

Sun/Oracle Java Virtual Machine (JVM) based

Java/Swing
Scala/Swing
JavaFX (Sun/Oracle alternative to Flex)
Groovy/Griffon/Swing (Rails-like framework for Swing)

Microsoft .Net-based: any CLI language
Adobe AIR-based: Flash or Flex

(Visual issues between these are addressed below.)

Non-browser based Web App (Java Web Start)

requires web server for initial installation
subsequent executions local
crosses lines between Applet (in-browser app) and Application (desktop)
implementation is Swing or JavaFX
full interactivity as in desktop app
could use heavy-weight client to integrate portions of backend
use light-weight client calling a higher-level API on web server
Ref: http://www.oracle.com/technetwork/java/javase/architecture-138566.html

Browser-based Web App - with Plugin

offers rich interactivity, near desktop
avoids browser issues
requires web server for download
could distribute load by running business logic in client (JVM plugin), or use higher-level API on web server
implementation platforms:

Microsoft Silverlight: zillions of CLI languages
Adobe Flash: Flash or Flex
JVM: any jvm language supporting Swing

Browser-based Web App - no plugin

generally less rich interactivity
AJAX for partial updating
Comet for server-push

Web App, no plugin - JVM-generation of pages

requires app server with business-logic code
relying on framework provided client-side interaction (JavaScript)
implementation platforms:

Java/JSP (Struts, etc.)
Java/JSF
Scala/Lift - what we have now
Scala/Other (See Appendix A)

Browser-based Web App - no plugin, “stand alone” pages

requires web server supporting a high-level API (e.g. a REST API)
requires larger code base in JavaScript, either:

hand coded: optionally with framework such as jQuery and its plugin family
generated: as in via Google Web Toolkit (GWT) Code in Java, compile to JavaScript

Visual Issues

Desktop

JVM - Swing: traditional ‘native’ widget/form applications with roughly the same appearance
JVM - JavaFX: much more graphic design
.Net - native Windows L&F
AIR - Flash or Flex components

Web Apps with plugins essentially look like desktop apps

Web Apps - without plugins

jQuery - http://plugins.jquery.com/
GWT: http://advanced-gwt.sourceforge.net/demo/index.html and http://code.google.com/apis/visualization/documentation/gallery/gauge.html
HTML5: http://html5gallery.com/ [N.B. there browser issues here - as in partial I.E. support]

Alternative Dimensions

App server vs. web server

The top, left box is a more traditional Swing application. The web server would not be an app server, meaning it would not need to run a JVM. It exists primarily to deliver the applet and its jar files.

App server with page generator (like JSP or equivalent)

In this scenario, the web pages are generated from templates and values are filled in by querying the backend business logic at page generation time. The JavaScript code in the page manages the AJAX calls to update the pages.

App server with no web framework

In this scenario, the web pages are not generated from templates and in that sense are ‘static’. The page values are filled in by querying the backend business logic at page rendering time. The JavaScript code in the page manages the AJAX calls to update the pages, but the knowledge of the page structure is not known by the server. All clients use a “simplified” API such as the REST API outlined below. No internals of the back-end system are exposed, just the data model.

Conclusions and recommendations

The app server with no web framework is clearly the most flexible architecture. The API is simple and a variety of clients support it. For that reason, many applications are moving to this type of implementation. This architecture achieves greater separation of concerns in that the server has no knowledge of the client. It is straightforward to implement the server-side and requires much less code, therefore putting less load on its host. This architecture does not limit the client-side implementation, although it may require a team member who knows JavaScript.

None of these solutions are an order of magnitude better or worse than any other. Any of the outlined implementation plans could work. Each optimizes a different combination of platform support, skills usage, visual and design sophistication, etc.

Misc Issues

Authentication

To accomplish userid and password authentication in a REST-world, you would pass userid and password via an https request to an API which would validate them and return an authorization token for future API calls.

Appendix A. - Scala Web Frameworks

Lift

Lift has been under development since 2007 (http://liftweb.net/team.html) and is used by such large sites as foursquare.com (http://www.scala-lang.org/node/5130)

Cons: mentioned above

Pros: provided support for Ajax, Comet, client-side graphs (Flot)

SSP (Scala Server Pages):

More basic framework; may avoid server-side memory issues, would have to roll our own support for Ajax, Comet.

Pinky: REST/MVC glue web framework built on top of Guice and Guice Servlet 2.0.

Appendix B - REST API

A REST-notation API passes all arguments in a URL call over HTTP. The result is returned generally in XML or JavaScript Object Notation (JSON). A domain model which is hierarchic is easily supported and mapped to a set of URL calls.

Additional Background Notes:

Scala has been under development and in use since 2001 (http://www.scala-lang.org/node/25)

REST and JSON is an evolving area of development.. c.f. http://asserttrue.blogspot.com/2010/08/jsop-idea-whose-time-has-come.html

Google Data API, Google App Engine and Scala/Lift

2009-12-25T21:23:00.000-08:00

Recently I decided to bite off this chunk of coding. What followed really emphasized and reinforced the title of this blog. It was quite frustrating at times, frequently interesting and in the end, rewarding. I did finally get most everything to work, so here are my notes...

The objective of the particular web site I did was to have the user enter a handful of values via the web page, run a model calculation based on those values and display the results. Prior to my involvement, my colleague had done all the modeling in Excel and VB. His next step was to export the data to XML files and re-code the calculations in Java.

My first step was to make the site run with Scala and Lift and let the Java code read the XML files. No problem.

Step 2: host the app somewhere. I had read a lot about Google App Engine (GAE) and knew people who had good luck with it. Great idea.

First roadblock: I had read GAE doesn't support static data files, but that's no problem there's the GData API, and all these XML files came from spreadsheets anyway, so how hard could it be?

First sidetrack: instead of reading static files and short of migrating to the GData API, it seemed I should be able to read XML files from the Jar files: ClassLoader.getResource("xmlfile_name"). I spent many hours and never did get this to work!

At this point it became clear - the GAE support for Java seems to be WAY behind the Python support/documentation/functionality/etc.

GoogleData API
It seems there are several variations on this, but the REST API model seems to be quite adequate. There are however a handful of glitchs/gotchas it seems.

1) I created a user which had only view authority on a spreadsheet. Unfortunately, it could *not* read that spreadsheet with the REST api.
2) Everything comes back as a string. This is not too bad, but it seems a more "robust" API would provide a bit more flexibility.
3) The column headings are used as the key to a map of the values in each row. This is a decent strategy, however I would like access to the actual value in the header, not the munged value used in the key. Again, not a complete deal-killer.

Google App Engine
I did get everything running just fine with the Gdata api within those constraints. Now it was time to deploy. I had read several people deployed with no problem and sure enough, there are a handful of apps running with Scala/Lift.

Would mine deploy? Of course not. It generated a couple stack traces indicating problems in the LiftFilter, but seemingly in the configuration of the logging. Might that be just a 'warning'? You would think so, but NO. What the heck? Well, 5 combo boxes aren't that big a deal, so I rewrote them in JSPs and it deployed just fine. As always, appetite grows while dining and the client wanted the drop downs to repopulate based on certain selections. No problem - but wait! That was why I wanted to use Lift in the first place! Ack. The long and the short of it was all I had to do was get a more recent version of Lift (specifically 1.1-SNAPSHOT), and it deployed just fine!

Miscellaneous Glitches
Because it is a proprietary application, I set the security of the main site to be limited to the registered users of a domain I had authorized in Google Apps. This works quite well - the user is redirected to a login page, then to the web site. Cool. Now I added a page to allow an admin user to reload the app. The documentation describes a really easy way to do that. The fine print I didn't digest the first time around is that the members in the admin role are those users defined as admins of the application. Oops. I'm the admin of the application and I created it from my main Google account which is NOT in the aforementioned domain. Oh, I can add admins, so email has been sent inviting another user I created in that domain. Now, where did that email go?

Pleasant Surprise
All the while I was developing the app, I was wondering about releasing new versions after it was in production. I only uploaded code a couple times before I encountered the concept that GAE has the idea of versions of your application. Several versions can be stored on the server and run independently and simultaneously! Well done, GOOG.

Bottom line: Google App Engine and GData API are a good way to go. Better if you're using Python, which is not a bad choice. I just have a lot of legacy Java code, so I'm really liking Scala and Lift. Now I know, those are GAE-compatible also, so life is good.

Another Reason to look at Scala for GUI

2009-11-04T07:49:00.000-08:00

It's just a simple thing - a form GUI to edit domain objects stored in XML. We even have a schema to describe those docs pretty well. Certain tags have one of a pre-defined list of values ("restriction" in XML schema terms). To edit this, a drop-down list is a very handy thing. How would you populate that? Well an enum sure looks like an attractive thing and these days in Java, enums have come a long way so that you can give the enum a handful of properties.

So I copied each set of restricted values out of the XSD file into a Java file and created enums - dandy! The first small problem we created for ourselves is that the restricted values have dashes. Gosh, as enum identifiers dashes look a whole lot like minus signs. So now I have to map the XML value to the enum value somehow.


    enum SensorType {
      accelerator,
      altimeter
    }

But it's very easy to populate the combo box:

inputSensorCombo.setModel(new DefaultComboBoxModel(SensorType.values()));

So I have to add the mapper, but while I'm at it I would like to have a different
display value in the combo box that has blanks!

Still not a big problem - create the enum class with a display value and XML tag value:


enum SensorType {
    accelerator("Accelerator", "accelerator"),
    altimiter("Altimiter", "altimiter");
    final String displayValue;
    final String xmlTagValue;
    SensorType(String displayValue, String xmlTagValue) {
       this.displayValue = displayValue;
       this.xmlTagValue = xmlTagValue
    }
    @Override
    public String toString() {
       return displayValue;
    }
}

With the toString override, populating the combo box is still the same. Pretty good, yeah? Now, I have about 4 of those. We're OO so just make a base class, right? Sorry. As 'syntactic sugar' enum already extends Enum, so we're SOL.

Bummer. Let's try Scala.... next post.

Do developers know branding?

2009-08-11T08:41:00.000-07:00

I think we learn branding or marketing "spin" at an early age. Here's an amusing post in Toni Epple's blog showing he clearly has: "122 Platform Exercises New & Free - First-come, first-served!"

The evolution of SCM or Why I would like any teams I'm on to use Git

2009-05-23T16:50:00.000-07:00

Back in the olden days of Source Code Management (SCM) there was SCCS and the original Unix things. These depended on developers checking out code with a LOCK. Because, after all, if you didn't have a lock and you changed things, badness would follow.

Well, then along came CVS and out went the idea of locking. Why? Merging became easy - in fact CVS would do it for you. Ok sure, sometimes there are conflicts and you have to merge yourself... but in fact, this is rare (at least for small to medium teams I've been on).

So then we upgraded to Subversion - not really substantially different than CVS - still lock-free central repository.

In this world (at least on the projects I've been on) you always check in against the trunk - i.e. the main line of code. Branching the code is still icky and to be avoided.

Now, along comes Git. (N.B. this discussion may apply to Mercurial also, i have no experience with that, but I know it's popular in many Java (i.e. Snoracle) circles). I don't have tons of experience with Git yet, and I may have forgotten the wonderful things the guys from Everlater.com came over to @iVolunteer to teach us (http://tr.im/gitevrl8r) - BUT I'm convinced of the Git-goodness!

There are two basic revolutionary aspects to it, from what I can tell:
1) no central repository. In some sense you use convention over configuration to determine who has the "central repository". Yes, you need to take backups somewhere. Yes, you need to figure out which repository to check out from for doing a build. However, the good news is that this can be *anybody* "in the network". Because everybody has a copy of the whole history (more or less), *anybody* can do the build.
2) local repository. This means several things, not the least of which is that if you're developing code you can check in locally and not break the build. How does that work? You have the whole repository. But what about everybody else's code? You have all the history you've requested from them. If you haven't "pulled" from their local repository, yes, you're hosed. So pull it and then do a build. Or have them pull from you and do a build - it just doesn't matter - and that's the beauty of it. So just as CVS got rid of the notion of merging being hard, Git gets rid of the notion that branching is hard.

Variations on a theme:
- sure, it's nice to have a publicly accessible, backed up, repository. That's where Github comes in (and presumably whereever you want to install the equivalent. But wait, doesn't that make it just like SVN? Well, ok - yes, to some degree.
- there is much finer granularity of changes. because you can check in locally, and then I can pull from you, I can't get changes from someone that I might want to integrate with before (possilby) screwing up the whole thing.
- and even finer, (this may be a GitX thing) you can check in just *some* changes to a file. I had occasion where I changed a properties file (IIRC) and wanted to check in the new properties, but NOT the hard coded path to my specific files. I checked in just some of the changes to the file - sweet.

now back to figuring out how to update and check in...

It's TOO great a time to be a geek!

2009-04-13T10:40:00.001-07:00

... especially if you can't decide what to do first. I was about to Tweet:

STILL looking 4 desktop or web client that shows msg thread: TweetDeck- click on "in reply to" Nambu shows *future* replies. Huh?

Last time I whined about that or similar, the reply I got (you know who you are!) was why not do one (write a client) yourself? OK, OK - i will. But that's the problem: I'm taking the Stanford class on iPhone development (http://www.stanford.edu/class/cs193p/cgi-bin/index.php), where a big homework assignment is to write a Twitter client, but that's 4 weeks starting 4/20.

But, wait - Dave Briccetti published a cool sample app showing how to do this in Scala (http://briccetti.blogspot.com/2009/03/simple-twitter-client-bay-area-scala.html)

And of course, there's the JavaFX version - TwitterFX (http://kenai.com/projects/twitterfx)

But that's after the iVolunteer project I signed up to help, and my day job!

Bottom line: Less Twitter *reading* and more Twitter *doing*!

Java WebStart success?

2009-01-27T09:19:00.000-08:00

Just maybe, I'm on the verge of success gaining the Holy Grail: automatic continuous integration of a Java WebStart application! What are the pieces?

Maven and Ant
Artifactory
Hudson
Jetty
JNLP servlet

Whew! Some details on each piece...

Ant and Maven
I like Maven for the convention it brings (as in Convention over Configuration). The repositories and versioning of dependencies are wonderful. The bad news is that a WebStart application isn't the traditional JAR or WAR build that Maven knows about. (N.B. - I may come back to this, since using the JNLP servlet, it *could* be a WAR file.) The good news would seem to be that of course, there a couple plugins that do neat WebStart things - including building the JNLP file from the dependencies. You know, DRY! The first one from CodeCrate offers great promise - handle the simple case! Cool. Well, it's a fail straightaway since it can't seem to find the dependencies at all and gets a ClassNotFoundExeception. Bummer. So I go for the full Monty - Maven Webstart Plugin . There's a "cookbook recipe" which shows a "Getting started" page. But no examples for the simple case - they go straight to WAR bundles. :( And the Maven jar signing plugin will only sign the main artifact - not all the dependencies. Double fail.
Ant to the rescue! Fortunately, Ant knows how to sign jars and Hudson will run multiple steps in the build, so it is easy to mix Ant and Maven. Ant will sign the dependency jars and Maven will build the rest of the project. The only loss is not generating the JNLP from the dependencies.

Artifactory, Hudson and Jetty
Both of these are handy web-based tools. Each is easy to install and configure - UNLESS you want password protection. My first thought is to bundle both into a Tomcat instance. Should be easy enough - both give instructions on that. Password protecting Tomcat sites should be easy enough. OK, start with Artifactory. Endless headaches, fails, NullPointerException, etc. Finally come across a suggestion to never use pre-installed Tomcat instances on Linux boxes. Oh! OK - download and install Tomcat 6.0.18 - works great! The password protection works. Now, just have to add the Hudson webapp. FAIL - OutOfMemoryError out the gazoo. Having used Jetty before with good success, I revert to separate Jetty installations - one for Artifactory, one for Hudson. Even with password protection!

JNLP Servlet
Providing links to a JNLP file and having it link all its resources works fine. Just one problem: the JNLP has the codebase in it, so at build/deploy time you have to know where you're deploying to. A bit of a problem if you want to build and deploy to a test server, then promote to production. But wait, the JNLP Servlet to the rescue: it filters the JNLP and drops in the proper codebase for you. Nice! Now let's see - where's the JNLP servlet?
The JnlpDownloadServeltGuide from the Sun JavaSE 6 TechNotes says: "The servlet is packaged into the jnlp-servlet.jar file, which can be found in the SDK under samples/jnlp/servlet/" OK - I've got lots of JDK/JRE installations.
find /usr/java -name samples
Nothing. Hmm... Oh, update 11 is out - let's download that. And there's a nice document in the Java Web Start Reference pages called "Packaging JNLP Applications in a Web Archive" - sweet. That's interesting, there's a "sample" directory in this JDK. Oh, even a "jnlp" directory under that. Cool - cooking with gas now. Follow all the instructions about deploying, etc. FAIL - java.lang.ClassNotFoundException: com.sun.javaws.servlet.JnlpDownloadServlet
WTF?
jar -tvf WEB-INF/lib/jnlp-servlet.jar
Oh look! All of them are "jnlp.sample" package, not "com.sun.javaws"! Thanks a lot. So change the servlet definition in the web.xml. Finally - success!

The only remaining piece is to have Maven or Ant copy the proper files to the Jetty webapp directory. How hard can that be?

Why Swing UIs are so hard...

2008-11-11T08:18:00.000-08:00

I'll tell you why - ok, well at least with issue I'm having now, which seems to be a common issue - LAYOUT.

How do you nicely lay out components? I've been reasonably happy with the layout tools NetBeans puts in for you. But I have a main window with 9 sub-panels, almost like portlets. Not all are the same size - and I want to have the user re-size them. Splitters? No, not the JSplitPane - too much overhead, can only split 2 sides. Enter the MultiSplitPane from SwingLabs - quite nice! An arbitrary grid layout even with custom split bars. BUT - how to specify a nice division. Well it provides "weight" - that's where the extra space goes. But what about the initial size? It uses each component's "preferred size" - seems like a good idea. But how do the components set their preferred size? This gets to the basic issue:

Layout - Bottom up or top down?
I attempted to have a component (tree control) set its preferred size based on the text and font it is assigned. Seems like a fine idea with good control, precision, etc. Nope! NullPointerException - the graphics aren't assigned at constructor time. Put in nice code:
String name = net.name;
FontRenderContext frc = ((Graphics2D)this.getGraphics()).getFontRenderContext();
TextLayout tl = new TextLayout(name, networkTree.getFont(), frc);
setPreferredSize(new Dimension((int)(tl.getBounds().getWidth()*1.5), 0));

NullPointerException at the line with getGraphics.

Top down...
Seems like Swing should learn from HTML/CSS - why can't a table support column widths in percentages? Seems like a simple enough thing - so I'm off to try banging that into MultiSplitPane.

Better Swing through dynamic JVM languages...

2008-10-09T10:32:00.000-07:00

The holy grail (?) - applying lessons learned in Web App development to Swing/desktop development. We have Python, Ruby, Groovy and now Scala on the JVM. Shouldn't they bring something to the party in terms of making my life easier to make Swing apps - which is still very tedious.

A couple good news items on this front-
Griffon for Groovy - This project shows some great promise! I hadn't been a big Groovy fan mostly because if it looks so much like Java, why not use Java? But then I realize a large impediment to starting up with Python or Ruby or Scala is the learning curve. On closer examination, it seems perhaps Groovy gets the benefits of a dynamic language while still in the overall "framework" of Java. That would be nice. One might say, 'but without the "buzz" it won't get the vast libraries of Python' - true, except for the extent to which it can just use the vast array of Java libraries. Is there an impedance mismatch? Don't know.

Monkeybars for JRuby - I just came across this project yesterday. (See http://groups.google.com/group/monkeybars) It seems to have a lot of the right objectives. The interesting thing is that there is no Ruby API for Swing components - you do the actual Swing components in a Java class and the Ruby code introspects the bytecode to manipulate stuff. Well, plausible I guess.

But interestingly, I've still not come across any Python-Swing or Scala-Swing toolkit/frameworks.

Singletons gone bad - again

2008-10-09T10:20:00.000-07:00

I've been successful at using the swing framework, org.jdesktop.application classes in particular. I have a handful of applications sharing a rather large code base. Now however, of course we want to launch application B from application A. It actually works, but the problem is now that the Application singleton became B instead of A and when the objects in the A application go to use their resource map or action map, the get application B which of course isn't an A, so ClassCastException results. Ugh.

Option A: don't use ResourceMap and ActionMap.
I've already headed in this direction because of NetBeans' issues around keeping track of which class is the true application when it is generating code - so that wouldn't be all bad.

Option B: create one master application perhaps deriving from a new class MultipleFrameApplication extended from SingleFrameApplication. It would know how to create a new JFrame, etc. Arguments could be passed in to specify which "real" application to run - which in this case would mean which view to show first.

Option C: pass application A to the new view for application B. But somewhere we need a new JFrame, etc.

I have a related issue in that my model and helper (controller?) classes have common base classes and the models are singletons. So when application B launches, I'm not sure I want a whole new B model which would replicate the base classes of model A.

Hmm...

NetBeans (6.1) lost my code!

2008-05-06T10:20:00.000-07:00

Things were going so well... I had created a Java Desktop application, got a desktop pane going, a dialog and an internal pane. It was now time to take a step back, refactor a little and etc.

I renamed my project, created a project group and BOOM! No more code. After a day or so reading about various frameworks, etc. and figuring out NetBeans 6.1 I got the program running in about an afternoon. Now I have nothing.
And now I have to Join Netbeans.org to post a message about this. Forget about it! My joining wiki.netbeans.org apparently wasn't good enough. My subscription to nbannounce was not good enough. FUGGET ABOUTIT!

The GUI builder was fairly good - but I'm going back to IntelliJ.

Frustrating: GWT InvocationException

2007-11-06T11:57:00.001-08:00

I am having some success with GWT - but here's one that took me a couple hours to figure out. I created an asynchronous RPC service. Pretty much straight from the "book". Wouldn't work - wouldn't work. Tore everything back to the bare bones. (OK - the service was taking a user-defined class as an argument and returning a list.) I changed it to take a String and return a String. Still always got the InvocationException - with no cause. Finally also ripped the RemoteServiceServlet back to the basics -- did I mention I implemented the init and service methods to allow setting up other stuff I needed? Lo and behold it started working! Doh!
In the simple minded version I originally wrote it wasn't going to actually service anything, just initialize. By calling super.service(request, response) things went much better. Sometimes it IS just the simple problems.

Interesting: IntelliJ

2007-11-06T11:54:00.000-08:00

My IDE travels have taken me back to IntelliJ for a tour with the EAP version of IntelliJ 7.0. So far - very nice! Great Maven integration. Great GWT integration! Only locked up on me once - I had three projects open and went to debug one of them.

Frustrating: Java on Mac OSX

2007-11-05T12:52:00.000-08:00

As you probably know, Leopard came out recently. Lots of us have been waiting to upgrade. But it turns out that one of the things *NOT* coming in Leopard is Java 6! Java 6 has been out for other platforms for quite a while. Apple used to be way behind, then caught up, but now is dropping behind again! I got a note from another news group that there is a grass-roots movement going on to demonstrate to Apple that there is a LOT of interest in this. It is in that spirit that I post this secret message to Apple: 13949712720901ForOSX.

More Frustrating: Eclipse

2007-11-01T15:31:00.000-07:00

Why does a "Dynamic Web Project" require javax.persistence? And it seems, therefore can't be deployed to the HTTP Preview (which is Jetty under the covers, right?)? And what is different between HTTP Preview and HTTP Server?

Only two facets are defined on the project: "Dynamic Web Project" and "Java", neither of which it will let me remove. I really *don't * want persistence...

Interesting: Why's (Poignant) Guide to Ruby

2007-11-01T09:19:00.000-07:00

If you're interested in languages, learning languages, or Ruby - you have to check this out.
http://www.poignantguide.net/ruby/

Frustrating: Subversion / Interesting: Bash

2007-11-01T09:03:00.000-07:00

So in the process of messing around with IDEs, I used NetBeans (most likely) to check out my project from Subversion. No problem - I edit my code, actually get my JSP page to work. Let me check it in and deploy! We're sorry - you can't check that in - Permission Denied. We're using svn+ssh protocol and the remote user is wrong - it is my local userid which is not the remote userid. Ok, how could that happen? And what to do?

Turns out the URL is stored in .svn/entries - just have to edit it. Sed to the rescue.
> find . -name entries -exec sed /host/s//user@host/ {} > {} \;
Ran fine - no change. All 'entries' files are read-only.
> find . -name entries -exec chmod u+w {} \;
Re-run sed. No change. Redirect is going somewhere else. Seem the second brace pair is not replaced with the file name. So put the sed command into a script. ~/bin/runsed.sh:
sed /host/s//user@host/ $1 > $1
Ok, let me try this on one file...
> ~/bin/runsed.sh src/main/java/.svn/entries
> ls -l src/main/java/.svn/entries
rw-r--r-- 0 entries
Zero!?? Oops. Change runsed.sh:
sed /host/s//user@host/ $1 > $1.fix
Re-run fine:
> find . -name entries -exec ~/bin/runsed.sh {} \;
Now I just have all these entries.fix files. Let's get rid of the old ones:
> find . -name entries -exec rm -f {} \;
Hmm... now if the curly braces only expand once, we're going to need a new bash script... And I recall there's a bunch of clever stuff bash will do with variables and file names... oh - here it is: "${1%\.fix}" will get rid of that...
~/bin/mvname.sh:
mv $1 ${1%\.fix}
> find . -name entries.fix -exec ~/bin/mvname.sh {} \;
Put them back to r/o:
> find . -name entries -exec chmod u-w {} \;

Done! Subversion now works again! Phew.

Interesting: Artifactory

2007-11-01T08:59:00.000-07:00

We all know, and I'm even having some luck convincing people how cool Maven is... but there is that issue of libraries not published in repositories that have to be installed by hand. Ok, and there is the issue of everybody having their own repository and installing all those in each one. But wait - Artifactory to the rescue!

I just installed it - and it just works! Way cool. And a browser even! And even better, what a cool interface... an AJAX-ish tree, dialogs, progress bars...wow! How did they do that? Looks like Wicket.

Frustrating: NetBeans 6.0 Beta

2007-11-01T08:54:00.001-07:00

So I've heard great things about NetBeans - especially that it is now doing Ruby (as I hear on the JavaPosse podcast). I'll give it a try.

Plus: the Maven integration is way ahead of Eclipse.
Con: after doing a Maven build, the errors don't seem to get updated in the editors - i.e. the editor and the project still show errors even though the Maven build went fine (internal or external)

Con: the cursor disappears regularly - the IDE isn't hung; the mouse still works; just no keystrokes. After restarting NB, it works fine... for a while. (I'm on Mac OSX 10.4.10)

I used to be an IntelliJ user - it was fantastic. Let me go see if I can still get the EAP version for free... Wait - what's this in the comments? Artifactory... cool!

Frustrating: Eclipse

2007-11-01T08:45:00.000-07:00

I have been using Eclipse for several years now and it has treated me generally very well. There are so many plugins that the only real hassle has been the few occasions where the plugins collide. However, since appetite grows while dining - I have recently come very close to declaring a divorce! Why?

Upgrading to a J2EE project
One cool thing about Eclipse is being able to deploy a web app and debug your servlets, etc. Eclipse knows how to run Tomcat (and others) and deploy your web app to that server. The trick to all this is that your project must be a 'Dynamic Web Project' (in Eclipse 3.3) or thereabouts. Fine. The problem arises when an existing project grows into a web project. No! We're sorry - you can't add the 'Dynamic Web Project'(DWP) facet to a POJP (Plain Old Java Project). No problem - I'll just make a new project that is a DWP. Now let me get the code from Subversion - let's see: run "Team->Share Project". We're sorry, you must specficy a NEW subversion folder. But I want the one that's already there!
[Actually I just remembered there's now something like "Import from SVN"]
Ok - yes, you can create a new project which is "Check out existing project from SVN" AND even run the "New project wizard" on it to make it a dynamic web project, or whatever you need.