Kirill Grouchnikov's Blog

Community: Java Tools Archives

What's the big deal?

I've been following Cafe au Lait for a few weeks now, and it really amuses me. Quotes like "the best Java can or should do is faithfully mimic the native user interface" and "the goal of a Java application is to fit in with other native applications, not to stand out" most certainly indicate that the writer is a strong proponent of a native look and feel, which is kind of bemusing. The Mac UI is shifting constantly, and the upcoming OS X release is supposed to feature a new UI (Illuminous?). Given the history of OS X for the past few years, and numerous native look and feels (Aqua, Graphite, Brushed Metal), it would appear that even Apple's UI designers don't consider the current state of affairs as the best. But i digress.

You need to be able to change the UI around really easily during development — after user testing, or a Steve Jobs encounter session — even after you’ve attached a lot of code to it. That means no RAD tools that write code for you, because once their code mingles with your code, it gets hard to disentangle. Instead, the UI should be described with data, like an Interface Builder ".nib" file.

The obvious target of this quote is NetBeans Matisse which puts the UI-related code in the same file as the business logic (say, event handlers). However, that is misleading at best and fanboyish at worst.

• The code that NetBeans generates doesn't "mingle" with your code. It is kept in one section of code which is folded by default, and the Java editor doesn't allow you to edit it (you can still view it).
• If you do open this class in an external editor, change the generated code and then play surprised that NetBeans doesn't like it (if you don't follow its conventions), think about what would happen if you'd do the same with the NIB file. Or with the good old Visual Studio RC files. Or with brand new XAML / C# extravaganza.
• NetBeans doesn't use any proprietary format and is already supported by Instantiations for editing in Eclipse. Any other major Mac IDE providing support for editing NIB-based UIs?

So, what's the big deal? What's all the bickering about? That NetBeans doesn't use two separate files? Or that a major Java IDE finally provided a decent UI editor? Or that Java developers seem to treat a 5% market as what it is (a 5% market)?

I don't want to reopen the entire native against cross-platform look-and-feel debate again. I just would like to understand the real difference between Interface Builder approach and Matisse approach, as long as each one of these is used as it's designed to.

For some more thoughts read this and this.

Ye old faithful IDE

My current work project involves extending an existing application and adding a few new features. All is well and good, but it's written in C++. Well, all is still well, since that has been my primary development from '99 to '02 (in Visual Studio 6). The code is written well, the original developers sit right next to me, C++ is very much like Java (thankfully they didn't use operator overloading), so what's the problem?

Well, it all begins with the build configuration. Since there's no such thing as an Ant build script, you have all these in the project files (.sln and .vcproj). Now, the structure of these files changes between different Visual Studio versions, so if you want to upgrade to Visual Studio 2005, you'll have to upgrade your projects files as well. In this specific case, this is way over my head, since the build portions are very complicated and it would take too much time to port it to VS 2005.

So, i'm stuck with 4-year old IDE. Now, back in the day (VS 6.0), i didn't notice it, but now, coming back from Eclipse / NetBeans / IDEA, this looks like an old relic from The Stone Age. Refactoring? Not yet. Find all uses? Not yet. Set breakpoint on field change? Just follow this sequence of 7-8 steps that involves writing down the field address and typing it later in some obscure screen. And the list goes on. Personally, i came to depend so much on key strokes in Eclipse, that coming back to an IDE that doesn't have the matching functionality is a serious shock.

Now, this is obviously not a VS problem. This would be the same with much earlier versions of Eclipse, NetBeans and JBuilder. It's just that the coding doesn't really flow. If you want to add a new parameter to a method and change all the callers, you have the following options, none of which are very attractive:

• Ctrl+Shift+F (Find in Files) for the method name and hope that no other class defines the same method name. Depending on the soltion size, this takes some time (the results are not cached by IDE).
• Change the .h and .cpp by adding a letter to the method name, build the solution and see all the places that have been broken. Depending on the solution size and build target complexities, this takes even more time.

With this, an extended "Thank You" goes to all Java IDE developers that continue adding new features to their IDEs. It's only when we stop using them, we can fully appreciate their advantages.

You say Eclipse, I say IBM

Using Java compiler in your Web Start application

private static Method javac = null;

