Consider this: Microsoft’s customers don’t buy into C# (regardless of what most techies will tell you), they buy the Visual Studio packaged, pre-canned development pathway to development nirvana. They take on a particular packaged view of the world. Then they pretty much sit back and go where Microsoft leads them. It’s a well-marketed, appealling, popular, putatively risk-free and well-trodden strategy.

(Dont’ kid yourself that the marketing is actually real, however. Script-kiddies will produce script-kiddy grade coding, regardless of the quality of the marketing, or the prettiness of the tool. Trust me, I’ve seen the code! The only way out of this is training and experience. There’s a cost there, both dollars and time, so the professional managers that now rule our world will do almost anything to avoid that cost.)

The Microsoft market is notoriously not innovation-driven. The customers and practitioners typically don’t care less about better ways of skinning the cat, as long as it gets skinned somehow.

On the surface, this seems fine and dandy but let’s look around our modern world to see if innovation actually is or is not needed…

• I am pretty happy that I don’t drive a Model-T Ford: love those modern innovations like anti-lock brakes, seatbelts, aircon, airbags pneumatic tyres and suspension systems. I am VERY happy that I don’t have to ride a horse…or a donkey.
• I’m grateful for penicillin.
• Being able to step into a Boeing 747 to travel half-way around the planet has certainly changed my life.
• Love the lidocaine that my dentist pumps into me before digging around inside one of my teeth’s root canals.
• I often remark at the way modern materials have changed the game of Tennis (sometimes for the worse but the actual rackets are indubitably superior to those of yore).
• Let’s not forget that ASP.Net is better because of the influence of JSP/JSF technology, and that JSP/JSP (especially JSF) is better because of ASP.Net…that raw competition has been good for all concerned.

Innovation does make a difference, it seems.

Oh well. That was then, this is now.

