最大的卖点在于把内存分成不同的 region，有 Young GC、MixedGC、Full GC

改进点在于。 1. stop the world，把和 GC Roots 直接相关的进行标记 2. 解除 stw，应用线程和并发的依赖标记线程一起做； 3. stop the world，把标记期间应用线程影响到的线程进行标记； 4. 解除 stw，和应用程序同时一起清除没被标记的对象。

改进点在于多个线程并行进行垃圾回收，但是回收期间还是 stw。

It is very unclear, String will be stored in PermGen in JDK 6, but PermGen is one part of Heap memory too.

So, whenever String objects will be stored in Heap.

Young GC = Minor GC

After a Young GC, if too many objects survice, they are prompted directly to the old generation.

future.thenApply(value -> value.length()); The registration of callback function does NOT guarantee which thread (new or old) will server to do this logic.

meta annotation - Target - TYPE: class - FIELD: class's member variables - METHOD - PARAMETER

JDK automatic proxy

1. JDBC Driver
2. Spring IOC load bean from configuration files .xml

our objects are reachable or not. searching from GC Roots.

1. new
2. Clazz object's newInstance()
3. clone
4. serialization
5. factory (e.g. ThreadExecutors)

if we know the clazz object, we can know what we define in code in reflection mechanism. but if we only have one of the object, we can not know what is exact parameter when creating because of type erasure mechanism.

2 main reasons: - code reuse, developers don't need to prepare different version of code for different types. - compile-time checking instead of runtime checking, e,g, if we want put “123” and 123 in a list, but if this list can only store Integer? if we use generic, such as List<Integer> we can discover it on compile-time.

generic

1. Cloneable interface, and implement the clone method.
2. Serializable interface, using streaming to realize clone
3. mutual implementation

so we should outer.new Inner() ?

SOILD: - S for Single, every class must take 1 role. - O for Open, open for extension, close for modification - I for Interface, it should be small and specific - L for Liskov, subclass object can replace all parent class object - D for Dependency, Dependency Inverse.

Polymorphism in Java: 1. overload 2. override 3. interface 4. up-casting and down-casting

• compile-time polymorphism: overload
• runtime polymorphism: override

1. What is boxing and unboxing
2. boxing: int \(\rightarrow\) Integer
3. unboxing: Integer \(\rightarrow\) int
4. When Java will do boxing and unboxing
5. assignment, e.g. java Integer x = 1; // boxing int y = x; // unboxing
6. method invocation java private void printInt(int x) { System.out.println(x); } Integer a = 1; // boxing printInt(a); // unboxing
7. potential efficiency problem: Integer sum = 0; for (int i = 0; i <= 1000000; i++) { sum += i; } boxing & unboxing is automatic, but need time!!! it will create many disposable Integer objects, which will increase GC pressure.

if we define BigDecimal a = 1, b = 3, and run a.divide(b), the target answer will be 0.333333... which can not represent in BigDecimal format, so it will throws an ArithmeticException.

If we want to fix this, we should use rounding mode, e.g. half_up (\(1.04 \rightarrow 1.0, 1.05 \rightarrow 1.1\))

• equal() return true or false, means a.unscaledvalue == b.unscaledvalue && a.scale == b.scale
• compareTo return number -1, 0, 1, means a < b, a == b, a > b

BigDecimal.valueOf(0.1) - step #1: 0.1 \(\rightarrow\) "0.1" - step #2: "0.1" $\rightarrow$ BigInteger = 1, scale = 1

asserts 一般用来存储那些不变的模板

• basic data types conversion problem
• data overflow, e.g. long to int
• precision loss, e.g. double to float
• object conversion problem
• upcasting, son to father, is ok, e.g. Cat to Animal
• downcasting, father to son, is maybe not ok, we must use forced casting, e.g. Animal to Cat, ClassCastingException

we should use instanceof to judge

4 types of data conversion: 1. automatic type conversion, e.g. int to long 2. forced type conversion, e.g. long to int 3. String to Object, e.g. Integer.parseInt() 4. basic data type \(\leftrightarrow\) their wrapper class

• automous type conversion, int \(\rightarrow\) long cpp int a = 10; long b = a;
• force type conversion, long \(\rightarrow\) int cpp long c = 10L; int d = (int) c;

• byte(1 byte), short(2 bytes), int(4 bytes), long(8 bytes)
• float(4 bytes), double(8 bytes)
• boolean(1 bit)
• char(2 bytes)

• Python: almost pure interpreted language.
• Java: 2 stages, (1) .java \(\rightarrow\) .class, compiled; (2) .class \(\rightarrow\) bytecode, interpreted(iced code) & compiled (hot code)

very important trade-off: efficiency vs. platform independence - compiled language: 1. source code compiles to the target platform's bytecode, 2. run or debug. run very fast online but development and changing platform is slow. - interpreted language: 1. interpret each line of source code in each platform, it is very easy to change environment and develop but slow

1. JVM = Java Virtual Machine, .class to bytecode
2. compile once (get .class) run anywhere (different platform has its own different platform-specific JVM)

invocation counter: if a method is frequently invoked, it will be hotter.

for (int i = 0; i < 100_000; i++) { calc(); }

JVM < JRE < JDK - JVM: run Java bytecode; or core engine - JRE: JVM + ClassLoader + library, providing runtime - JDK: JRE + javac + javadb + develop tools, providing development environment.

1. .java \(\rightarrow\) .class, “compile once”.
2. each platform will have its own JVM, mapping .class \(\rightarrow\) machine code, "run anywhere".

JVM is the most key software.

Java's 3 main strength: 1. Platform Independence 2. Memory Control, CC 3. strong ecosystem

比如 \(x_1, x_2\) 先算 \(x_1\) 还是先算 \(x_2\) 导致决策树不同，但是表示函数可以是同一个。

几何空间

1. Penalized \(\rightarrow\) Constrained: proof by contradition
2. Constrained \(\rightarrow\) Penalized: Lagrangian duality

System One Model 指的是快速判断模型，不像普通 LLM 一样生成一大堆文本，而是做快速判断（Noul）、分类（Choice）、打分（Score）

DSPy 是一个用代码来优化 LLM 应用的框架。

传统的 Prompt Engineering：手写提示词、调模型、结构不好、人肉修改 Prompt

DSPy：定义任务模块、准备训练和验证样本、定义评分指标、DSPy 自动优化 Prompt 和示例