static {
   try {
      File jreHome = new File(System.getProperty("java.home"));
      System.out.println("java.home = " + jreHome.getAbsolutePath());
      File toolsJar = new File(jreHome.getParent(), "lib/tools.jar");
      System.out.println("tools.jar = " + toolsJar.getAbsolutePath());
      ClassLoader toolsJarLoader = new URLClassLoader(
            new URL[] { toolsJar.toURL() });
      javac = toolsJarLoader.loadClass("com.sun.tools.javac.Main")
            .getMethod("compile", new Class[] { String[].class, PrintWriter.class });
      hasToolsJar = true;
   } catch (Exception exc) {
      javac = null;
      hasToolsJar = false;
   }
}   

<resources>
  <j2se version="1.5+" />
  ...
  <jar href="jaxb-api.jar"/>
  <jar href="jsr173_api.jar"/>
  <jar href="org.eclipse.jdt.core_3.1.0.jar"/>
  ...
</resources>

-cp jaxb-api.jar;jar173_api.jar

try {
   for (Enumeration<?> e = org.jvnet.jaxbw.Workspace.class
         .getClassLoader().getResources("META-INF/MANIFEST.MF");
         e.hasMoreElements();) {
      URL url = (URL) e.nextElement();
      _logger.info("Scanning " + url.getFile());
      ...
} catch (IOException exc) {
   exc.printStackTrace();
}

INFO: Scanning https://jaxb-workshop.dev.java.net/webstart/jaxb-api.jar!/META-INF/MANIFEST.MF

-cp https://jaxb-workshop.dev.java.net/webstart/jaxb-api.jar;https://jaxb-workshop.dev.java.net/webstart/jar173_api.jar

   private static synchronized String getLocalClassPath(Logger _logger) {
      if (isJarsLoadedLocal) {
         return localJarsClassPath;
      }

      Set classpathJars = new HashSet();

      try {
         for (Enumeration<?> e = org.jvnet.jaxbw.Workspace.class
               .getClassLoader().getResources("META-INF/MANIFEST.MF"); e
               .hasMoreElements();) {
            URL url = (URL) e.nextElement();
            _logger.info("Scanning " + url.getFile());
            if (url.getFile().contains("jaxb-api.jar")) {
               String jaxbApiLocal = getLocalJarFilename(url, _logger);
               if (jaxbApiLocal != null) {
                  classpathJars.add(jaxbApiLocal);
               }
            }
            if (url.getFile().contains("jsr173_api.jar")) {
               String jsr173ApiLocal = getLocalJarFilename(url, _logger);
               if (jsr173ApiLocal != null) {
                  classpathJars.add(jsr173ApiLocal);
               }
            }
         }
      } catch (IOException exc) {
         exc.printStackTrace();
      }

      String classpath = "";
      if (classpathJars.size() > 0) {
         classpath = " -cp \"";
         String separator = "";
         for (String localJarName : classpathJars) {
            classpath += (separator + localJarName);
            separator = File.pathSeparator;
         }
         classpath += "\"";
      }

      isJarsLoadedLocal = true;
      localJarsClassPath = classpath;

      return localJarsClassPath;
   }

   private static String getLocalJarFilename(URL remoteManifestFileName,
         Logger _logger) {
      _logger.info("Trying to create local version of "
            + remoteManifestFileName);
      // remove trailing
      String urlStrManifest = remoteManifestFileName.getFile();
      String urlStrJar = urlStrManifest.substring(0, urlStrManifest.length()
            - MANIFEST.length() - 2);
      _logger.info("Remote : " + urlStrJar);
      InputStream inputStreamJar = null;
      File tempJar;
      FileOutputStream fosJar = null;
      try {
         URL urlJar = new URL(urlStrJar);
         if (urlJar == null) {
            _logger
                  .info("No remote version (probably not running in JNLP)");
            return null;
         }

         inputStreamJar = urlJar.openStream();
         String strippedName = urlStrJar;
         int dotIndex = strippedName.lastIndexOf('.');
         if (dotIndex >= 0) {
            strippedName = strippedName.substring(0, dotIndex);
            strippedName = strippedName.replace("/", File.separator);
            strippedName = strippedName.replace("\\", File.separator);
            int slashIndex = strippedName.lastIndexOf(File.separator);
            if (slashIndex >= 0) {
               strippedName = strippedName.substring(slashIndex + 1);
            }
         }
         tempJar = File.createTempFile(strippedName, ".jar");
         _logger.info("Created temporary file '" + tempJar.getAbsolutePath()
               + "'");
         tempJar.deleteOnExit();
         fosJar = new FileOutputStream(tempJar);
         byte[] ba = new byte[1024];
         int bytesWritten = 0;
         while (true) {
            int bytesRead = inputStreamJar.read(ba);
            if (bytesRead < 0) {
               break;
            }
            fosJar.write(ba, 0, bytesRead);
            bytesWritten += bytesRead;
         }
         _logger.info("Written " + bytesWritten + " bytes to local file");
         return tempJar.getAbsolutePath();
      } catch (Exception ioe) {
         System.out.println(ioe.getMessage());
         ioe.printStackTrace();
      } finally {
         try {
            if (inputStreamJar != null) {
               inputStreamJar.close();
            }
         } catch (IOException ioe) {
         }
         try {
            if (fosJar != null) {
               fosJar.close();
            }
         } catch (IOException ioe) {
         }
      }
      return null;
   }

ByteArrayOutputStream baosMessages = new ByteArrayOutputStream();
ByteArrayOutputStream baosWarnings = new ByteArrayOutputStream();
long time0 = System.currentTimeMillis();
StringBuffer bigAllNames = new StringBuffer();
for (SingleClassInfo currClassInfo : allClasses) {
   String currFilename = currClassInfo.getRootDirName()
+ File.separator + currClassInfo.getRelJavaFilename();
   this._logger.info("Adding " + currFilename + " to compilation");
   bigAllNames.append("\"" + currFilename + "\" ");
}
String warningSetting = new String("allDeprecation,"
      + "allJavadoc," + "assertIdentifier," + "charConcat,"
      + "conditionAssign," + "constructorName," + "deprecation,"
      + "emptyBlock," + "fieldHiding," + "finalBound,"
      + "finally," + "indirectStatic," + "intfNonInherited,"
      + "javadoc," + "localHiding," + "maskedCatchBlocks,"
      + "noEffectAssign," + "pkgDefaultMethod," + "serial,"
      + "semicolon," + "specialParamHiding," + "staticReceiver,"
      + "syntheticAccess," + "unqualifiedField,"
      + "unnecessaryElse," + "uselessTypeCheck," + "unsafe,"
      + "unusedArgument," + "unusedImport," + "unusedLocal,"
      + "unusedPrivate," + "unusedThrown");

// Create classpath. For compiling XJC-generated files we need two
// jar files, jaxb-api.jar and jsr173_api.jar. When Milano is run
// from the local computer, these jars should be on classpath
// (explicitly or on PATH varibable). However, when our application
// runs from Java Web Start, these jars are not available by their
// names. Here, we will try to fetch them as resources and create
// temporary files on the local machine.
String classpath = Workspace.getLocalClassPath(this._logger);
this._logger.info("Classpath is " + classpath);

// Start compilation using jdtcore
boolean compilationStatus = org.eclipse.jdt.internal.compiler.batch.Main
      .compile("-1.5 -source 1.5 -warn:" + warningSetting + " "
   + classpath + " " + bigAllNames.toString(),
   new PrintWriter(baosMessages), new PrintWriter(
baosWarnings));

// Parse the messages and the warnings.
long time1 = System.currentTimeMillis();
BufferedReader br = new BufferedReader(new InputStreamReader(
      new ByteArrayInputStream(baosMessages.toByteArray())));
while (true) {
   String str = br.readLine();
   if (str == null) {
      break;
   }
   this._logger.info("/javac/ " + str);
   compilerMessages.addLast(str);
}
BufferedReader brWarnings = new BufferedReader(
      new InputStreamReader(new ByteArrayInputStream(baosWarnings
   .toByteArray())));
LinkedList<String> warnings = new LinkedList<String>();
while (true) {
   String str = brWarnings.readLine();
   if (str == null) {
      break;
   }
   this._logger.warning("/javac/ " + str);
   compilerMessages.addLast(str);
   warnings.addLast(str);
}
this._logger.info((time1 - time0) + " milliseconds, "
      + (compilationStatus ? "success" : "failure"));
return compilationStatus;

AOP - a poor man's excuse for writing ugly code

• pre and post conditions - should really be a part of the methods (especially in Java where you should be able to read the Javadocs to understand what is the contract and when the exceptions are thrown)
• contract enforcement - covering up for a bad design.
• configuration management - via standard resource bundles, property files and Ant configuration.

This work is licensed under a Creative Commons License.