Jason5Lee

Some recommended books for improving as a software developer

Most software books are too language specific and go out of date too quickly. What I find has stayed with me are books about bigger concepts, such as systems thinking and complexity, and also so-called "soft skills" such as management and psychology.

User experience

These are all really about developing empathy for other people :)

• "The Design of Everyday Things" by Donald Norman

Jason5Lee

// The following task would create a `classpath` directory under the build dir, with a copy of the built jar and links of every jar from classpath.
// You can start the project by `java -classpath "classpath/*" MainClass`.
// This is useful for creating a personal-used script reusing gradle cache.
// This idea is inspired by the pnpm project.
task("linkClasspath") {
    val jarTask = tasks.getByName("jar", Jar::class)
    dependsOn(jarTask)
    doLast {
        val targetDir = File(buildDir, "classpath")
        if (!targetDir.mkdirs()) {

Jason5Lee

/// Warning: the following code is made for experiment.
/// If you cause losses due to the use of this code in production, I am not responsible.

#[derive(PartialEq, Eq, Clone, Debug)]
pub struct List<T = ()>(pub Vec<T>);
#[derive(PartialEq, Eq, Clone, Debug)]
pub struct Id<T = ()>(pub T);

pub trait HKT<T> {
    type Actual;

Jason5Lee

import Control.Concurrent
import Control.Concurrent.Async

delayHello n = do
    threadDelay (n * 100)
    let hello = show n ++ ": Hello World!"
    putStrLn hello
    
delayHello :: Int -> IO ()
delayHello n = do

Jason5Lee

// [dependencies]
// lazy_static = "1.4"
// crossbeam-channel = "0.4"

use crossbeam_channel::{unbounded, SendError, Sender};
use lazy_static::lazy_static;
use std::thread;
use std::time::Duration;

lazy_static! {

Jason5Lee

Inspired by elizarov/DeepRecursiveFunction.kt.

Normally, when recursively evaluating the depth of a deep tree, it will result in stack overflow error. But, by using async/await, it keeps its stack on the heap, and evaluates correct result without error.

C#

public static class Program
{

Jason5Lee

type USD = number & { readonly __brand: unique symbol }
type EUR = number & { readonly __brand: unique symbol }

type Currency = USD | EUR;

function addCurrency<T extends Currency>(a: T, b: T): T {
    return (a + b) as T;
}

addCurrency(5 as USD, 6 as USD);

Jason5Lee

In Kotlin, a coroutine can be abandoned by not resuming it. If a coroutine is abandoned while suspending in a try-block with finally, the finally clause will not be executed until the coroutine is collected.

For example, the following Kotlin code

val seqWithFinally = sequence {
    try {
        yield(Unit)
        yield(Unit)