Kirill Grouchnikov's Blog

Programming Archives

Evolving the language

I guess i wasn't very focused in yesterday's entry, paying too much attention to the details of the specific puzzle and not emphasizing my main point (or as Chris defined it the "money quote"). I'll try to rectify it here, bringing together my thoughts on the subject of evolving Java as a language.

First, let's start with the code from Neal's entry. Here is the relevant part:

    static <T,U> List<U> map(List<T> list, 
		{T=>U} transform) {
        List<U> result = new ArrayList<U>(list.size());
        for (T t : list) {
            result.add(transform.invoke(t));
        }
        return result;
    }

    public static void main(String[] args) {
        List<Color> colors = map(Arrays.asList(
		Flavor.values()), { Flavor f => f.color });
        System.out.println(colors.equals(Arrays.asList(Color.values())));
    }

Putting aside the puzzle punchline, here is how i would do the same without closures:

public class Puzzler<T, U> {

   interface Transformer<T, U> {
      U transform(T t);
   }

   List<U> transform(List<T> list, 
          Transformer<T, U> transformer) {
      List<U> result = new ArrayList<U>(list.size());
      for (T t : list) {
         result.add(transformer.transform(t));
      }
      return result;
   }

   public static void main(String[] args) {
      List<Colour> colors = new Puzzler<Flavor, Colour>().transform(Arrays
            .asList(Flavor.values()), new Transformer<Flavor, Colour>() {
         public Colour transform(Flavor f) {
            return f.color;
         }
      });
      System.out.println(colors.equals(Arrays.asList(Colour.values())));
   }
}

And now comes the million dollar question - which one is better? It's a simple question that has two straightforward answers. However, the real answer is "it depends". And based on the subjective background of each one of us, we would go for either the first version or the second version. What does it depend on? Well, quite a few things.

There was an illuminating exchange of opinions in Scala blogosphere about a month ago, ignited by Doug Pardee's post, which lead Reg Braithwaite to quote Jef Raskin's views on the definition of intuitive:

It is clear that a user interface feature is "intuitive" insofar as it resembles or is identical to something the user has already learned. In short, "intuitive" in this context is an almost exact synonym of "familiar."

Let's get back to our two code samples, and to the question which one is better. In my highly subjective opinion, the second one is better, because:

• it is more readable
• it is more maintainable
• it is more verbose

Allow me to address each one of these three points. The second sample is more readable because this is how i'm accustomed to program this sort of requirement. This is what the current language structures allow me to do, and i don't find it too much of a hassle. The code is more maintainable because of the limited variety of currently available options. It ascertains that i and other people who will have to maintain this code must have seen this approach a few times in the existing code base. Getting back to the Jef Raskin quote, it feels more intuitive since it is familiar. Not necessarily optimal, but familiar nonetheless.

The last point on verbosity might be a little controversial, but i'll stand by my words. I've programmed in Ada for almost five years (professionally) and i've never seen it as an over-verbose language. Sure, it might take me an extra 20 seconds to read through the definition of that interface and its invocation, but the extra verbosity makes sure that the code guides me (as its maintainer) along its intended path.

Why would one choose the first example? There are many reasons, all of them undoubtedly valid in the subjective eye of the relevant parties. Some would enjoy the perceived expressiveness (cramming more logic in less characters), some would prefer the abstraction of a method body as first-class language citizen, some would want to know that their language is on par with the hot kid-du-jour that gets all the blogosphere love, some would view it as a refreshing exercise to expand their mind, and some would see the commercial potential that lies in books, consulting and conferences (absolutely no offense meant).

One nagging question remains unanswered - who is the intended target of the new language features? Are the creative minds behind different closures proposals at work just because they are creative, or is there an overwhelming evidence that Java programs (and programmers to a lesser extent) suffer without this language feature. Couple that with the absolute refusal to remove existing language features (like, say, poorly-implemented generics), and you get the following from Bruce Eckel:

But we need to become especially conservative when considering major, fundamental language features like closures which, while they can be very appealing in theory, may have a cost that is too great in practice when they are forced into a language that values backward compatibility over the clarity of its abstractions.

There are real-life scenarios addressed by closures. Anonymous listeners, unnecessary complex try-catch-finally blocks on closing streams and connections, blocks guarded by semaphores, you name it. But if the language is not going to remove (refuse to compile) the existing ways of addressing these scenarios, adding yet another way to do what millions (yes, millions that do not read or write blogs) Java programmers already know how to do is very harmful. Harmful to the code readability (at least in the first few years with the very slow adoption rate for the server-side JDK upgrades) and harmful to the code maintainability.