(It is interesting to note that Microsoft is finding it hard to add new features into C# nowadays: the customers are effectively saying “we dont’ need no stinkin’ innovation”…)

So: I see Java becoming Oracle’s C# analogue.

All Java’s best features…all those features that make it attractive to Oracle the tool vendor (a mature, stable, efficient, cross-platform execution environment with minimum cost of development and support but with maximum market penetration)…will be ‘deprecated’/no longer mentioned. They will still be there and still be relevant but they will be pushed under the covers. You won’t see them and Oracle will educate you to let you know that you don’t even need to see them. What you’ll ‘need’ is to buy their product set. The product set that has been carefully engineered and (especially) advertised to sit right in the sweet-spot of minimum effort to produce and maximum profitability…for Oracle.

You’ll be bombarded with marketing and other influences to ensure that you forget those Java communities and competitors out there (you know, the ones that have benefitted your world over the past 10-15 years); Oracle’s sales team will be happy to explain to you why you don’t need the likes of Apache.org, the JCP, Spring, JBoss, etc. any more.

As long as you cross their palms with copious quantities of gold, Oracle will show you the One True Way.

Hopefully, there will be some sort of convergence between what Oracle will feed you and what you actually need.

Just remember what happens to a drug addict when he/she can’t pay their dealer…

The current Java-based multi-vendor marketplace simply won’t be able to survive under such conditions.

Don’t believe me? Want proof? Answer me this, then: what’s the second-best selling C# IDE in the windows world? There pretty much isn’t one, is there! Or this: what’s the alternative framework to ASP.Net? Again, there ain’t no such animal…

It’s the end of the world, people!

Perhaps one day in 2025, some manager with an atavistic streak of innovation in his/her DNA will suddenly pause the “Oracle Charge-O-Meter” on his/her pay-per-cycle copy of “Oracle Developer Brain Enhancement Interface for the Enterprise 17.7c” and think: “You know, what we need is a way of building Open Systems and not being beholden to a single monopolistic vendor! Wonder why no-one ever thought of that before?” I’m assuming that about 100 cycles after detecting such a wayward and unprofitable thought, the “Oracle License Mangager” will take appropriate remedial action…

Whoops! There I go! Again with the Open Systems thing…

Might have saved me some grief.

I’m sure that this will be useful sometime in the future.

I am opening up old courseware to the world on a “pay if you like it” or have it free basis.

My fifth offering is Java Technology and Development.

(You will find other offerings in this site tagged with DonationWare.)

This course was started in ~1996 as Java was becoming popular. I stopped hacking it sometime around 2002, so it had a pretty good run. This version is from sometime in 2001 (it was pretty much the first “reasonably up-to-date” copy I found in my archive…actually a big pile of CDs).

This course had a lot of mileage: it went around Australia and the US many times, it went around various bits of Asia a couple of times and it went to NZ a few times.

It was used by a team of presenters, each of whom presented it very differently (interestingly enough), and contributed bits and pieces and bugfixes to it (thanks, guys!). Nonetheless, it retained my somewhat cynical/quirky view of the Java Universe.

It was presented under a few different banners. Never under the transentia banner in Australia.

It was even ‘informally’ licensed (meaning I pretty much got ripped-off!) to a US company for their purposes (whatever they were…I never really found out).

I have also presented Java courseware for a number of other organisations and I still believe that this is the best.

I remember presenting it for the very first time, to a local ISP in Darwin. After discussing Applets, I was talking about how Applets could be used to build a Tsunami-style D.O.S. attack and bring down a whole network. Suddenly one participant jumped up and walked out and I didn’t see him for quite a whle. Turns out that he was the owner of the company. He later explained that he had just spent a day madly reconfiguring his servers and network to be more resistant to the type of attack I had been talking about. I really scared the poor guy!

When the course first burst onto the world, the course participants were all keen and clever “early adopters”: for exercises, it was enough to say “Here is a Java compiler, go build me an ‘X’.” and everyone had fun, and learned lots along the way. By the time I knocked it on its head–no more early adopters were coming through and in some cases we had to deal with people who simply didn’t want to know but were being told to follow the company line–the exercises were having to be specified a lot more completely (it seemed like we had to detail practically every keypress and mouse movement). It wasn’t so much fun at the end, sad to say!

I also recall telling my colleagues about one participant that really did not know how to use her mouse (this makes life really hard for an instructor; to this day, the phrase “No. Use the other mouse button.” has significance to us) and they were scoffing at me, thinking I was exaggerating. Until the time when one poor guy came back from presenting the course for the first time and said: “I was really shocked. I always thought you were laying it on thick, but some of these participants didn’t even know how to type, let along program.” I paraphrase, but you get the idea.

Fun days…

Enough reminiscing! Here’s the ‘blurb’:

The course is now well and truly at End of Life.

I figure that it would be such a pity for it to end as a set of bits decaying away on my hard disk so I am opening it up to the world on as “as-is” basis:

java-courseware-donationware.04.july.2009.zip

(MD5: 197bf97bf6020c2ca2ba440f87b59790; size: 6,615,799 bytes)

Some (unfortunately necessary) legalese:

• This content is provided “as-is”, with no guarantees.
• Feel free to use it, but not to abuse it (to give a couple of examples: don’t make hundreds of copies for friends; don’t claim it as your own work).
• I retain copyright, so “all rights reserved.”

Enjoy!

If you like it, or have any questions/comments, send me an email ().

If you find this material useful, please consider paying me a small amount: via PayPal.

It’s still available…and still the best Java course out there, IMHO (and I have given quite a few from several other [major] vendors in addition to my own).

One of the exercises that that participants seemed to enjoy was to take an applet not to dissimilar from the Scribble applet published in David Flanagan’s Java in a Nutshell and modify it so that the drawing persevered through screen redraws.

This helped the participants get their head around anonymous inner classes and the applet lifecycle callbacks and also gave them a chance to play with the List collection interface/classes.

Time moves on and we now have Groovy’s SwingBuilder and the new JavaFX technology promoted by Sun.

Prompted by the negative press that JavaFX has received, postings such as this and the speed increases of the “consumer JRE”, together with the fact that it is now bundled into Netbeans 6.5.1 (making it easy to get hold of and play with; not sure why it is currently missing in action for 6.7m3) I decided to see how the ‘newcomers’ stacked up.

The examples aren’t completely identical (one is an applet, while the others are JFrames, for example) but this is still a nice ‘feel’ exercise.

I am reminded of the Evolution of a Programmer joke…

Here goes…

=== Java (in homage to Java in a Nutshell, Second Edition)

import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class PerseveringScribbleCollections extends java.applet.Applet
  {
  int last_x = 0;
  int last_y = 0;
  List model = new ArrayList ();

  public void init ()
    {
    addMouseListener
      (
      new MouseAdapter ()
        {
        public void mousePressed (MouseEvent e)
          {
          last_x = e.getX ();
          last_y = e.getY ();
          }
        }
      );

    addMouseMotionListener
      (
      new MouseMotionAdapter ()
        {
        public void mouseDragged (MouseEvent e)
          {
          Graphics g = getGraphics ();
          int x = e.getX ();
          int y = e.getY ();
          g.setColor (Color.black);
          DrawLine d = new DrawLine (last_x, last_y, x, y);
          model.add (d);
          d.paint (g);
          last_x = x; 
          last_y = y;
          }
        }
      );
    }

  public void paint (Graphics g)
    {
    ListIterator l = model.listIterator ();
    while (l.hasNext ())
      {
      ((DrawLine) l.next ()).paint (g);
      }
    }
  }

class DrawLine
  {
  private int x0;
  private int y0;
  private int x1;
  private int y1;

  public DrawLine (int x0, int y0, int x1, int y1)
    {
    this.x0 = x0;
    this.y0 = y0;
    this.x1 = x1;
    this.y1 = y1;
    }

  public void paint (Graphics g)
    {
    g.drawLine (x0, y0, x1, y1);
    }
  }

=== Groovy (based on the Java version, above. All my own work ;=))

