Programming Language on Louis's blog

速通Kotlin

Mon, 10 Feb 2025 03:36:36 +0000

工作需要学习一下Kotlin，写一篇速通笔记。

思路

首先再复习一下看K&R学到的编程语言思路。

变量声明，赋值，以及数据类型
函数定义
Collections（集合类）以及迭代方法
操作符
Flow-of-control
内存管理模型
I/O
编译

1. 变量

Kotlin声明方式有两种, var（引用可变）与val（引用不可变）。推荐不可变。这个可以类比js的let和const。

类型可以参考Java，基本没有变化。其声明方式类似Py或者TS。

val nullableString: String? = null

此外Kotlin支持空安全，syntax为类似String?

2. 函数的定义

fun <function-name>(<function-args>): <return-type> {
    // body
}

和js一样，kt的函数是一等公民，可以作为参数和返回值。

此外kt还有一种非常神奇的中缀函数，可以将函数当一个operator来使用。

infix fun Int.plus(x: Int) = this + x
1 plus 2

Kotlin的Lambda比较有意思。

val function_variable = { <parameters> -> <body> }

eg.

val sum = { x: Int, y: Int -> x + y }

Lambda如果只有一个参数也可以用it隐式引用。

val square = { it: Int -> it * it }
// 或者
val square: (Int) -> Int = { it * it }

list.filter { it > 0 }  // 过滤正数

Lambda可以多行。最后一行为返回值。

val transformer = { x: Int ->
    if (x > 0) {
        println("Positive number")
        x * 2
    } else {
        println("Non-positive number")
        0
    }
}

3. Collections

Kotlin常用的聚合类有三种，并且每一种都有Mutable和Immutable的Variant。

List / MutableList：数组
Map / MutableMap：k-v pair
Set / MutableSet：无重复元素的集合

一样地可以迭代。

// 列表迭代
val list = listOf(1, 2, 3)
for (item in list) {
    println(item)
}

// Map迭代
val map = mapOf("a" to 1, "b" to 2)
for ((key, value) in map) {
    println("$key -> $value")
}

4. 特殊操作符

除了各个语言中经常出现的操作符外：

4.1 Elvis

代表的意思是“如果非空则前，如果空则后”。

val name: String? = null
// 如果name为null，使用"Unknown"
val displayName = name ?: "Unknown"

4.2 区间

// 闭区间
for (i in 1..5)

// 开区间
for (i in 1 until 5)

// 步长
for (i in 1..10 step 2)

// 倒序迭代
for (i in 10 downTo 1 step 3)

5. Flow-of-control

并没有非常显著的差别。

最大的差别主要是when的语法

val num = 3
val result = when (num) {
    1 -> "One"
    2, 3, 4 -> "Few"  // 多个值匹配
    in 5..10 -> "Several"  // 范围匹配
    else -> "Many"
}
println(result)  // Few

6. 关于内存和底层

大部分和JVM类似。

目前总体看下来kt的感觉是更加舒适的语法糖和空安全为主。

之后会看看Kotlin Compose Multiplatform。

CPP Primer Reading Note - Ch.2 (Variable and Elementary Types)

Thu, 26 Sep 2024 06:28:54 +0000

Chapter 2 mainly talks about variables and elementary types in C++.

Except for some knowledge that is common for most languages, here are some interesting things I would like to make notes of.

Object

Although many conventions about the meaning of object exist, in C++:

An object is a region of memory that can hold values of a given type.

So “variables” can be regarded as “objects”.

Understanding this can be extremely helpful for further studies.

Reference and pointer

A reference is an alias of an object that must be initialized. A reference is not an object.
A pointer is an object (indeed! It has a memory space, an address and has type.) that can point to another object.

Top-level const and low-level const

Top level const: const int a = 1;
- The const applies constant constraint to the object (top level).
- So the value of a cannot be changed.
- For pointers: int *const ptr = ...
  - The pointer itself is a constant, so the address it points to cannot be changed. But the value of the underlying object can be changed.