In my opinion, the language is only a tool. At the end of the day, we still have real people addressing real problems. The technical merits of new language proposals need to be weighed carefully against the potential negative disruption that they bring into the everyday cycle of software development. The puzzlers are only a tip of the iceberg. When i need to maintain and extend existing code, i already have a hard enough time to understand the business logic in it. If you're not going to remove the existing ways to address the limitations imposed by the language, don't add yet another way. It's not going to help me. Not in the everyday world.

And so it begins - the first closures puzzler

Neal Gafter has posted the first closures puzzler. I guess the second edition of Java Puzzlers is in works, and closures will be a hefty addition to the book. If anything, this makes me really sad.

I was very excited to lay my hands on the first edition, but after reading through a few chapters, i skimmed the table of contents, glanced at the visual illusions and never came back to it. If i had to sum this book in one sentence, it would be "great optical illusions and irrelevant content". I know, this is a harsh statement, and i have nothing but respect to both authors (in fact, i consider "Effective Java" to be the book that i would take with me to a deserted island on a condition that it has WiFi access).

I've been using Java for the last 8 years, most of it exclusively (amounting to about 10-12 hours a day, including the work and the side projects). I've written my share of new code, and i most certainly have seen my share of old code that i had to maintain, fix and extend. But never once have i encountered anything even remotely connected to any Java puzzler presented in the book and at the conferences.

Bit-level shifts, integer overflows, overloaded methods, reflection, generics - you name it. I've looked at the examples, i've tried to match them to the real code that i see during the day, and i have found nothing. Of course, i am looking at the tiniest sliver of Java code that exists in the enterprise sector, but somehow i get an impression that i'm not alone. I would even go as far as to say that a feature implemented in a way that results in at least one puzzler is not a feature worth having in the language.

Which brings me to the quote of the day. It comes from an announcement on the end-of-life for Ruby.NET:

As a researcher, my prime interest is not in developing products, but in developing innovative new ideas and having an impact by having those ideas used in the real world.

The generics were added to the language in a very incomplete manner, mainly due to the restrictions on binary compatibility. If we let the researchers in us (even if they are the best researchers) to do the same with closures, i'll pass.

The things that we take for granted

Last weekend i went and bought a new laptop (actually, this is my first laptop). So, as i plugged it in and connected to the net, Vista started downloading updates and installing them. And then i started thinking - what happens if one of these updates will simply crash the OS on the next boot?

The implicit assumption of any update to the operating system is that it at least boots (if everything is OK with the hardware). For the past 8 years that i've been using Windows (from 3.11 to NT, 98, XP, 2003 and Vista) i've seen the blue screen of death only once, and that was because of bad RAM sticks (after our IT department replaced them, it all went back to normal). So you kind of take it for granted that when you switch the power on, the OS will come alive and greet you with the full functioning desktop at your disposal. But just think about myriads of small things that can go wrong, including the boot, startup processes, login, drivers, mouse and keyboard, anti-virus, firewall etc. The operating system simply can't fail.

I don't know what's the testing process inside Microsoft for releasing the automated updates, but the end result is that it simply works. They are downloaded, installed, and on some occasions (which are far less frequent than they used to be) OS reboots. And then the magic happens - it all comes back to life. No exception stack traces to copy and send to the developer. No magic key sequence to bypass a faulted module. No praying that it won't crash. It just works.

And this is a technical feat worthy of praise. Such a gigantic multi-layered beast and zero tolerance for startup errors. Makes me think twice about asking people to send stack traces when something goes wrong...

When you know that a programmer is a Java programmer

Mylar - a very useful Eclipse plugin

Developing Java project - a team effort

How single can your singleton instance be?

    
public class TestSingleton {
  private static TestSingleton instance;

  private TestSingleton() {}

  public static synchronized TestSingleton getInstance() {
    if (instance == null) {
      instance = new TestSingleton();
    }
    return instance;
  }
}

    
public class TestSingleton {
  private static TestSingleton instance = new TestSingleton();

  private TestSingleton() {}

