JVM, JRE, JDK, and Your First Program

public class Demo {
    public static void main(String[] args) {
        System.out.println("Hello from bytecode");
    }
}

public class Bytecode {

    // Compile Demo.java from the previous exercise, then run:
    //     javap Demo
    //     javap -c Demo
    // Read the output and fill these in. Instruction names only, no numbers.

    // TODO: which instruction holds your text?
    static String instructionThatLoadsAConstant() { return "?"; }

    // TODO: which one reads System.out?
    static String instructionThatReadsAStaticField() { return "?"; }

    // TODO: which one calls println on that object?
    static String instructionThatCallsAMethodOnAnObject() { return "?"; }

    // TODO: add a static method to Demo, call it, recompile, and look again
    static String instructionThatCallsAStaticMethod() { return "?"; }

    // TODO: look at the first block, the one named after the class itself
    static String instructionThatCallsAConstructor() { return "?"; }

    // TODO: which instruction ends every method in the output?
    static String instructionThatEndsAMethod() { return "?"; }

    // ---- the thing at the top you did not write ----

    // TODO
    static boolean classFileHasAConstructorYouDidNotWrite() { return false; }

    // TODO: which class does it call into? Write down the answer and move on.
    static String classThatHiddenConstructorCalls() { return "?"; }

    // ---- what this tells you ----

    // TODO: is bytecode machine code for the processor in your laptop?
    static boolean bytecodeIsMachineCodeForYourProcessor() { return true; }

    // TODO: open Demo.class in a text editor. Is the file itself readable?
    static boolean classFileOnDiskIsBinary() { return false; }

    public static void main(String[] args) {
        System.out.println("load a constant     : " + instructionThatLoadsAConstant());
        System.out.println("read a static field : " + instructionThatReadsAStaticField());
        System.out.println("call on an object   : " + instructionThatCallsAMethodOnAnObject());
    }
}

public class Break {

    // TODO: the rule, worked out from the four messages you collected.
    // Return "javac" or "jvm".
    static String whoReported(String message) {
        return "?";
    }

    // ---- the four failures you caused ----
    // Cause each one, copy the exact message, then say who produced it.

    // TODO: 1. delete a semicolon and compile
    static String whoReportedMissingSemicolon()  { return "?"; }

    // TODO: 2. rename the class inside Demo.java to Hello, and compile
    static String whoReportedFilenameMismatch()  { return "?"; }

    // TODO: 3. change main to mian, compile (it will work), then run
    static String whoReportedMisspeltMain()      { return "?"; }

    // TODO: 4. compile, delete Demo.class, then run java Demo
    static String whoReportedMissingClassFile()  { return "?"; }

    // ---- what that tells you ----

    // TODO: number 3 compiled. Does javac check that a main method exists?
    static boolean compilerChecksThatMainExists() { return true; }

    // TODO: what does a javac message always contain that a JVM message never does?
    static boolean javacMessagesNameASourceLine() { return false; }
    static boolean jvmMessagesNameASourceLine()   { return true; }

    public static void main(String[] args) {
        // Paste your four real messages in here and check your rule against them.
        String[] messages = {
            "TODO",
        };
        for (String m : messages) {
            System.out.println(whoReported(m) + "  <-  " + m);
        }
    }
}

public class Warmup {
    // Some work that is worth compiling. Deliberately simple.
    static long work(int n) {
        long total = 0;
        for (int i = 0; i < n; i++) {
            total += i % 7;
        }
        return total;
    }

    public static void main(String[] args) {
        for (int round = 1; round <= 20; round++) {
            long start = System.nanoTime();
            long result = work(2_000_000);
            long took = (System.nanoTime() - start) / 1_000_000;
            System.out.println("round " + round + ": " + took + " ms  (result " + result + ")");
        }
    }
}