Low level const: const int *ptr = ...
- The const applies constant constraint to the object the pointer points to (low level).
- So the value of the object cannot be changed through the pointer.
- IMPORTANT but it doesn’t mean the object itself is a constant. The object can be changed through other means. Imagine that the pointer or the reference “thinks” that the object is a constant, so it refuses to change the object through itself - but the underlying object could be changed through other ways.

Right-to-left reading rule

const int *ptr
- Read from right to left: ptr is a pointer to a constant integer
int *const ptr
- Read from right to left: ptr is a constant pointer to an integer

`constexpr` and `decltype`

constexpr is a specifier that indicates that the value of the variable or function can be evaluated at compile time.
decltype is a specifier that indicates the type of the variable or expression.

About headers

In C++, the header usually contains the declaration of consts, constexprs, and class definitions (because they should only be defined once). The constraints of defining only once can be achieved by using the #ifndef directive.

Scope of const

const has the default scope of a file. If you want to use the const across multiple files, you should use the extern keyword both in the declaration and definition.

Notes about poetry

Sat, 14 Sep 2024 03:52:17 +0000

Why Poetry?

Aside from the traditional requirements.txt / setup.py and conda solutions, Poetry is a modern Python packaging and dependency management tool that leverages the pyproject.toml file to manage dependencies and build packages.

Why `pyproject.toml`?

To start with poetry we must first introduce the pyproject.toml file. This file is a configuration file that is used to manage the dependencies and build process of a Python package. It is a modern alternative to the setup.py file. (Check PEP 518 for more information.)

As a simple example, here is a pyproject.toml file that is generated from poetry:

[tool.poetry]
name = "awesome-package"
version = "0.1.0"
description = "An awesome package"
authors = ["Your Name <youremail@example.com>"]
license = "MIT"
readme = "README.md"
homepage = "https://github.com/username/awesome-package"

[tool.poetry.dependencies]
python = "^3.8"
numpy = "^1.20.0"
requests = "^2.25.0"

[tool.poetry.dev-dependencies]
pytest = "^6.0"
black = "^22.0"

