lessons

Lessons:

Lesson 01 - Introduction and Modern VMs, e.g. JVM, Node

Bibliography and Lecturing methodology: github and slack.
Tools: javac, javap, kotlinc, JDK 17 and gradle.
Program outline in 3 parts:
1. Java Type System and Reflection;
2. Metaprogramming and Performance;
3. Iterators versus Sequences (yield). Generics and Reified type parameters.
Project in 3 parts according to program outline.

Managed Runtime:
- Software components = Metadata + IR (intermediate representation) (e.g. bytecodes)
- Portability - Compile once and run everywhere.
- Jitter - Just-in-time compiler
- Safety - NO invalid memory accesses
- GC - Garbage Collector.
- ClassLoader and CLASSPATH - dynamic and lazy load.
CLASSPATH
Interoperability Java <> Kotlin supported by JVM.
Using javap -c -p Point.class to inspect metadata and bytecodes definition of data class Point
- Kotlin properties x, y and module map to methods getX(), getY() and getModule().

Type System - Set of rules and principles that specify how types are defined and behave.
Types are defined through Classes or Interfaces
- On JVM types are defined through Classes.
Classes have Members.
Members in JVM may be Fields or Functions (aka as methods).
Members in Kotlin may be Properties or Functions.
There are NO Properties at JVM level.
A Kotlin property may generate:
- Backing field -- accessed with getfield bytecode.
- Getter, i.e. function get... -- called with invoke... bytecode.
- Setter, i.e. function set... (if defined with var).
Kotlin val <=> Java final.
Any <=> Java Object, which is the base class of all classes.
Implicit call to base constructor ...: Any():
- bytecodes: invokespecial Object.<init>()
new in Java and new in bytecodes.
new is implicit in Kotlin.

Component - Reusable software unit, with:
- IR - code in intermediate representation (e.g. bytecodes, IL, other)
- Metadata - auto description
- Ready to use => does not require static compilation.
- API => conforms to a public interface.
- Indivisible => 1 module (file)
Software development by Components:
- Reduce Complexity;
- Promote Reuse.
Developer roles:
- Provider - provides a component with a well-known API (e.g. Point)
- Client - uses the component from a provider to build an Application, or another component (e.g. App).
Unmanaged <versus> Managed
Static <versus> Dynamic link

Building unmanaged components with static link:
- NOT a unit, but two parts instead: header + obj
- Need of a header file that describes the component content
- Different builds for different architectures
- Structural modifications (new header) => compilation + link
- Behavioral modifications => link
Demo with an unmanaged App using a Point.
Demo with a managed App using a Point.
- Jitter (just-in-time compiler) - compiles IR to native code (e.g. x86, amd64, ppc) at runtime
- Dynamic link - Point.class on App compilation + link at runtime.
- Lazy Load - Point.class is loaded only when needed

Reflection object oriented API for metadata
Java Reflection API (java.lang.reflect): Class, Member, Method and Field.

KClass is representing a type in Kotlin, whereas Class is representing a type in JVM.
KClass --- .java ---> Class
Class ---- .kotlin ---> KClass
ClassLoader and URLClassLoader
loadClass(): Class
Closeable interface and Kotlin extension use()