import javax.swing.WindowConstants as WC

import groovy.swing.SwingBuilder
import java.awt.Color
import java.awt.Graphics
import javax.swing.JPanel

def list = []
def last_x = 0
def last_y = 0

SwingBuilder.build {
  frame(title: 'Groovy Scribble',
      size: [600, 400],
      show: true,
      pack: false,
      resizable: false,
      defaultCloseOperation: WC.EXIT_ON_CLOSE) {
    widget(new Scribble(list: list),
        mousePressed: {e ->
          (last_x, last_y) = [e.x, e.y]
        },
        mouseDragged: {e ->
          (x, y) = [e.x, e.y]
          def d = new DrawLine(x0: last_x, y0: last_y, x1: x, y1: y)
          d.paint(e.component.graphics)
          list << d
          (last_x, last_y) = [x, y]
        }
    )
  }
}

class Scribble extends JPanel {
  def list = []

  public void paint(Graphics g) {
    list.each { it.paint(g) }
  }
}

class DrawLine {
  def x0
  def y0
  def x1
  def y1

  public void paint(Graphics g) {
    g.setColor(Color.black);
    g.drawLine(x0, y0, x1, y1);
  }
}

=== JavaFX (adapted from Planet JFX)

package au.com.transentia.scribble.javafx;

import java.lang.System;
import javafx.scene.*;
import javafx.scene.input.MouseEvent;
import javafx.scene.paint.*;
import javafx.scene.shape.Polyline;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;

def w = 600;
def h = 400;

class Scribble extends CustomNode {
    var polyline: Polyline;

    public override function create(): Node {
        var group: Group = Group{
            onMousePressed: function (e: MouseEvent) {
                polyline = Polyline{ points: [e.sceneX, e.sceneY] };
                insert polyline into group.content ;
            }
            onMouseDragged: function (e: MouseEvent) {
                insert [e.sceneX, e.sceneY] into polyline.points;
            }
            content: Rectangle {
                width: w
                height: h
                fill: Color {opacity: 0}
            }
        }

        return group;
    }
}

Stage {
    onClose: function(): Void {
        System.exit(0);
    }
    title: "JavaFX Scribble"
    width: w
    height: h
    visible: true
    resizable: false
    scene: Scene {
        content: [Scribble{}]
    }
}

I’m not going to draw any conclusion…not one. Nope, not one. “Left as an exercise for the reader”, that sort of thing applies here…

I had fun and each example is interesting, in its own way.

Enjoy.

Where now for Solaris?

Seems pretty clear: ‘Unbreakable’ Solaris, coming soon to a datacentre near you.

Where now for Java?

Ah. Now that is the question as far as I’m concerned, isn’t it?