[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

In order to do the same with setup.py, you need to write:

from setuptools import setup, find_packages

setup(
    name="awesome-package",
    version="0.1.0",
    description="An awesome package",
    author="Your Name",
    author_email="youremail@example.com",
    license="MIT",
    packages=find_packages(),
    install_requires=[
        "numpy>=1.20.0",
        "requests>=2.25.0"
    ],
    extras_require={
        "dev": [
            "pytest>=6.0",
            "black>=22.0"
        ]
    }
)

The pipeline is actually mixed with python code, which is not very clean. pyproject.toml on the other hand provides a cleaner and more structured way to manage dependencies and build process.

Functions

Poetry not only handles the dependencies, but also creates a virtual environment automatically, builds the package, and (potentially) publishes it to PyPI through a unified interface.

Some functionalities include:

poetry new: Create a new Python package.
poetry install: Install dependencies based on the pyproject.toml file. This also creates a virtual environment.
poetry add <package>: Add a new package to the dependencies.
poetry remove <package>: Remove a package from the dependencies.

It also enables switching between dev and production environments.

poetry install --only main: Install only the production dependencies.
poetry add --group dev <package>: Add a new package to the development dependencies.

The new poetry uses --group instead of --dev.

Poetry virtual environment

One key feature that is not so intuitive is that poetry automatically creates a virtual environment for each project.

In-project virtual environment

The virtualenv is usually stored in some system folder, but you can also let it init a .venv folder in your project root by setting virtualenvs.in-project option to true:

poetry config virtualenvs.in-project true

Running the scripts

Some may find that if they directly run the script, the dependencies are not found. This is because the virtual environment is not automatically activated, so you need to run the scripts in the virtual environment by prefixing the command with poetry run:

poetry run python my_script.py

or, you can create a shell in the virtual environment, and run the scripts in the shell:

poetry shell
python my_script.py

Configuring in vscode

If you are using the in-project virtual environment, vscode will automatically configure it for you.

If not, you can manually set the python interpreter to the virtual environment by clicking on the python version at the bottom.

First, use poetry to find the path of the virtual environment:

poetry env info --path

Then, in vscode:

Click on the python version at the bottom, and select “Enter interpreter path”.
Paste the path of the virtual environment and select the python executable.

About environment info

If you run poetry env info, you will see two parts: “Virtualenv” and “Base”. The “Virtualenv” part is the virtual environment of the project, and the “Base” part is the system global python environment.

A skim through "K&R" - The C Programming Language (2nd Ed.)

Thu, 05 Sep 2024 14:10:27 +0000

0. Introduction

I came across with a lot of recommendations on one shall start their life in computer science with C/C++. Now, as a guy that have been programming in Python with empty brain since my undergrad CS intro course, I am finding myself asymptotically tending to the state of a diaobaoxia 调包侠, a term in Chinese that means a person that has minimum CS knowledge and finishes all his work on package APIs.

Even though I am not yet a C programmer, the motivation of reading this 1988 book is to “pay respect” to this language that has been the foundation of many modern tools. In other sense:

What is the, somehow, “minimum building blocks” of a programming language?
Learn to appreciate the evolution of the programming languages and many tools that I have been taking for granted.

Do note that this read is a simple skim.

1. Variables, Functions and Scopes

1.1 Variables

That was some time ago, but someday I suddenly asked myself:

What is a variable?

Although might be incorrect, currently I like to think of a variable as a synonym of a memory address, so that you do not need to memorize the hexadecimal itself. After all, down to the assembly, the system just fetch the data from the memory to the registers and write back (at a proper time).

1.2 Functions

Knowing “pass-by-what” is the most important when you learn a new language.

I really like the simplicity of “pass-by-value” in C. Everything passes by value. The essence of modifying the values inside a function is actually passing a copy of the pointer, and you modify what the pointer is pointing to.

Also, I am quite amazed how early a function with variable sized parameter lists was introduced. C can actually support this using the stdarg.h library.

1.3 Scopes and encapsulation

C is not an OOP language. However, there are some concepts that shed lights on later languages. This is actually encapsulation in its youth. Check out those concepts:

static
- If defined out of blocks: Local to the file, not visible to other files.
- If defined inside functions: Local to the func, the variable is not destroyed after the function is done.
const
- The variable is read-only.
extern
- A declaration without definition. The variable is defined in another file.

C provides encapsulation on the file level, and actually takes a strategy that is quite different from OOP languages today that those functions are visible to other files. To do encapsulation you have to use static explicitly. It makes sense if I imagine its way of merging all those files together into an executable…

1.4 Declarations and Definitions

Declaration: Tells the compiler about the type of the variable or function. Does not allocate memory.
Definition: Allocates memory for the variable or function.

Somehow it tells me what it means when I right-click in VSCode and it asks me whether I want to “Go to definition” or “Go to declaration”. Within the context of C it is more than clear.

2. Flow of control

C supports for, while, do-while, if-else, switch-case, and break and continue statements. Pretty much the same like other modern languages.

goto considered harmful? :)

The only thing I would like to take note is its explanation on the for statement.

for (initialization; condition; update) {
    // body
}

is equivalent to

initialization;
while (condition) {
    // body
    update;
}

which clearly solves any confusion of mine on the C style for statement. Thanks. :)

3. “The consistency”

As an analogy I would say that other languages are like cloud services while C is like on-premises. It somehow exposes the “bare metal” to you, but in a simplistic, consistent way.

Strings are arrays of chars terminated by \0.
Array names are pointers to the first element.
- When passed to a function, it decays to a pointer.
Functions are pointers to the entry point.

Pointers does give you headaches, but it really burns everything nearly down to its core - many things are essentially the same.

Extra: Complicated declarations

Complicated declarations is a kind of nightmare in C that you compose function parentheses, pointers, and arrays together. As an example:

void (*bsd_signal(int sig, void (*func)(int)))(int);

