update

content/courses/prog-intro/_index.md

@@ -0,0 +1,5 @@
+---
+title: Introduction to Programming in Java
+weight: 3
+---
+

content/courses/prog-intro/homeworks/_index.md

@@ -0,0 +1,4 @@
+---
+title: Homeworks
+weight: 4
+---

content/courses/prog-intro/homeworks/sum/ParseIntExample.java

@@ -0,0 +1,12 @@
+// ParseIntExample.java
+
+public class ParseIntExample {
+
+    public static void main(String[] args) {
+        String s = "123";
+        int sum = 321;
+        //! sum = sum + s;
+        sum = sum + Integer.parseInt(s);
+        System.out.println(sum);
+    }
+}

content/courses/prog-intro/homeworks/sum/Sum.java

@@ -0,0 +1,17 @@
+// Sum.java
+
+public class Sum {
+    public static void main(String[] args) {
+        System.out.println("number of arguments: " + args.length);
+        
+        int sum = 0;
+        for (String argument : args) {
+            sum = sum + argument;
+            System.out.println(argument);
+            System.out.println(sum);
+        }
+        
+        System.out.println(sum);
+    }
+}
+

content/courses/prog-intro/homeworks/sum/_index.md

@@ -0,0 +1,245 @@
+---
+title: Sum
+weight: 5
+---
+
+# Task
+ 
+1. You need to create a `Sum` class which will sum integers from command line arguments and output the sum to console.
+2. Examples:
+
+    ```sh
+    java Sum 1 2 3
+    ```
+
+    Expected output: `6`.
+
+    ```sh
+    java Sum 1 2 -3
+    ```
+
+    Expected output: `0`.
+
+
+    ```sh
+    java Sum "1 2 3"
+    ```
+
+    Expected output: `6`.
+
+    ```sh
+    java Sum "1 2" " 3"
+    ```
+
+    Expected output: `6`.
+
+    ```sh
+    java Sum " "
+    ```
+
+    Expected output: `0`.
+
+3. Arguments can be:
+    - digits,
+    - signes `+` and `-`,
+    - [space symbols](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Character.html#isWhitespace(char)) 
+
+4. You can assume that `int` type is sufficient for in-between calculations and result.
+5. Before doing the task make sure to read docs for classes [`String`](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/String.html) and [`Integer`](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Integer.html).
+6. For debugging use [`System.err`](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/System.html#err), because it will be ingnored by the testing program.
+
+--- 
+
+# Solution
+
+After reading about [`String`](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/String.html), [`Integer`](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Integer.html), [`System.err`](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/System.html#err) we now know about some usefull methods:
+
+- [`Integer.parseInt(String s, int radix)`](https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html#parseInt-java.lang.String-) which parses the string argument as a signed integer in the radix specified by the second argument. So it basically converts a number from the `String` data type to `int`.
+- [`Character.isWhitespace(char ch)`](https://docs.oracle.com/javase/8/docs/api/java/lang/Character.html#isWhitespace-char-) which checks if a character `ch` is a space symbol or not.
+
+Now let's start coding. Firstly let's define the structure of our program. I will be putting the name of the file at the first line comment in a file and its path if its nessesary.
+
+```java
+// Sum.java
+
+public class Sum {
+    public static void main(String[] args) {
+        // ...
+    }
+}
+```
+
+Okay that's done. What do we do next? Let's look at `String[] args` argument to our `main` method. It represents an array of command line arguments which we need to sum. So know we made our task a little bit easier. Now we can just say that we need to find sum of elements of array `args`.
+
+How are we going to do it though? First let's understand what we can do with this array. Let's modify our class a little bit.
+
+```java
+// Sum.java
+
+public class Sum {
+    public static void main(String[] args) {
+        System.out.println(args.length);
+    }
+}
+```
+
+We've added `System.out.println(args.length)` which takes the field `length` from our `args` object and prints it to the console.
+
+Let's try it. First compile our class using 
+
+```sh 
+$ javac Sum.java
+```
+
+And then we can do some manual testing.
+
+```sh
+$ java Sum 1 2 3
+3
+```
+
+We got `3` as an output as expected. We gave our program 3 command line arguments: `1`, `2` and `3`.
+
+Here are all of the examples 
+
+```sh
+$ java Sum 1 2 -3
+3
+```
+
+```sh 
+$ java Sum "1 2 3"
+1
+```
+
+> [!NOTE]
+> Notice, that we got 1 instead of 3. That's because we put our arguments in `""` so this becomes a single string argument.
+
+```sh 
+$ java Sum "1 2" " 3"
+2
+```
+
+```sh
+$ java Sum " "
+1
+```
+
+> [!NOTE]
+> Here program gives us 1 instead of 0, because despite not having any numbers in the arguments a single whitespace is still an argument.
+
+Now let's try not obly to count our arguments but to list them as well. Let's modify our program a little bit more.
+
+```java
+// Sum.java
+
+public class Sum {
+    public static void main(String[] args) {
+        System.out.println("number of arguments: " + args.length);
+        
+        for (String argument : args) {
+            System.out.println(argument);
+        }
+    }
+}
+```
+
+Here I used `for` loop to do printing ***for*** every `String` element in `args`.
+
+Let's try this with our examples. And don't forget to recompile using `javac Sum.java`.
+
+```sh
+$ java Sum 1 2 3
+number of arguments: 3
+1
+2
+3
+```
+
+```sh
+$ java Sum 1 2 -3
+number of arguments: 3
+1
+2
+-3
+```
+
+```sh
+$ java Sum "1 2 3"
+number of arguments: 1
+1 2 3
+```
+
+> [!NOTE]
+> Again, notice only ***one*** string argument. 
+
+
+```sh
+$ java Sum "1 2" " 3"
+number of arguments: 2
+1 2
+ 3
+```
+
+```sh
+$ java Sum " "
+number of arguments: 1
+ 
+```
+
+Okay, now that we know how to ***iterate*** (or do something for every element), we can calculate the *sum* of all the numbers in the `args` array. To do that we need to create a new variable `sum` of *integer* type and assign it the **value** of `0`. Then for every number in `args` we will add it to `sum`, and so by the end of array we will have the sum of all numbers stored in variable `sum`. This is what the code will look like
+
+```java
+// Sum.java
+
+public class Sum {
+    public static void main(String[] args) {
+        System.out.println("number of arguments: " + args.length);
+        
+        int sum = 0;
+        for (String argument : args) {
+            sum = sum + argument;
+            System.out.println(argument);
+            System.out.println(sum);
+        }
+        
+        System.out.println(sum);
+    }
+}
+```
+
+Seems ok. But let's test it.
+
+```sh
+$ javac Sum.java
+Sum.java:9: error: incompatible types: String cannot be converted to int
+            sum = sum + argument;
+                      ^
+1 error
+```
+
+We got a compilation error that says `String cannot be converted to int`. It means that when we try to add 2 variables `sum` and `argument` their types don't match. The type of `sum` is integer and string for `argument`. It seems pretty logical because what do we expect when adding for example `1` and `apple`?..
+
+> [!IMPORTANT]
+> So we need to *cast* `argument` to integer data type so that we can add it to `sum`.
+
+We can do so using [`Integer.parseInt()`](https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html#parseInt-java.lang.String-) method.
+
+It takes a `String s` and returns an `int`, which a string `s` represents. For example this code will work as expected
+
+```java
+// ParseIntExample.java
+
+public class ParseIntExample {
+
+    public static void main(String[] args) {
+        String s = "123";
+        int sum = 321;
+        //! sum = sum + s;
+        sum = sum + Integer.parseInt(s);
+        System.out.println(sum);
+    }
+}
+```
+
+The commented out line (`//!`) would have given us an exception.

content/courses/prog-intro/lectures/_index.md

@@ -0,0 +1,4 @@
+---
+title: Lectures
+weight: 4
+---

content/courses/prog-intro/lectures/intro.md

@@ -0,0 +1,145 @@
+---
+title: Lecture 1. Introduction
+weight: 5
+---
+
+# Why do we choose Java?
+
+According to **TIOBE Programming Community Index** Java is one of the most demanded languages in the programming field.
+
+![TIOBE Programming Community Index](assets/tiobe.png)
+*Img. 1 - TIOBE Programming Community Index*
+
+Also, Java has a lot of advantages for beginners such as:
+
+* It's fairly easy
+* It has a broad spectre of usage
+    * Server
+    * Desktop
+    * Mobile devices
+    * Smart-cards
+
+# What does Java consist of?
+
+Java consists of multiple main components. The first one being the **Java compiler**. The process of converting *human-readable* text to *machine code* is called **compilation**.
+
+![Compilation Process Simplified](assets/compilation-process-simplified.svg) 
+*Img.2 - Simplified Compilation Process*
+
+The behaviour of the Java compiler is described by the [Java Language Specification](https://docs.oracle.com/javase/specs/) or JLS.
+
+Let's talk about compilers a little bit. For example if we will take *C++*. If we take C++ compiler for *x86-64* platform and *Windows* operating system, and launch the compiler on source code it will turn it directly into assembly code.
+
+![C++ code compilation under x86-64](assets/cpp-x86-64-compilation.svg) 
+*Img. X -- C++ code compilation process under x86-64 architecture.*
+
+But what if I want to run my program on *Linux* instead of Windows. I will need to take a different compiler under different operating system and recompile my code using a new compiler. It's not very convenient. 
+
+Java tries to protect us from that. By converting the *Java source code* into *Java byte code*. And then the *byte code* will be ran on the *Java virtual machine* which will run our program on the native processor.
+
+![Java code compilation](assets/java-code-compilation.svg) 
+*Img. X -- Java code compilation*
+
+This approach allows to change only **JVM** according to our platform (*x86_64, ARM, ...*) and operating system (*Windows, MacOS, GNU-Linux, ...*) while *byte code* stays the same. We can only write our code once, than compile it and run under everywhere. 
+
+As the motto says:
+
+> Write once -- ~debug~ run everywhere.
+
+ The third component of Java is the standart library which is included in the JVM. 
+
+There are multiple redactions of Java-platforms:
+
+* Standart edition
+  - *For regular aplications*
+* Enterprise edition
+  - *For server aplications*
+* Micro-edition
+  - *For mobile aplications*
+  - *Isn't in use nowadays 🪦*
+* Java Card
+  - *Sim- and smart-cards*
+
+There also were multiple versions of Java throughout its history.
+
+
+- JDK 1.0 (Jan 1996)
+- J2SE 1.2 (Dec 1998)
+  * *Collections Framework*
+- J2SE 5.0 (Sep 2004)
+  * *Generics*
+- Java SE 8 (Mar 2014)
+  * *Streams and Lambdas*
+- Java SE 9 (Sep 2017)
+  * *Modules*
+- Java SE 10 (Mar 2018)
+  * `var`
+- Java 11 (Sep 2018)
+  * `jshell`
+- Java 17 [LTS-old] (Sep 2021)
+  * *Previous stable version*
+  * *Many little changes*
+- Java 21 [LTS] (Sep 2023)
+  * *Current stable version*
+- Java 25 (Sep 2025)
+  * *Next version*
+
+Java comes in two parts: **JDK - Java Development Kit** and **JVM - Java Virtual Machine**.
+
+There is also a **JRE - Java Runtime Environment**. For example if we want to run our code somewhere on the server we don't need to compile it there because we have our byte code and we just need JRE to run it.
+
+Some of the most popular JVMs right now are:
+
+- OpenJDK
+- Eclipse
+- Azul Systems
+- Excelsior JET
+
+The disadvantage of such system is in the connection between JVM and a native processing unit. In case of C++ compiler that we reviewed earlier the source code is compiled directly into machine-code but in case with Java it is compiled into byte-code. And so the problem is to develop such a JVM that would quickly turn our byte-code into machine-code. Anyway it takes extra time. That's why it mostly will be slower than direct compilation into machine-code. So ultimately while we have the advantage of compiling out code only once, we have the disadvantage of turning byte-code into machine-code slower.
+
+None the less, there is a way to speed up this process which is called JIT - Just In Time compilation. How does it work? While our program is running some of the instructions or functions turns directly into processor commands. 
+
+# What is garbage collection?
+
+For example we have `int` which is represented with 4 bytes of data which is directly stored in memory.
+
+![`int` in memory](assets/int-in-memory.svg)
+*Img. X -- `int` in memory*
+
+But what if we have a `String`. How many memory cells does this string take? We don't know. We will say that our `String` that has length of 5 symbols is stored at `0x12347865`. We defined an address where this string is located in memory. And somewhere in the memory of our programm will be a large buffer where the 5 cells will be stored. 
+
+![`String` in memory](assets/string-in-memory.svg)
+*Img. X -- `String` in memory*
+
+But what do we do with that buffer? We won't need it forever and so sometimes we need to clear that buffer. In case with C/C++ whoever created the memory for that string is in charge of clearing it. There are also languages with garbage collection such as Java and Python. The purpose of the **Garbage Collector** is to automatically find variables that we no longer need and clear their memory.
+
+Suppose we have some code like this.
+
+```java 
+if (someCondition) { 
+    x = [1, 3, 7] // first link 
+    // some code here 
+    y = x // second link 
+    // some code here 
+} // no links
+```
+
+After the `if`-statement we no longer need `x` or `y`. Every variable in this case `x` and `y` is the link to our array (`[1, 3, 7]`). After we left the `if`-statement the amount of links to the array is zero, so we can safely delete the array. This approach is implemented in Python. The problem is that if we have to objects linked to one another and there are no external links, they will not be deleted by garbage collector since there link counter is 1. 
+
+![Edge case for link couting](assets/edge-case-for-link-counting.svg)
+*Img. X -- Edge case for link counting*
+
+The advanced way of implementing the garbage collection is *traversing the graph of links* which is implemented in Java, C# and Go.
+
+# What other advantages does Java have?
+
+- It's easy (in terms of syntax)
+- It's secure and stable
+- It supports Unicode
+- It supports multithreading
+- It has backwards compatibility
+
+# How should Java code look like?
+
+You can go and learn about it [here](https://google.github.io/styleguide/javaguide.html). 
+