It’s a major part of why Oracle wanted Sun…no doubt.

Oracle’s (even more than Sun’s) early statements of “Use your Java skills everywhere: from Stored Procedures in the database, through the server on to mobile devices.” always resonated with me: it made good business sense (and that should tell you what a doomed idea it was…)

Trouble is: history.

At first, Java was a pissy little language. I didn’t take it too seriously (didn’t stop me making $$$, though!).

Before release 1.1 came along, IBM contributed a big slab of technology and know-how and raised Java up quite a few levels. I saw some of this first-hand. Thus, for the longest time I said: “Java is practically a product of IBM’s experience; IBM should buy Java.” But over time, they stopped driving (or–more accurately, I guess–were prevented from driving) and so went off to play with Apache and then Eclipse. The end result is a lot of excellent Java-based tools and componentry but not enough at the ‘core.’

IBM recently made a few noises but eventually didn’t follow though, it seems. Apparently however, they opened the door for Oracle to step through.

Oracle have used Java a lot; their fusion middleware stack, etc. is all Java; they have made some excellent products using Java; they have contributed to JCPs; they have bought other big users. This is all good. But I can’t see that they have ever really driven Java.

Stability seems to be what they need and will be aiming at.

Not that there is anything wrong with that.

The question is: what gets dropped?

Take IDEs: Oracle now has the Eclipse-based Workshop, JDeveloper and now Netbeans on its sheet. I was worried about them having two…

Another: JRockit. What is going to happen to the best server-side JVM out there? I was pretty mad at Oracle for restricting access to JRockit after they bought BEA. Now it seems that the JVM pack of cards will be up in the air…

My prediction is that some other pissy little language is going to become “safe harboour” and the industry will run after it like some dumb slathering dog chasing a bone: “Never mind hey! There’s another silver bullet in the chamber, let’s see what that does!”

A proof of this, I offer SAP.

Seems inevitable, doesn’t it.

My vote would go to whitespace. If we’re going to throw away all the good stuff that has happened since the late ’90s, we may as well really throw it away ;-)

Let’s remember the “bad old days” too (not too long ago): when DEC forced BLISS at us, IBM wanted you to use PL/I, Burroughs were the ‘Algol’ shop, etc. etc. These days persist with all the silly little SQL dialects out there, not to mention Microsoft .Net. Do we really want to return to this? The vendors’ natural proclivities are to “lock us in” to their worlds…

I always answer that the respective Java and .Net technologies are roughly equivalent (I have my preference, of course) but that there are important differences in the ethos of the developer communities that IMHO make Java a better choice overall.

I don’t want to get into a flame war here, but Dear Developer… reinforces this quite nicely:

Here’s my point: some of the most influential books on software development and programming such as …hold a vast, deep and rich knowledge of the craft of software development that VB/VB.NET developers are mostly ignorant of. …they should take a look at Enterprise Library from the Patterns and Practices Group at Microsoft (…) for it can save them time, cost and effort in common development situations. I even tell them that it is open source, which means they have access to the code. However, I don’t get much excitement from their part, …, I haven’t even heard of one VB developer simply using Enterprise Library in his projects. The same goes for projects like nHibernate, the Castle project, NUnit, even mocking tools like Rhino.Mocks and Moq. That’s very sad, because by not using some of these tools, VB developers tend to stay far behind common practices such as TDD and technologies like ORM tools…

It comes down to: which group of developers is going to create better quality software? This is not a “my for loop has better syntax than yours” question, but a question that speaks to the fundamental ethos of the developer group; to their willingness and ability to embrace and improve with new tools and techniques.

I have witnessed several .Net teams operate and it has always seemed to me that they have been pushed into adopting the technology and are looking for the minimal step to take, for the minimal change to their toolkit or their technique toolbox, for the quickest way to return to their comfort zone.

This is not universal, of course (trust me; I have seen things come from the Java/J2EE communities that would curl your hair!) but my experiences point to the truth of what I have written.

To me, this is the key differentiator.

http://java.sun.com/ … /reallybigindex.html.

Even though I have been programmng in Java for lo these many years (SDK 0.98 on a Mac Duo 280c; circa 1995/6), I’ve never seen this before.