I really like this article on geeksforgeeks about how to read complicated declarations in C by using postfix notation.

Simply put, you expand the innermost parentheses first, and then move outwards. At each level, you first look at the variable name, then look right, then look left. This is far too abstract so please check out the article! It is a lot of fun… I hope?

4. Importing?

I do not really think much when I type:

import os

C does the task of pulling the code from other files (or, code from others) using preprocessor directives.

What it does is actually expands the code before the compilation.

#include: Expands the code from the file.
#define: Replaces the text with the defined text.

And, since those functions are visible to other files, a header would be fine to tell the compiler what functions to find.

Do notice that in C, duplicated definitions are not allowed. You kind of appreciate how great the invention of namespaces are.

5. How far is `struct` from `class`?

C does not have classes, but it has struct which is a way to group variables together. I sometimes think that how far away is it from a class in OOP languages.

After all, structs can store variables and even functions inside, and the way of accessing them (obj.var1) is quite similar to OOP languages.

#include <stdio.h>

// Function declarations
void greet() {
    printf("Hello!\n");
}

void farewell() {
    printf("Goodbye!\n");
}

// Define a struct with function pointers
struct Person {
    char *name;
    void (*greetFunc)();     // Function pointer for greeting
    void (*farewellFunc)();  // Function pointer for farewell
};

int main() {
    // Create an instance of Person and assign functions to function pointers
    struct Person p;
    p.name = "Alice";
    p.greetFunc = greet;       // Assign greet function
    p.farewellFunc = farewell; // Assign farewell function

    // Call the functions through the function pointers in the struct
    printf("%s says: ", p.name);
    p.greetFunc();

    printf("%s says: ", p.name);
    p.farewellFunc();

    return 0;
}

Nevertheless, this comparison is somehow meaningless, since structs are tend to be used for data storage. But it is intriguing to see the “sprout” of later languages.

6. Interact with the system

6.1 I/O

I/O in a broad sense can be regarded as a serial input and output, with system calls like lseek to provide random access. But nevertheless it is just like moving a pointer around in a file or to read byte-by-byte from a stream that you do not know where it ends. That’s why EOF is important.

6.2. Exceptions not at home?

It is the first time I know that C does not have built-in exception handling. It is quite a surprise to someone who have been taking try-except for granted.

I remember that the instructor in the Intro to CS in CMU has stressed on “checking the return value of system calls”. Now somehow I know the reasons better, since those kind of exceptions are reported by the return values.

This is probably also why separating the stdout and stderr, and do not reporting errors using print() is a good practice, since people used to have to analyze the return values manually and report the errors to the console.

6.3 Prototypes of formatting and access control

Think of python formatted string:

num = 5
print(f"Number is {num:9.3f}")
# Output: Number is     5.000

In C this is originated from the printf function, where after the % you can specify the width and precision of the output.

%<width>.<precision><type>
// You can also specify 
// left-justified 
// with a `-` before the width

Also think of python’s file access control:

with open("file.txt", "r") as f:
    print(f.read())

In C, you can specify the mode of the file access in the fopen function. There are r (read), w (write), a (append), and b added to those modes to specify binary mode.

FILE *f = fopen("file.txt", "r");

So, many things do have their roots in the history.

7. Epilogue

First, here is my very, very naive overview that I derived from the C language:

Variables
Functions
Operators
Flow of control: Conditionals and loops.
Memory management
Typing system
Set types: Arrays, structs (those types that store multiple variables)
Multiple files and compilation
I/O

Many modern languages do stem from this template, so you get to somehow know the new languages by first looking into this template and know how they operate, then investigate what problems they try to solve using this new language.

I remember a post that said “every time you read K&R after some growth in programming, you will find something new”. I did find many things new in this first quick pass, especially when I have been using high level programming languages for some time. It is like a journey back to the roots and solved many of my confusions. Just like artists have to learn the history of art, I start to think that understanding the low level languages, touching the fundamentals and somehow looking in the past makes you gain some knowledge on where you are standing right now, and peek into the essence of the machine before you.