The function-based nature of C language, the class-based nature of Java, and the string-based nature of Tcl language, they all are the same as bytecode-command-based nature of Assembly Languages: it’s simply a low level. The low level language isn’t an “assembly language” or “system language”. It’s the language that bases on one strict simple “nature” that is used to implement everything.
no, this isn't a definition of a low-level language. it's your're are own definition of the term which is not used by anyone else. it's a definition of a consistent language, which Java isn't because it has things that fall outside of its class/object model (primitive types are not objects, and classes themselves aren't objects either which makes metaprogramming much harder). Ruby and Python are much more consistent with class-based OOP. ironically, the author does mention that later to describe Java as not truly OOP - but that has nothing to do with being high level or low level. he then goes on to sperg about verbosity, interfaces and other shit which is bad language design but again has nothing to do with high and low level languages.
also, C isn't a function-based language. function (which in C is more of a procedure really) is just one of control flow constructs like a loop or a switch/case.
So, Java just changed this undefined behavior into NullPointerException (if we agree that SIGSEGV is what you get, or something similar on Windows, rather than undefined behavior, this is just a cosmetic change).
wrong. NPE can be caught and handled if you know it might happen (arguably, it should be a checked exception with the compiler requiring you to handle it, but that's a whole different problem). and while you could technically install a SIGSEGV handler in C, it will not be portable due to undefined behavior and due to signals being a Unix thing, not a C thing.
try{
Anus myAnus = null;
myAnus.hax();
} catch(NullPointerException e){
System.err.println("HAX MY ANUS!");
}this is valid Java code with a well-defined, predictable and portable behavior. in C, a null pointer is technically undefined and practically actually low-level, in that it defers handling of an invalid address to the OS/hardware.
The only “usage” of reflection I found so far for Java is Java Beans and the implementation of some scripting languages that deal directly with the Java objects (Jython, Jacl). So, as you can see, for things not connected to writing any software in Java language at all!
reflection has its uses, mostly obscure and hard to maintain. more often than not it's an ugly hack, I won't argue with that. but it has nothing to do with high or low level. a low-level approach would be directly accessing the memory of a vtable, or something like that.
tl;dr most of the criticism of Java are right, but they have nothing to do with high or low level. Java is not an assembler