Some Types are Keywords

For legacy reasons, Java has two kinds of types. There are primitive types that correspond in some manner to machine types, and the reference types that form the class hierarchy. Examples of primitive types would be int or float or void (Unit - only allowed as method return type). In general it's also the case that operators work on primite types but do not for reference types (exceptions apply). Those primitive types are builtin insofar that their type names are keywords as well.

As a homework for the second week I gave the following task: write a program that reads a number between 0 and 100 from the standard input (they don't know about standard input yet, and I'd prefer passing arguments as command line parameters but was overruled) and write a 10 character progress bar, visualizing the progress that correspond to the input number. This is my solution I worked from:

import java.util.Scanner;

class Progress {
  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);

    int progress = input.nextInt() / 10;
    int rest = 10 - progress;

    while (progress > 0) {
      System.out.print("|");
      progress = progress - 1;
    }
    while (rest > 0) {
      System.out.print("-");
      rest = rest - 1;
    }
  }
}

Since this is quite complicated for beginners, I've given them the basic structure and removed all keywords, replacing them with % and replacing all variable names with #. Resulting in this:

import java.util.Scanner;

% Progress {
  % % % main(String[] #) {
    Scanner # = % Scanner(System.in);

    % # = #.nextInt() / 10;
    % # = 10 - #;

    % (# > 0) {
      System.out.print("|");
      # = # - 1;
    }
    % (# > 0) {
      System.out.print("-");
      # = # - 1;
    }
  }
}

And as you can see, not entirely all type information is removed by replacing the keywords with #. If all types were reference types, we'd have a program that looked more like this:

% Progress {
  % % Unit main(String[] #) {
    Scanner # = % Scanner(System.in);

    Integer # = #.nextInt() / 10;
    Integer # = 10 - #;

    % (# > 0) {
      System.out.print("|");
      # = # - 1;
    }
    % (# > 0) {
      System.out.print("-");
      # = # - 1;
    }
  }
}

Now doesn't this look quite a bit better? Some types are introduced as keywords but all user-created ones are not (and by user-created, I also mean the standard library). This is an inconsistency that is quite hard to explain away, even more so if you have yet to introduce the students to the vocabulary to explain this.

There are even more problems quite soon. Once conditionals are introduced, we have the next problem. The language construct if () then {} else {} only works with the bool type as conditionals. So primitive types are necessary to use the language constructs for conditional execution (while as well, but the numeric comparison follows somewhat naturally).

I do not know whether we will get this far, but for type parameters (for for polymorphic types, like containers) the primitive types don't work either.

All in all, I'd say Java would need to do away with primitive types and consistently use reference types. But for this to work properly with the operators, one would probably also need to add operator overloading. Once you're there, you could think long and hard about whether you'd really need the new keyword for instance construction.

And of course, one would want to introducing a proper Unit type. But since in Java all types are inhabited by the value null (who the hell had that idea?), this would be useless. So I will allow keeping the void keyword.