  public static TestSingleton getInstance() {
    return instance;
  }
}

    
public class SingletonMain {
   public static void main(String... args) throws Exception {
      Logger _logger = Logger.getLogger(SingletonMain.class.getName());
      // create first version of class
      String className = "TestSingleton";
      String dir1 = "C:\\temp\\ver1";
      new File(dir1).mkdirs();
      BufferedWriter bw1 = new BufferedWriter(new FileWriter(dir1
            + File.separator + className + ".java"));
      bw1.write("public class " + className + " {");
      bw1.newLine();
      bw1.write("  private static " + className + " instance;");
      bw1.newLine();
      bw1.write("  private " + className + "() {}");
      bw1.newLine();
      bw1.write("  public static synchronized " + className + " getInstance() {");
      bw1.newLine();
      bw1.write("    if (instance == null) {");
      bw1.newLine();
      bw1.write("      instance = new " + className + "();");
      bw1.newLine();
      bw1.write("    }");
      bw1.newLine();
      bw1.write("    return instance;");
      bw1.newLine();
      bw1.write("  }");
      bw1.newLine();
      bw1.write("}");
      bw1.newLine();
      bw1.close();

    
public class TestSingleton {
  private static TestSingleton instance;
  private TestSingleton() {}
  public static synchronized TestSingleton getInstance() {
    if (instance == null) {
      instance = new TestSingleton();
    }
    return instance;
  }
}

    
      // compile
      int compStatus = com.sun.tools.javac.Main.compile(new String[] { dir1
            + File.separator + className + ".java" });
      _logger.info("Compilation status is " + compStatus);

      // load
      ClassLoader classLoader1 = new URLClassLoader(
            new URL[] { new File(dir1).toURL() });
      Class clazz1 = classLoader1.loadClass(className);
      _logger.info("Loaded " + clazz1.getName() + " [" + clazz1.hashCode()
            + "]");

    
INFO [11:05:27.553] [SingletonMain.main] Compilation status is 0
INFO [11:05:27.584] [SingletonMain.main] Loaded TestSingleton [24287316]

    
      Method getter1 = clazz1.getMethod("getInstance", new Class[0]);
      Constructor[] ctrs1 = clazz1.getConstructors();
      
      _logger.info(ctrs1.length + " constructors");
      Object val10 = getter1.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val10.hashCode());
      Object val11 = getter1.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val11.hashCode());
      Object val12 = getter1.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val12.hashCode());
      

    
INFO [11:05:27.584] [SingletonMain.main] 0 constructors
INFO [11:05:27.584] [SingletonMain.main] Fetched object #7254922
INFO [11:05:27.584] [SingletonMain.main] Fetched object #7254922
INFO [11:05:27.584] [SingletonMain.main] Fetched object #7254922

    
      // copy the class file to another directory
      String dir2 = "C:\\temp\\ver2";
      new File(dir2).mkdirs();
      InputStream in = new FileInputStream(new File(dir1 + File.separator
            + className + ".class"));
      OutputStream out = new FileOutputStream(new File(dir2 + File.separator
            + className + ".class"));
      byte[] buf = new byte[1024];
      int len;
      while ((len = in.read(buf)) > 0) {
         out.write(buf, 0, len);
      }
      in.close();
      out.close();

      // load
      ClassLoader classLoader2 = new URLClassLoader(
            new URL[] { new File(dir2).toURL() });
      Class clazz2 = classLoader2.loadClass(className);
      _logger.info("Loaded " + clazz2.getName() + " [" + clazz2.hashCode()
            + "]");

    
INFO [11:05:27.600] [SingletonMain.main] Loaded TestSingleton [33482492]

    
      Method getter2 = clazz2.getMethod("getInstance", new Class[0]);
      Constructor[] ctrs2 = clazz1.getConstructors();

      _logger.info(ctrs2.length + " constructors");
      Object val20 = getter2.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val20.hashCode());
      Object val21 = getter2.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val21.hashCode());
      Object val22 = getter2.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val22.hashCode());

    
INFO [11:05:27.600] [SingletonMain.main] 0 constructors
INFO [11:05:27.600] [SingletonMain.main] Fetched object #32429958
INFO [11:05:27.600] [SingletonMain.main] Fetched object #32429958
INFO [11:05:27.600] [SingletonMain.main] Fetched object #32429958

    
public class SingletonMain2 {
   public static void main(String... args) throws Exception {
      Logger _logger = Logger.getLogger(SingletonMain2.class.getName());

      String className = "TestSingleton2";
      String classSig = className + ".class";
      File dir1 = new File("C:\\temp\\ver1");
      dir1.mkdirs();

    
      String classpath = System.getProperty("java.class.path");
      _logger.info("Classpath : " + classpath);
      String[] pathComps = classpath.split(";");
      boolean wasLocated = false;

    
      for (String pathComp : pathComps) {
         if (wasLocated)
            break;
         if (pathComp.endsWith(".jar")) {
            // scan jar and look for the desired class.
            // Use JarInputStream for reading jar file and
            // JarEntry for checking the current entry.
            // The, getInputStream() on the matching entry
            // and copy it to the temp directory as below.
         } 

    
            // should be directory
            File pathCompDir = new File(pathComp);
            if (pathCompDir.exists() && pathCompDir.isDirectory()) {
               // scan for the class
               File[] allFiles = pathCompDir.listFiles();
               for (File currFile : allFiles) {
                  if (currFile.getName().equals(classSig)) {
                     _logger.info("Located at "
                           + currFile.getAbsolutePath());
                     wasLocated = true;
                     // copy to another directory
                     InputStream in = new FileInputStream(currFile);
                     OutputStream out = new FileOutputStream(new File(
                           dir1, classSig));
                     byte[] buf = new byte[1024];
                     int len;
                     while ((len = in.read(buf)) > 0) {
                        out.write(buf, 0, len);
                     }
                     in.close();
                     out.close();
                     break;
                  }
               }
            }

    
      if (!wasLocated) {
         _logger.info("Not located - quitting");
      }

      // very important - pass null parent class loader, otherwise
      // the parent class loader will be system class loader and
      // it will find the class in the classpath
      ClassLoader classLoader1 = new URLClassLoader(
            new URL[] { dir1.toURL() }, null);
      Class clazz1 = classLoader1.loadClass(className);
      _logger.info("Loaded " + clazz1.getName() + " [" + clazz1.hashCode()
            + "]");
      _logger.info("Have " + clazz1.getName() + " [" + clazz1.hashCode()
            + "]");

    
INFO [11:27:39.598] [SingletonMain2.main] Loaded TestSingleton2 [4384790]
INFO [11:27:39.598] [SingletonMain2.main] Have TestSingleton2 [4384790]

    
      Method getter1 = clazz1.getMethod("getInstance", new Class[0]);
      Constructor[] ctrs1 = clazz1.getConstructors();

      _logger.info(ctrs1.length + " constructors");
      Object val10 = getter1.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val10.hashCode());
      Object val11 = getter1.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val11.hashCode());
      Object val12 = getter1.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val12.hashCode());

    
INFO [11:27:39.598] [SingletonMain2.main] 0 constructors
INFO [11:27:39.598] [SingletonMain2.main] Fetched object #9634993
INFO [11:27:39.598] [SingletonMain2.main] Fetched object #9634993
INFO [11:27:39.598] [SingletonMain2.main] Fetched object #9634993

    
      // copy the class file to another directory
      String dir2 = "C:\\temp\\ver2";
      new File(dir2).mkdirs();
      InputStream in = new FileInputStream(new File(dir1 + File.separator
            + className + ".class"));
      OutputStream out = new FileOutputStream(new File(dir2 + File.separator
            + className + ".class"));
      byte[] buf = new byte[1024];
      int len;
      while ((len = in.read(buf)) > 0) {
         out.write(buf, 0, len);
      }
      in.close();
      out.close();

    
      // load
      ClassLoader classLoader2 = new URLClassLoader(
            new URL[] { new File(dir2).toURL() }, null);
      Class clazz2 = classLoader2.loadClass(className);
      _logger.info("Loaded " + clazz2.getName() + " [" + clazz2.hashCode()
            + "]");

    
INFO [11:27:39.614] [SingletonMain2.main] Loaded TestSingleton2 [14576877]

    
      Method getter2 = clazz2.getMethod("getInstance", new Class[0]);
      Constructor[] ctrs2 = clazz2.getConstructors();

      _logger.info(ctrs2.length + " constructors");
      Object val20 = getter2.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val20.hashCode());
      Object val21 = getter2.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val21.hashCode());
      Object val22 = getter2.invoke(null, new Object[0]);
      _logger.info("Fetched object #" + val22.hashCode());

    
INFO [11:27:39.676] [SingletonMain2.main] 0 constructors
INFO [11:27:39.676] [SingletonMain2.main] Fetched object #12677476
INFO [11:27:39.676] [SingletonMain2.main] Fetched object #12677476
INFO [11:27:39.676] [SingletonMain2.main] Fetched object #12677476

IDE lockdown - give my Java back

• at work - most probably dictated by the work-place policy (which on itself isn't bad, considering that you have to work in team environment at different computers, so you'd better have the same environment installed)
• go with the majority (hoping that the shepherd isn't blind and has no hidden agenda)
• try out various tools and see which one fits you the best

• rename (variable, member, class)
• move (class to another package)
• find declaration (of variable, member, class)
• refactor string to constant static member
• generate getters and setters for a class
• implement methods from interface
• organize imports
• reformat code

This work is licensed under a Creative Commons License.