S先生の筆記📒

Run xv6-x86-64 on macOS M

Daniel Sun — Thu, 05 Mar 2026 21:41:33 -0700

https://en.wikipedia.org/wiki/Xv6

I used to believe it’s not possible to run xv6-x86-64 version on macOS with arm chip. It turns out that it is not that hard to do that with qemu.

All we need is to install qemu on your macOS.

brew install qemu

Verify:

which qemu-system-x86_64
$ /opt/homebrew/bin/qemu-system-x86_64

Install cross-compilation toolchain:

$ brew install x86_64-elf-gcc
$ which x86_64-elf-gcc
$ /opt/homebrew/bin/x86_64-elf-gcc

make qemu-nox

Assembly Word

Daniel Sun — Tue, 03 Mar 2026 19:26:59 -0700

在 x86 体系里——不管 16 位、32 位、还是 64 位模式—— WORD 永远是 16 位 = 2 字节。这是历史遗产。早期 8086 是 16 位 CPU。当时“word”就是机器的自然数据宽度——16 位。后来扩展到 32 位：原来的 word 仍然是 16 位新的 32 位被叫做 double word（DWORD）再到 64 位： 64 位叫 quad word（QWORD）所以单位一直叠加： BYTE = 8 bit WORD = 16 bit DWORD = 32 bit QWORD = 64 bit

这里的“double”不是“相对当前模式”，而是相对最初的 16 位 word。

Useful Uou Resources

Daniel Sun — Sun, 22 Feb 2026 14:06:32 -0700

Student Health Center https://studenthealth.utah.edu/

Run x86-64 Docker on Macos

Daniel Sun — Tue, 17 Feb 2026 16:25:29 -0700

决定不玩SRS账户了

Daniel Sun — Sat, 14 Feb 2026 17:58:49 -0700

向SRS账户转入一笔钱的那刻，注定是给自己找麻烦。

新加坡很多理专忽悠我开通SRS账户。基本上连新加坡人也很少玩SRS。

钱转入后，看似可以避税，但是打理这个账户非常麻烦。

首先，SRS需要挂靠在一家银行账户下。为了增值，还需要开通银行的证券账户，所以我还得安装银行的证券App。

本来SRS就那么点钱，还要用专门的App去运作，真是麻烦的很。而且银行证券服务的交易手续费也比在线券商高很多。

终于，三思后，打算把余额转出SRS，此生不碰SRS。

Ampcode

Daniel Sun — Wed, 11 Feb 2026 10:48:29 -0700

Ampcode是我入门Vibe Coding，也几乎成为了日常开发工作的重要工具。

print("hello world");

https://ampcode.com/news/amp-free

https://ampcode.com/free

https://ampcode.com/manual

https://ampcode.com/news/liberating-code-review

两种几何随机变量的定义

Daniel Sun — Mon, 03 Nov 2025 21:50:59 -0700

发现在一些主流教材中，几何型随机变量(Geometric Random Variable)的定义有细微的分歧。主流教材中给的定义是，重复多次的抛硬币试验 (单次试验是Bernoulli experiment)，

Number of flips (failures) until the first heads (success)

但有有些教材会定义为：

Number of flips (failures) before the first heads (success)

虽然中外主流教材都是采用第一种定义，但是遗憾的是R和Python中的概率计算库使用的是第二种定义。

比如为要计算X ~ Geo(0.5)，X = 1的概率，需要传入0：

dgeom(0, 0.5)

这种定义的不一致带来毫无必要的麻烦。

https://en.wikipedia.org/wiki/Geometric_distribution

Hello World

Daniel Sun — Sat, 04 Oct 2025 12:11:53 -0600

有用的Google Colab命令

Daniel Sun — Sat, 06 Sep 2025 16:52:09 -0600

如何将Jupyter Notebook转成PDF

!sudo apt-get install texlive-xetex texlive-fonts-recommended texlive-plain-generic
!sudo apt-get install pandoc

!jupyter nbconvert --to pdf <path to jupyter notebook>.ipynb

犹他大学CS6353：Deep Learning

Daniel Sun — Fri, 22 Aug 2025 11:26:51 -0600

https://d2l.ai/index.html

犹他大学CS 6300：Artificial Intelligence

Daniel Sun — Fri, 22 Aug 2025 11:17:05 -0600

课程主页：https://dsbrown1331.github.io/intro-ai-class/

基本不出所料，这本课程拷贝了Berkeley CS188。

https://inst.eecs.berkeley.edu/~cs188/su25/

Office hours: https://docs.google.com/spreadsheets/d/1l8_Ao3nhnRuwWtWc2FHGDa45U35HzWy-PXrfO-VEAh4/edit?gid=0#gid=0

Piazza: https://piazza.com/class/me9fkw623gc52m

第一章：绪论

An agent is just something that acts.
A rational agent is one that acts so as to achieve the best outcome or, when there is uncertainty, the best expected outcome.

The rational-agent approach to AI has prevailed throughout most of the field’s history. In the early decades, rational agents were built on logical foundations and formed definite plans to achieve specific goals. Later, methods based on probability theory and machine learning allowed the creation of agents that could make decisions under uncertainty to attain the best expected outcome.

In a nutshell, AI has focused on the study and construction of agents that do the right thing. What counts as the right thing is defined by the objective that we provide to the agent. This general paradigm is so pervasive that we might call it the standard model.

Big Nerd Ranch React Programming笔记

Daniel Sun — Sun, 20 Jul 2025 14:43:44 +0800

第十三章

SyntheticBaseEvent is a wrapper that React puts around native events to ensure that events work the same across all browsers. You can access the underlying native event through the nativeEvent property. (However, it is unlikely that you will ever need it.)

Bootstrap Microservices Ch4

Daniel Sun — Wed, 09 Jul 2025 17:21:01 +0700

Testing an internal microservice from the outside is normally only possible in development. Once we move this microservice to production, its REST API is only available within the Kubernetes cluster. In this case, we’ll make it private because we don’t want the outside world having direct access to our video storage. This is a security feature of microservices! We can control which microservices are exposed to the outside world, and we can use that to restrict access to parts of the application that should not be directly accessible by outsiders.

Spring Boot的环境变量

Daniel Sun — Tue, 08 Jul 2025 17:28:00 +0700

在Spring Boot中，环境变量的定义，可以诸如在application.properties中：

server.port=${PORT}

这里的$PORT是一个自定义的环境变量，它将绑定系统预设的server.port，就是服务的端口号。

但是如果要自定义一个环境变量，而没有系统的某个key对应，那就不要在application.properties中绑定？

Bootstrapping Microservices第三章笔记

Daniel Sun — Fri, 04 Jul 2025 13:21:14 +0700

A microservices application, however, isn’t a microservices application if it only consists of a single microservice!

We’d like to add a database, that’s one container, but it’s not something we consider as a microservice.

We could use the local version of Kubernetes that is included with Docker Desktop, but it’s kind of resource hungry (try running it on a laptop if you want to see poor performance) and just not that convenient to use when we’re working on multiple projects.

For now, we can “simulate” Kubernetes on our development computer using Docker Compose, which is much easier and more straightforward than trying to dive straight into Kubernetes.

Why Docker Compose? In the same way that Docker allows us to build, run, and manage a single microservice, Docker Compose gives us a convenient way to build, run, and manage multiple microservices in development. During development and testing, we must frequently boot and reboot our entire application, which will eventually contain many microservices. After each small increment of development, we also must test the changes to our code.

Docker Compose revolves around the Docker Compose file. I like to think of this as a script file that builds a local instance of a microservices application.

The Docker Compose file is a script that specifies how to compose an application from multiple Docker containers.

The Docker Compose file is like a script for building and launching a microservices

Recall the Dockerfile we created, which was a script for building a single image. The Docker Compose file scales this up and allows us to orchestrate the creation of a whole application from a collection of Dockerfiles. Docker Compose reads the Docker Compose file and produces a running application

We’re now building an application that will soon have more than one microservice. We must therefore put each microservice into its own separate subdirectory. Our convention is that each subdirectory will be named after its microservice.

Our Docker Compose file, which is called docker-compose.yaml. Because it doesn’t belong to any single microservice, it lives in the root directory of our microservices application.

services:

 video-streaming:
 image: video-streaming
 build: 
 context: ./video-streaming
 dockerfile: Dockerfile
 container_name: video-streaming
 ports:
 - "4000:8080"
 environment:
 - PORT=8080
 restart: "no"

You might be wondering why we set the restart option to no. When working in development, we don’t want our microservices to automatically restart when they crash. If they did that, we could easily miss problems! Instead, if these crash, we want them to stay that way so that we’ll notice the problem. This is the opposite of how we’d usually like our microservices to work in production. We’ll see later in chapter 11 how we can have Kubernetes automatically restart our production microservices that crash.

The output of Docker commands such as docker ps can be different from the output of docker compose ps. That’s because Docker commands relate to all images and containers on our development computer, whereas Docker Compose commands only relate to the images and containers specified in our Docker Compose file.

In this sense, we’re using Docker Compose like a scoping mechanism. It constrains the commands to apply only to images and containers in our current project. Essentially, it restricts the scope of these commands to the current working directory, which is another useful aspect of Docker Compose.

Put another way, docker compose ps shows us only the containers that are listed in our Docker Compose file, whereas, docker ps shows us all containers on our development computer.

Bootstrapping Microservices V2

Daniel Sun — Sun, 29 Jun 2025 22:52:19 +0700

Chapter 2

Express is the de facto standard for building HTTP servers on Node.js.

Of course, we could build an HTTP server directly on Node.js without Express, but Express allows us to do this at a higher level of abstraction, with less code, and without the nuts-and-bolts code we’d otherwise need using the low-level Node.js API.

npm install --save express

The –save argument causes the dependency to be added to and tracked in the package.json file. Note that –save isn’t necessary anymore. In older versions of Node.js, this was required; these days, it’s the default.

The command npm install by itself (not specifying any particular package) installs all the dependencies listed in package.json.

The file index.js is one of the standard names for the main entry point (main file) of a Node.js application. We could just as easily have called it something else, such as main.js or server.js.

We placed the file index.js under the src directory as a convenient way to keep our source code files separated and easily distinguished from our configuration and other files. The directory doesn’t have to be called src —— you can call it anything you like —— but src is a common name for it. Don’t forget to update your package.json file to include the location of index.js within the src directory.

It’s customary during development to set your Node.js application to listen on port 3000.

Environment variables can be thought of as an input or parameter to our microservice.

Configuring a microservice

We need a way to configure our microservice so it knows the port number to use when starting the HTTP server. There are several techniques we might use to configure our microservice, such as configuration files or command-line arguments. These techniques work, but another has emerged as the standard way to configure a microservice, and it’s well supported by all the tools we’ll be using. We’ll configure our microservices using environment variables.

To run multiple different microservices at the same time, we’ll have to start them on separate port numbers.

export PORT=3000

We can also use environment variables to pass secret and sensitive data into a microservice (e.g., the password for our database). We need to treat this information carefully, and we shouldn’t store it in the code where everyone in the company can see it.

Well, to get our microservice ready to run in production, we’ll use a slightly different version of this command:

npm install --omit=dev

We added the argument --omit=dev to omit development dependencies and only install those dependencies that are required in production. This is important because when creating a Node.js project, we’ll usually have a bunch of these so-called dev dependencies that we only need to support our development efforts—we don’t want to install these into our production environment.

npm script

Up until now, we’ve run our HTTP server on our dev computer like this:

node src/index.js

That’s OK, but now we’ll start running our microservice using the following standard convention for Node.js:

npm start

注：npm start是启用生产环境的惯例。

Invoking the command npm start is the conventional way to start a Node.js application. This is a special case of a npm script.

The nice thing about this convention is that for almost any Node.js project (at least those that follow this convention) , we can run npm start without actually knowing if the main file is called index.js or if it has some other name. We also don’t need to know if the application takes any special command-line arguments or configuration because those details can be recorded here as well.

This gives us a single command to remember regardless of whatever project we’re looking at and however the particular application is started. This makes understanding how to use any Node.js project much easier, even those created by other people.

So far, we set up our microservice to run on our development computer. That’s all well and good—we need that for ongoing development and testing—but before we get to the fun stuff (Docker, Kubernetes, Terraform, etc.), we need to know how to set up our microservice to run in the production environment. When I say production environment, what I mean is our customer-facing environment. That’s where our application is hosted so it can be accessed by our customers. For this book, our production environment is Kubernetes, and we’re gearing up to run our application in a Kubernetes cluster to make it publicly accessible.

Live reloading for fast iteration

To create our live reload pipeline, we’ll install a package called nodemon. We use nodemon to run our microservice, and it automatically watches for code changes in our project. When a code change is detected, nodemon automatically restarts our microservice for us, saving us the effort of doing so manually. This might not sound like it does much at all, but I’ve found that it makes for a fast and fluid development cycle. Once you’ve tried it, you might wonder how you ever did without it.

We can install nodemon in our Node.js project as follows:

npm install --save-dev nodemon

Note that now we’re using the --save-dev argument. This installs the package as a dev dependency rather than a production dependency.

npx command

Now that we’re going to be using nodemon instead, we’ll replace node with nodemon and run it like this:

npx nodemon src/index.js

The npx command that’s suddenly appeared is a useful command that comes with Node.js and allows us to run locally installed packages directly from the command line. Before npx was added to Node.js, we used to install modules such as nodemon globally. Now we can run tools like this directly from the current project’s dependencies. This really helps us use the right versions of modules for each project and prevents our computer from being cluttered up with globally installed modules.

Debugging the container

When we’re running a container locally, especially one that is having problems, it can be useful to shell into it and inspect it from the inside. This can help us understand what’s happening inside our container. We can open a shell into our container like this:

docker exec -it <container-id> bash

From here, you can use common Linux commands such as cd, ls, and ps to inspect the filesystem and process inside the container. This is a valuable technique for debugging and understanding what is going on in your container, so please spend some time exploring inside your container.

创新思维与创业管理

Daniel Sun — Fri, 27 Jun 2025 16:44:24 +0700

创新思维方式：敢于挑战常规和传统模式，用与众不同的思考方式提出全新的想法或者寻找更好解决方案的思维方式；Think different。

要做到它需要：

拆毁心理之墙
多问为什么
第一性原理
多角度看问题

Node Trick 1

Daniel Sun — Thu, 26 Jun 2025 17:32:47 +0700

在Node项目中，要运行npm install，必须要存在package.json。

如果是手动从零新建一个项目，新建package.json后，加入个空的对象。

// package.json

{}

否则，运行npm install foo会报错。

或是用npm init -y来创建，参数-y避免在创建创木时需要回答的一些交互问题。

ETF并不一定是指数ETF

Daniel Sun — Wed, 25 Jun 2025 12:59:22 +0700

ETF (Exchange-Traded Funds)被翻译为“交易所挂牌基金”或是“交易所交易基金”。

不要误认为ETF就是挂钩某个指数(index)的ETF，甚至是宽基指数(broadband index)。

比如KWEB挂钩某个小众指数 — 中证海外中国互联网指数(CSI Overseas China Internet Index)。

CMU: Intro to Ml Notes

Daniel Sun — Sat, 26 Apr 2025 11:24:57 -0600

第一课

Artificial Intelligence (AI): Getting Computers to Behave Intelligently

Do things that people do well (better than computers) A moving target! But usually involves:

Perceptron
Control
Planning
Human language (recognize, understand, respond to, generate)

Example Tasks:

Identify objects in an image
Translate from one huamn language to another
Recognoize speech
Assess risk (e.g. in loan application)
…

1st Attempt: “Knowledge-Based AI” (1960s — 1980s)

= Write programs that simulate how people do it. Problems:

Will never get better than a person
Requires deep introspection
Sometimes requires experts (“expert systems”, “knowledge elicitation”)
Often we don’t know how we do things (e.g. ride bicycle)
- Difference between knowing and knowing-how-we-know
Sometimes we think we know, but we’re wrong

Didn’t work as well as hoped.

Alternative: “Data-Based AI” (a.k.a Machine Learning) (1980s — today)

= Write programs that learn the task from examples.

You don’t need to know how to do it yourself
Performance (should) improve with more examples

But:

Need lots of examples! (millions and billions)
When it finally works, you may not understand how

Lecture 2

ML: Learn a task from experience (examples)

Get better at the task with experience

Medical Diagnosis: f: Patient Info -> {Categories}, Classification

Predict Tomorrow’s Temperature f: (Input) -> R, Regular Regression

ML = Learning a function.

Spring Security in Action 2 Notes

Daniel Sun — Mon, 24 Mar 2025 21:49:33 -0600

Chapter 2

For the apps that you develop with the Spring Framework, Spring Security is an excellent choice for application-level security.

To customize the handling of authentication and authorization, we’ll need to define a bean of type SecurityFilterChain.

An object that implements a UserDetailsService interface with Spring Security manages the details about users.

It is good practice to separate the responsibilities even for the configuration classes.

MongoDB in Action 2笔记

Daniel Sun — Fri, 21 Mar 2025 16:47:35 -0600

Chapter 1

Perhaps the biggest reason developers use MongoDB isn’t because of its scaling strategy, but because of its intuitive data model. MongoDB stores its information in documents rather than rows.

A document-based data model can represent rich, hierarchical data structures. It’s often possible to do without the multitable joins common to relational databases.

… the distinction between a tabular and object representation of data …

The umbrella term NoSQL was coined in 2009 to lump together the many relational database gaining in popularity at the time, one of their commonalities being that they use a query language other than SQL.

The most important thing to remember from its history is that MongoDB was intended to be an extremely simple, yet flexible, part of a web-application stack.

Internally, MongoDB stores documents in a format called Binary JSON, or BSON.

BSON has a similar structure (of JSON) but is intended for storing many documents.

Where relational databases have tables, MongoDB has collections.

The data in a collection is stored to disk, and most queries require you to specify which collection you’d like to target.

The technique of separating an object’s data into multiple tables is known as normalization. A normalized data set, among other things, ensures that each unit of data is represented in one place only.

But strict normalization isn’t without its costs. Notably, some assembly is required.

A document-oriented data model naturally represents data in an aggregate form, allowing you to work with an object holistically.

MongoDB groups documents into collections, containers that don’t impose any sort of schema. In theory, each document in a collection can have a completely different structure; in practice, a collection’s document will be relatively uniform.

Your application code, and not the database, enforces the data’s structure.

To say that a system supports ad hoc queries (即席查询) is to say that it isn’t necessary to define in advance what sorts of queries the system will accept. Relational databases have this property; they’ll faithfully execute any well-formed SQL query with any number of conditions.

One of MongoDB’s design goals is to preserve most of the query power that’s been so fundamental to the relational database world.

With MongoDB, you can create up to 64 indexes per collection.

MongoDB provides database replication via a topology known as a replica set.

Replica sets distribute data across two or more machines for redundancy and automate fail-over in the event of server and network outages.

Since MongoDB v2.0, journaling is enabled by default. With journaling, every write is flushed to the journal file every 100ms. If the server is ever shut down uncleanly (say, in a power outage), the journal will be used to ensure that MongoDB’s data files are restored to a consistent state when you restart the server. This is the safest way to run MongoDB.

MongoDB was designed to make horizontal scaling manageable. It does so via a range-based partitioning mechanism, known as sharding, which automatically manages the distribution of data across nodes. There’s also a hash- and tag-based sharding mechanism, but it’s just another form of the range-based sharding mechanism.

The core database server runs via an executable called mongod. The mongod server process receives commands over a network socket using a custom binary protocol.

The MongoDB command shell is a JavaScript-based tool for administering the database and manipulating data. The mongosh executable loads the shell and connects to a specified mongod process, or one running locally by default.

Chapter 2

MongoDB divides collections into separate databases. Unlike the usual overhead that databases produce in the SQL world, databases in MongoDB are just namespaces to distinguish between collections.

Databases and collections are created only when documents are first inserted.

Every MongoDB document requires an _id, and if one isn’t present when the document is created, a special MongoDB ObjectID will be generated and added to the document at that time.

You can set your own _id by setting it in the document you insert, the ObjectID is just MongoDB’s default.

A query selector is a document that’s used to match against all documents in the collection.

Note that calling the find method without any argument is equivalent to passing in an empty predicate; db.user.find() is the same as db.users.find({}).

Rather, the query itself is a document. The idea of representing commands as documents is used often in MongoDB and may come as a surprise if you’re used to relational databases.

Programming in Python

Daniel Sun — Tue, 18 Mar 2025 20:50:12 -0600

Lists are an extension of an earlier, more primitive concept called arrays.

An older programming concept called a record, which is any data structure that combines several distinct values into an integrated whole.

The individual components of a record are generally called fields.

The simplest way to represent a record in Python is to use a built-in data structure called tuple, which is used in both computer science and mathematics to refer to an ordered, immutable collection of elements.

As it happens, Python programmers rarely refer to the elements of a tuple by their index number because the language offers a convenient syntactic form called destructuring assignment for splitting a tuple into its component elements.

Encode the information for each record as an object containing the necessary fields, which are more often called attributes in the context of a Python object.

In Python, having a reference to an object makes it possible to create new attributes within it.

Data Serialization Formats Useability

Daniel Sun — Fri, 14 Mar 2025 23:11:07 -0600

JSON JSONC JSON5 HJSON YAML TOML XML CSV

Tableau With Postgres

Daniel Sun — Sat, 08 Mar 2025 14:21:01 -0700

本地安装MongoDB 8.0+

Daniel Sun — Wed, 05 Mar 2025 15:13:15 -0700

https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-os-x/#std-label-install-mdb-community-macos

mongosh

The MongoDB Shell, mongosh, is a JavaScript and Node.js REPL environment for interacting with MongoDB deployments.

MongoDB Compass

用命令行启动MongoDB服务器

MongoDB needs a folder/directory to store the database.

启动mongod，需要带上存储路径

% mongod --dbpath /opt/homebrew/var/mongodb

--dbpath参数：Directory for datafiles - defaults to /data/db

% mongod --config /opt/homebrew/etc/mongod.conf

/opt/homebrew/etc/mongod.conf是MongoDB的配置文件

systemLog:
destination: file
path: /opt/homebrew/var/log/mongodb/mongo.log
logAppend: true
storage:
dbPath: /opt/homebrew/var/mongodb
net:
bindIp: 127.0.0.1, ::1
ipv6: true

如果是用homebrew安装的MongoDB，可以这样启动和关闭：

% brew services start mongodb-community

% brew services stop mongodb-community

you should be able to directly interact with the MongoDB database by running the command:

% mongosh

参考

https://web.stanford.edu/class/cs142/install.html

安装PostgreSQL

Daniel Sun — Mon, 03 Mar 2025 15:54:57 -0700

Postgres似乎是比PostgreSQL更cool的称呼。

上一份工作一直在和Postgres打交道。本地Mac开发环境里，Postgres跑在了Docker容器中，非侵入式地安装。然后使用DataGrip提供的可视化界面进行数据查询。

而侵入式地安装Postgres，会把本地文件系统搞得乱糟糟。安装容易卸载难啊。

如果想geek一些的，推荐在Docker中运行Postgres。

本地安装

然而在大学课堂里，大部分教授都不懂Docker，所以课堂上要求侵入式地安装Postgres —— 我也老老实实地照做了。

一种简单的安装方式是直接从Postgres官网下载，在下载页面可找到各平台的Installer安装包。目前最新的版本是17。

初始安装后，界面只会显示默认的postgres数据库。

注意，这里是指在Postgres中的一个叫postgres的数据库。

直接安装Postgres也是有好处的，有一个操作Postgres的极简用户界面。界面上会列出了一个个本地创建的数据库。此外，可以用界面启动、暂停Postgres服务器。

设置PATH环境变量

此外，安装目录带了许多原生的命令行工具，其中有重要的psql命令。它的所在位置如下：

/Applications/Postgres.app/Contents/Versions/17/bin/psql

为了在Terminal运行这条命令，要把Postgres的bin目录放入PATH环境变量中。

export PATH=$PATH:/Applications/Postgres.app/Contents/Versions/17/bin

这样就能运行psql命令了：

% psql --version
psql (PostgreSQL) 17.4 (Postgres.app)

安装完毕后，与Postgres交互可以从psql命令行开始。需要掌握psql的常用命令。

请我喝杯咖啡吧！

完毕

Learning Numpy

Daniel Sun — Tue, 25 Feb 2025 09:39:42 -0700

这是找到的一个NumPy Tutorial https://cs231n.github.io/python-numpy-tutorial/

Data Wrangling

Daniel Sun — Fri, 17 Jan 2025 23:19:33 -0700

Data Analysis (Wikipedia’s definition): the process of converting data, with the help of tools, from one form to another to allow convenient consumption of the data. This includes transformation, aggregation, visualization, and statistics.

Data Wrangling (author’s definition): the whole process of working with data to get it into and through your pipeline, whatever that may be, from data acquisition to your target audience, whoever they might be.

Data Analysis (Wikipedia): the process of working with and inspecting data to support decision-making.

Data Analysis (author): I view data analysis a subset of the data-wrangling process.

Monorepo和Microservices

Daniel Sun — Wed, 15 Jan 2025 15:20:28 -0700

https://monorepo.tools/

https://www.atlassian.com/git/tutorials/monorepos

https://danluu.com/monorepo/

https://news.ycombinator.com/item?id=33587622

Book Troubleshooting Java

Daniel Sun — Fri, 16 Aug 2024 19:35:23 +0800

最近在读一本Larentiu Spilca写的关于Java的调试和性能刨析的书。

第六章：Identifying resource consumption problems using profiling techniques

I consider learning to use a profiler a must for all developers, as it can be a compass to guide you to the cause of a seemingly hopeless problem.

作者推荐VisualVM，一款免费的profiler。此外还可以选：

A memory leak is when an app stores and keeps references to unused objects.

LeakCanary

MapStruct介绍

Daniel Sun — Sat, 10 Aug 2024 14:55:53 +0800

所谓的成为一位后端工程师，无非就是要掌握一系列的后端技术。学习了一门小的技术，并会拆解它，这样，就朝着后端工程师迈入坚实的一步。

我司的Spring Boot项目中，有引用一个第三方依赖 — MapStruct，属于工具类的库。

引用官网的介绍：

MapStruct is a code generator that greatly simplifies the implementation of mappings between Java bean types based on a convention over configuration approach.

Git笔记

Daniel Sun — Thu, 06 Jun 2024 20:34:54 +0800

安装Git

首次配置Git

Git从2.28.0版本（2020年7月）开始将默认的初始分支名称从"master"改为"main"。

Leanring Kotlin Coroutines

Daniel Sun — Sat, 25 May 2024 22:16:56 +0800

Suspending functions, like withContext, can only be called from other suspending functions or inside a coroutine builder.

对于Kotlin的Coroutines，不应该参考维基百科的协程定义。

Kotlin’s coroutines are a language-level feature designed for structured concurrency, while operating system coroutines are a low-level mechanism for cooperative multitasking provided by the operating system or user-level libraries.

学习Kotlin

Daniel Sun — Fri, 24 May 2024 18:05:54 +0800

Kotlin的杀手锏是与Java的互操作性。

Kotlinx — a set of optional, first-party libraries provided by JetBrains that extend on the base functionality in the Kotlin language and standard library. The Coroutines library is also part of Kotlinx.

CIO — coroutine-based I/O.

Structured Concurrency — A paradigm for managing batches of coroutines and handling them collectively as resources.

async — A coroutine builder that can be used as an alternative to launch. Much like launch, async accepts a lambda expression as an argument, which is where you can call other code that suspends. The big difference between these two functions is their return types:

Coroutines

Unlike threads, coroutines can execute and wait for the completion of other work without blocking the thread they are launched on – thanks to the magic of suspending functions.

Kotlin 1.3 introduced stable support for coroutines, but coroutines are not new or exclusive to Kotlin. The concept of a coroutine dates back to the 1950s, and they have been implemented in many programming languages.

Coroutines are based on the idea of functions being able to suspend, meaning that a function can be paused until a long-running operation completes.

Coroutines provide a high-level and safer set of tools to help you build asynchronous code. Under the hood, Kotlin’s coroutines use threads to perform work in parallel, but you often do not have to worry about this detail.

Kotlin does not ship with support for coroutines.

F公司的Backend Tech Stack

Daniel Sun — Wed, 22 May 2024 19:51:10 +0800

很感恩，差不多三月底拿到F公司的的offer，并于4月15日入职。那天是周三，一个值得纪念的日子。

算来刚满了一月。我想聊聊技术栈。公司主要使用Kotlin和TypeScript

基础技能：

Git：the popular version control system
Docker
REST API
Postman/cURL
SQL
IntelliJ IDEA
Gradle
Linux basics
TypeScript
Node.js
Kotlin

进阶技能

Unit Testing

Kotest：Kotest is a flexible and elegant multi-platform test framework for Kotlin with extensive assertions and integrated property testing
JUnit 5

Spring Boot
PostgreSQL
Kafka\

GraphQL

Expedia™️ GraphQL Kotlin
GraphQL Tools：A set of utilities for faster GraphQL development.
The Guild/Conductor：A Fully-Featured, Open-Source GraphQL Gateway for Your Project
The Guild/GraphQL Codegen：Generate code from your GraphQL schema and operations with a simple CLI

Exposed

Exposed is a Kotlin SQL database library with two flavors: a lightweight ORM (using DAO) and type-safe SQL (using DSL).
AWS
Camunda

高阶技能

TimescaleDB
nginx
Flyway
Terraform
Keycloak：一个开源的身份和访问管理系统,提供了完整的认证、授权、用户管理等功能。它是一个独立的认证服务器,可以与多种应用程序集成。
Kubernetes

TBC…

新加坡是福利国家吗？

Daniel Sun — Sun, 19 May 2024 18:32:22 +0800

很多人会认为新加坡不是一个福利国家。它独特的公积金制度，是一个以受雇者薪水作为福利来源的方式。确实，和西方发达国家在福利上支出相比，新加坡政府每年在福利项目上的支出，仅占总支出的2.15%和GDP的0.49%。与此相比，美国政府在医疗福利上每年的支出竟高达GDP的17.3%。这样福利制度的顶层设计，背后的指导思想是极小化福利支出在财政上的负担，让新加坡藉以保持竞争力。反观很多欧美国家，受雇者一旦失业，可以向政府每月领取失业金，即使不用上班也可以过着体面的生活。当然这样从宏观上看，是降低了社会的竞争力。

既然新加坡人在医疗和养老上是以自助为基础的，我为何认为它是个福利国家呢？

原因就在于新加坡独特的公屋制度。按照住建局的公屋制度，每一对新加坡夫妇（有一方得是公民）有生之年，有一次申请新屋(BTO)的机会。新屋的价格非常低廉，以至于低收入家庭也能够负担得起。申请新屋大致流程是向住建局提出申请。住建局提供一些候选的地点和户型。其中户型大小和家庭大小有一定关联，人口多的家庭有资格申请较大的户型。选定后，住建局下单开始兴建新屋。

经过几十年的密集建设，现在新加坡的23个城镇共有100多万套组屋。1960年，只有9%的新加坡人住在公共住房，如今接近80%，超过90%的组屋居民买下了房子。
有订单才会建新房，售价均低于市场价格，但要等上至少3、4年才能入住，不过低收入家庭也可以获得大量租房补贴。最新数据显示，组屋数量占新加坡住房总量的73%。
摘自BBC：https://www.bbc.com/ukchina/simp/vert-cap-46773103

由于新加坡的600百万人口里，有40%是外国人。这些人通常会租房。这样公屋屋主就很容易将空余的房间出租给外国人，赚取一定的租金。现在按照市价，一间单间的房间，租金均价在1000新币。如果能把一套三室户整体出租，租金甚至可以高达4000新币。这实在是一笔可观的收入。

假若退休之后，这对夫妇选择出国定居，比如赴临近的马来西亚或是泰国养老。他们将整套公屋出租。租金的收入基本上可以让他们在泰国租到一套房，并能覆盖日常的开销。

既然按照公屋制度，新加坡人可以以相对低廉的价格获得公寓，那必然可以把赚来的工资分配在别的事项上，比如旅游、医疗、教育…，这样即使新加坡不是传统意义上的福利国家，仍然可以过着一定有保障的生活。

当然，新加坡中产阶级普遍生活质量比不上欧美国家，这个话题将在日后撰文讨论。

学习GraphQL

Daniel Sun — Sat, 11 May 2024 23:23:24 +0800

GraphQL官方文档：https://graphql.org/

GraphQL over HTTP: https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md

The GraphQL-First Philosophy

A specific workflow for developing a GraphQL server, where the GraphQL schema is the first thing you design, and acts as the contract between your frontend and backend. It’s not necessarily for everyone, but it can be a great way to get a server up and running with a very clear separation of concerns.

UBS/TCS的最终轮面试

Daniel Sun — Thu, 04 Apr 2024 13:43:55 +0800

What’s the Java version used in your project?
Have you used any recent version of Java?
What frontend framework do you use?
Do you use Redux to manage state?
Do you use BDD or TDD for your development?
How do you configure your project to enable test coverage?
Which directory of your project stores the test configuration?
Elaborate how you carried out your project development?
Does your team use Agile/Scrum?
Solve 215. Kth Largest Element in an Array.

TATA咨询/瑞银的第二轮面试

Daniel Sun — Thu, 28 Mar 2024 23:08:33 +0800

最近的Java版本中引入了哪些变化？
Java中的record是什么？
什么是Immutable，它有什么好处？
如何设计一个Immutable类？
Java 8带来了哪些变化？
谈一下ConcurrentHashMap的实现。
Spring Boot是什么？
过去用过哪些Spring Boot Starter Dependencies？
什么是Dependency Injection？
Spring Boot中有哪几种Depedency Injection？
SOLID Principles中的L是指哪个原则？
Write a function that checks if all elements in an array are odd numbers.
手写Leetcode 121. Best Time to Buy and Sell Stock

聊聊Spring WebFlux

Daniel Sun — Thu, 28 Mar 2024 13:17:41 +0800

先来梳理一下关系。

Reactive Streams

Reactive Streams是一个规范，定义了处理异步数据流的标准，包括了发布者(Publisher)、订阅者(Subscriber)、订阅(Subscription)、处理器(Processor)等核心接口和规则。它为异步编程提供了一个统一的基础，解决了背压(Back Pressure)等问题。

详细见：https://github.com/reactive-streams/reactive-streams-jvm/blob/v1.0.4/README.md

Java 9 Flow API

此外，Java 9引入的java.util.concurrent.Flow与Reactive Streams在语义上是1：1等价的。

JDK9 java.util.concurrent.Flow

The interfaces available in JDK >= 9 java.util.concurrent.Flow, are 1:1 semantically equivalent to their respective Reactive Streams counterparts. This means that there will be a migratory period, while libraries move to adopt the new types in the JDK, however this period is expected to be short - due to the full semantic equivalence of the libraries, as well as the Reactive Streams <-> Flow adapter library as well as a TCK compatible directly with the JDK Flow types.

Project Reactor

而Project Reactor则是这个规范的一种具体实现。它提供了Reactive Streams规范接口的不同实现，以及一组符合规范的操作符，从而让开发者能够方便地进行响应式编程。

有关Project Reactor的书很少，分享一本免费的在线电子书。

Unraveling Project Reactor

RxJava

RxJava 3是一个基于观察者模式的Java编程库，用于实现异步、基于事件的程序。作为Reactive Streams规范的实现之一，RxJava 3遵循了 Reactive Streams的接口和协议。

Spring WebFlux

Beyond Java8

Daniel Sun — Mon, 25 Mar 2024 17:43:54 +0800

在入职Grab后就开始专注Kotlin，我就没碰过Java了，所以Java 8之后语言的新变化知之甚少。但有点是肯定的，这门语言变得越来越复杂。

当时我甚至觉得Kotlin这样新的JVM语言优于Java。Java已经不再是一门值得关注的语言。甚至我觉得我以后不太可能用Java了。

Compiler bugs All software has bugs, and sometimes the JVM, the Java compiler, or both have bugs. When you are using a 10-year-old version of the JVM and Java compiler, you run a much greater risk of compiler bugs, especially around features introduced near to that release.

There were many compilation problems around lambdas which were introduced in Java 8. If you are using the Java compiler from JDK 8 to target Java 8 JVMs you can still run into those bugs. Even if you are keeping your JDK 8 up-to-date many fixes are not backported. You can find ones on the issue tracker without much effort.

Now is the Java compiler in JDK 22 completely bug-free? No. But is using the Java compiler from JDK 22 on sources targeting Java 8 using only Java 8 language features much safer than using one from JDK 8? Absolutely.

Kotlin书单

Daniel Sun — Fri, 22 Mar 2024 18:54:58 +0800

从2018年开始使用Kotlin至今，Kotlin已经伴随我在大型Android应用和后端的项目中，成为我主要使用的编程语言。

除了透过Kotlin官网来学习Kotlin外，以下是我整理的优秀的Kotlin书单。

第一本入门书

这是一本极佳的入门书。我正是读了它的第一版入门Kotlin的。Kotlin Programming The Big Nerd Ranch Guide, 2nd Edition

本书出版于2021年底，覆盖了Kotlin 1.5。由于已经有三年，并且Kotlin 2.0也已经发布，我认为大约在2025年会出版该书的第三版。

读了它的第20章Coroutine，觉得信息量很大。不重复读几遍很难读懂。

阅读「Web 3大趋势」

Daniel Sun — Thu, 21 Mar 2024 19:13:53 +0800

本书的副标题是——日本网路教父教你一次看懂元宇宙、区块链、NFT。本书的作者是伊藤穰一。

本书以Web 3、元宇宙和NFT作为最重要的三个关键字。

伊藤给出了他认为最适合的元宇宙的定义——以网路即时沟通为前提，进行某种价值交换的空间。

零成本开DBS账户 - My Account

Daniel Sun — Thu, 21 Mar 2024 13:15:23 +0800

我一直以为，开通DBS账户需要维持3000新币的最低存款要求，否则会被收取每月5新币的账户管理费。

这也是为何我去年关闭了我的Multiplier Account。我认为为了拥有DBS账户而维持3000新币划不来。毕竟在高利率时代，3000新币一年能带来100新币的利息。相当于为了持有账户会让我每月损失8新币。

因为我的Moomoo和Tiger证券账户有美元和港币想要出金，只有DBS是对外币免手续费。主要的原因是Moomoo和Tiger的银行账户是在DBS托管的。

我本来是打算重新开DBS账户，并存入3000新币。在与DBS的工作人员交涉时，他解释了为何Multiplier Account要维持最低3000元的活期存款。因为只要credit your salaries，这个账户的活期存款有可观的利息收入的。他推荐我（重新）开通这个账户。

此外，他也提到有一种活期账户（current account）类型叫My Account，且支持多种货币。我欣喜地发现，这个账户没有最低存款要求。他解释道：

This account caters to people who can’t manage to deposit even hundreds of dollars.

于是，我开了My Account账户，只存入了50新币，并成功把Tiger上的港币出金到这个账户上，没有收取手续费。

虽然不知道其他新加坡银行的情况，但我相信也是有这种没有最低存款要求的账户的。

我会持续更新我的博文，让大家能够以最低成本持有银行账户。

请我喝杯咖啡吧！

新加坡交易所上值得买入的ETFs

Daniel Sun — Mon, 18 Mar 2024 14:40:06 +0800

第一个是追踪新加坡海峡时报指数的一款SPDR® Straits Times Index ETF；

证券代号：ES3

管理费：0.26%（年）

交易货币：SGD

挂牌日： 2002年4月17日

规模：15亿新币

派息率：4.60%

派息日：每年的2月和8月

塔塔咨询服务的Java后端面试记录

Daniel Sun — Fri, 15 Mar 2024 18:35:12 +0800

最近面了一家叫Tata Consultancy Services的咨询公司，面试的岗位是Java后端工程师。

这家国际(印度)咨询公司有许多的客户。我猜这个岗位的客户是UBS。

面试进行了35分钟左右。这里记录一下面试题。

面试题围绕着Java、Spring Boot和Microservices展开。

Java 8（2014年3月发布的）带来了哪些新功能？
Java接口的default methods有啥作用；Java 8为何要加入这个特性？
什么是Functional Interfaces？
Java 8中的HashMap有啥改变？
解释下Immutability/Immutable？
如何设计一个Immutable类？比如一个Employee类。
有一组Employee，每个Employee属于某个Department的集合，如何用Java Stream API找出属于IT Department的所有Employee？
Spring Boot为Spring framework带来了哪些新特性？
解释一下@SpringBootApplication的作用。
解释一下@RestController的作用。
谈一下Spring Data JPA。
Spring Boot应用如何做Health Check？
微服务中的Circuit Breaker是做什么的？
微服务彼此之间是如何通信的？
如何设计一个OpenFeign的类？
什么是Solid Principles？
什么是Twelve-Factor App？

「Spring Security in Action」读书笔记

Daniel Sun — Thu, 14 Mar 2024 14:27:10 +0800

Java专家Laurentiu Spilca于2020年出版了「Spring Security in Action」一书。

这本书以Spring Boot v2.3.0和Java 11版本为基础。

根据Manning Publications官方和Amazon上的讯息，他将于2024年4月出版本书第二版。

Spring Security in Action

虽然我没有第二版的书，但是读一下2020年版的应该不会太过时。

这篇博文记录书中的摘录、我的笔记和感想。

Spring Security is a framework that belongs to application-level security.

Application-level security refers to everything that an application should do to protect the environment it executes in, as well as the data it processes and stores. Mind that this isn’t only about the data affected and used by the application. An application might contain vulnerabilities that allow a malicious individual to affect the entire system!

Through authentication, an application identifies a user (a person or another application). The purpose of identifying these is to be able to decide afterward what they should be allowed to do—that’s authorization.

「Spring Start Here」读书笔记📒

Daniel Sun — Tue, 12 Mar 2024 13:14:33 +0800

这本书是我见过质量最好的Spring入门书籍，真的是没有之一，我花了整整两周读完。但是价格要$49.99，真是不便宜啊。

一直很稀奇，为何Spring这个流行的框架，社区中没有产出香Rails Tutorials那么高质量的入门实作读物。

此外，作者有些书目的推荐。

@RestController
public class HelloController {

 @GetMapping("/hello")
 public String hello() {
 return "Hello!";
 }

}

The @RestController annotation registers the bean in the context and tells Spring that the application uses this instance as a web controller.

微服务

Software architecture and its evolution is such a fantastic and complex subject. I don’t think there’ll ever be too many books to cover this subject thoroughly. I’ve added this discussion to the book to help you understand the references I’ll make to these notions. Still, you might want to go deeper into the subjects, so here’s a list of books from my shelf. The books are in the order I recommend you read them.

Microservices in Action
Microservices Patterns
Spring Microservices in Action
Microservices Security in Action
Monolith to Microservices

Hands on Learning Postgresql

Daniel Sun — Mon, 11 Mar 2024 21:22:44 +0800

这是记录我学习的Open Full Stack上的一门小课程Part 13 - Using relational databases。

这本课程是用PostgreSQL。

类似Mongoose，这门课程用到了Sequelize。官网的描述是：

Sequelize is a modern TypeScript and Node.js ORM for Oracle, Postgres, MySQL, MariaDB, SQLite and SQL Server, and more. Featuring solid transaction support, relations, eager and lazy loading, read replication and more.

Spring Security in Action

这里首先讲到之前课程用到的MongoDB。

Mongo is a document database and one of its most characteristic features is that it is schemaless, i.e. the database has only a very limited awareness of what kind of data is stored in its collections. The schema of the database exists only in the program code, which interprets the data in a specific way, e.g. by identifying that some of the fields are references to objects in another collection.

The \d command, which tells us what tables are in the database.

postgres=# \d
List of relations
Schema | Name | Type | Owner
--------+--------------+----------+----------
public | notes | table | username
public | notes_id_seq | sequence | username
(2 rows)

With the command \d notes, we can see how the notes table is defined:

postgres=# \d notes
Table "public.notes"
Column | Type | Collation | Nullable | Default
-----------+------------------------+-----------+----------+-----------------------------------
id | integer | | not null | nextval('notes_id_seq'::regclass)
content | text | | not null |
important | boolean | | |
date | time without time zone | | |
Indexes:
"notes_pkey" PRIMARY KEY, btree (id)

In practice, a migration is a single JavaScript file that describes some modification to a database. A separate migration file is created for each single or multiple changes at once.

「Redis for Dummies」第二版读书摘要

Daniel Sun — Mon, 11 Mar 2024 17:30:24 +0800

Redis is a popular multi-model database server.

NoSQL数据库有四个主要的类型：key/value、column、document和graph。

有两个易混淆的术语：

Data Store是专门的数据库系统，提供高效的数据组织和访问能力。

Data Storage是通用的数据存储介质和设备，为Data Store等上层系统提供存储容量。

Durability is the ability to ensure that data is available in the event of a failure of a database component.

第三章

There is no formal database creation step with Redis. There isn’t a formal table creation step with Redis either. The SET command is used to create data within the current database.

Those familiar with formalized database creation and definition may be uncomfortable with the seemingly informal process of Redis database creation and data handling. However, it’s through this flexibility that the true power of Redis is found.

学习Redis

Daniel Sun — Sun, 10 Mar 2024 20:52:43 +0800

最近打算系统地学习Redis。想花最少的时间快速地入门Redis。尝试在网上搜些优质的资源，结果发现好的不多，整理如下：

好书

第一本书是「Redis for Dummies」第二版，可以从redis.com官网免费下载。

Redis for Dummies

我会把读书的笔记整理到一篇博文中。

第二本叫「Redis in Action」,2013年出版的。这本书居然直到如今都没有更新，可能因为内容并没有过时。

Redis in Action

配套的源码放在GitHub，并有多种语言的实现。

Redis云服务提供商

介绍一个叫Redis Cloud的云产品。可以免费试用30天来创建一个数据库，用来学习是足够了。最基本的套餐也只要5美元/月。推荐使用这个云环境使用起来非常方便。我是懒得在本地安装、配置一个Redis实例了。

工具

推荐从Redis官网下载一款叫RedisInsight的GUI工具。可以直接连接一个本地或是远程的多个Redis实例。

RedisInsight

此外，黑马程序员的Redis课程也不错。

认证考试

没想到Redis生态真是健全，还有认证考试，不知道含金量如何。

Claude AI给我我如下的回复：

Redis Certification考试的费用和考试方式情况如下: Redis认证考试分为两个级别:Redis Certified Developer（149美元）和Redis Certified Data Persistence Specialist（249美元）。

Introduction to JDBC

Daniel Sun — Thu, 22 Feb 2024 19:12:29 +0800

This document illustrates the basics of the JDBC (Java Database Connectivity) API (Application Program Interface). Here, you will learn to use the basic JDBC API to create tables, insert values, query tables, retrieve results, update tables, create prepared statements, perform transactions on a database system from a Java program.

This document draws from the official Sun tutorial on JDBC Basics.

Head First SQL的精要

Daniel Sun — Sat, 17 Feb 2024 22:30:10 +0800

这是一本很好的SQL入门书。

很好的SQL练习题：https://leetcode.com/studyplan/top-sql-50/

第一章

SQL is case-insensitive. But it’s considered a good programming practice in SQL.

CREATE DATABASE gregs_list;

The semicolon is there to indicate that the command has ended.

TIMESTAMP is usually used to capture the current time. DATETIME is best used to store a future event.

DESC命令

To see how my_contacts table you created looks, you can use the DESC command to view it:

DESC my_contacts;

DESC is short for DESCRIBE.

INSERT语句

INSERT INTO your_table (column_name1, column_name2,...) VALUES ('value1', 'value2',...);

IMPORTANT: the values need to be in the same order as the column names.

Any value that goes into a VARCHAR, CHAR, DATE, or BLOB column has single quotes around it.

NULL相当于undefined。

You can’t compare one NULL to another. A value can be NULL, but it never equals NULL because NULL is an undefined value!

第四章

LIKE isn’t specific enough to target precise data.

… consider how much room on your hard drive it will take up when your database grows to an enormous size.

Cartesian join（亦称Cross join或Cartesian product）

A Cartesian join is a type of inner join. An inner join is basically just a Cartesian join where some results rows are removed by a condition in the query.

An outer joins returns all rows from one of the tables, along with matching information from another table.

Spring的容器中获取Bean

Daniel Sun — Wed, 14 Feb 2024 12:40:18 +0800

默认情况下，Spring项目启动时，会把Beans都创建好放在IOC容器中。如果想要主动获取这些Beans，可以通过如下方式：

根据name获取Bean

Object getBean(String name);

根据类型获取Bean

<T> T getBean(Class<T> requiredType);

根据name获取Bean（带类型转换）

<T> T getBean(String name, Class<T> requiredType);

在中国，使用npm需要替换registry

Daniel Sun — Tue, 02 Jan 2024 21:10:24 +0800

是在国外开始把玩Node.js，回国后发现npm install速度很慢…

这又是一个解决别的制度不存在的问题…

总之，npm默认的registry是 https://registry.npmjs.org 。可是在中国，这个源似乎访问速度很慢。

npm config get registry

可以返回当前源设置

设置淘宝源：

npm config set registry https://registry.npmmirror.com

JavaScript怪癖

Daniel Sun — Fri, 15 Apr 2022 21:52:20 +0800

1. `JavaScript`里的空指针异常其实是一种`TypeError`

null.toString();

回显

"TypeError: Cannot read property 'toString' of null"

超有用的Flutter命令行

Daniel Sun — Thu, 14 Apr 2022 13:51:33 +0800

自动生成的代码

flutter packages pub run build_runner build --delete-conflicting-outputs

获取依赖

flutter pub get

静态分析

flutter analyze

格式化

flutter format -n --set-exit-if-changed path/to/project --line-length 140

用命令行在iOS模拟器上打开Deeplink

Daniel Sun — Mon, 04 Apr 2022 14:55:32 +0800

比想象中简单，只需要打开Terminal输入如下咒语：

xcrun simctl openurl booted "some url"

在Big Sur上安装Ruby的经历

Daniel Sun — Fri, 01 Apr 2022 18:19:07 +0800

TL;DR: macOS Big Sur貌似对安装Ruby不太友好。不推荐rvm；推荐rbenv…

我是在macOS Big Sur上安装Ruby的，从来没有那么折腾过，花费了大半天时间。最后虽然安装成功，但却有很多点值得记录。这是是要安装2.7.5版本，LTS版本。输入ruby -v后会发现Mac是自带Ruby的，只是版本滞后，满足不了灵活需要。

最好不要直接安装Ruby，而是通过Ruby版本管理工具。

藉rvm安装Ruby

首先尝试安装rvm，用rvm管理不同的本地Ruby版本应该很简单，然而却不然。rvm很容易安装，但要手动设置环境变量。具体步骤可以参考RVM官网。

YouTube上有个很好的视频讲解

安装某个Ruby版本只要rvm install 2.7.5；安装后设置成默认是用rvm --default use 2.7.5 ，但是却报错。

藉rbenv安装Ruby

rbenv似乎没有官方主页，只有Github项目地址

brew install rbenv

然后

rbenv install 2.7.5

这条命令居然也失败了…

参考了这篇Github Gist，找到了解决方法。

RUBY_CONFIGURE_OPTS="--with-openssl-dir=$(brew --prefix openssl@1.1)" RUBY_CFLAGS="-w" rbenv install 2.7.5

然后

rbenv global 2.7.5

关闭Terminal后，ruby -v还是输出老版本，设置一下环境变量

export PATH="$HOME/.rbenv/bin:$PATH"
eval "$(rbenv init -)"

Stack in Java

Daniel Sun — Sun, 02 Sep 2018 20:17:01 +0800

##前言堆栈作为最基础的数据结构之一，在Java的最初版本就有了纯粹的标准实现：java.util.Stack。只可惜该实现存在性能缺陷，主要是由于主要的操作都加上了synchronized线程安全保护机制，导致无法被应用于对性能要求颇高的生产环境。

A more complete and consistent set of LIFO stack operations is provided by the Deque interface and its implementations, which should be used in preference to this class. For example: Deque stack = new ArrayDeque();

在Java Collections类发布后就和java.util.Vector类被一起被废弃了，取代之的是java.util.Deque接口。之所以设计成接口，是不想与某一个Deque的实现绑定。Java提供了LinkedList和ArrayDeque即可按照使用场景不同，采纳基于数组或是链表的Deque实现，提供了灵活性。

Deques can also be used as LIFO (Last-In-First-Out) stacks. This interface should be used in preference to the legacy Stack class. When a deque is used as a stack, elements are pushed and popped from the beginning of the deque.

how to maintain octopress

Daniel Sun — Sat, 01 Sep 2018 19:19:01 +0800

https://www.didiksetiawan.com/blog/2016/06/02/octopress-setup-and-deployment/

top k algorithms

Daniel Sun — Sat, 01 Sep 2018 18:46:00 +0800

##背景

去年面试Facebook时，被问到了一道Top K的问题，这类的问题解法往往具有共通性。今天在LeetCode上又遇到了一道类似的问题，于是网上搜了一下解题思路，摘录留下备用。

JDK里有一个强大的集合类 – PriorityQueue，掌握了它的用法便能迎刃而解这类问题。

值得注意的是PriorityQueue没有继承自List，不具有随机访问第i个元素的方法。

E get(int index);

Given a non-empty array of integers, return the k most frequent elements.

class Pair {
 int num;
 int count;

 Pair(int num, int count) {
 this.num=num;
 this.count=count;
 }
}

public class Solution {
 public List<Integer> topKFrequent(int[] nums, int k) {
 //count the frequency for each element
 HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
 for(int num: nums){
 if (map.containsKey(num)) {
 map.put(num, map.get(num)+1);
 } else {
 map.put(num, 1);
 }
 }

 // create a min heap
 PriorityQueue<Pair> queue = new PriorityQueue<>(new Comparator<Pair>() {
 public int compare(Pair a, Pair b) {
 return a.count - b.count;
 }
 });

 //maintain a heap of size k.
 for (Map.Entry<Integer, Integer> entry: map.entrySet()) {
 Pair p = new Pair(entry.getKey(), entry.getValue());
 queue.offer(p);
 if(queue.size() > k) {
 queue.poll();
 }
 }

 //get all elements from the heap
 List<Integer> result = new ArrayList<Integer>();
 while(queue.size() > 0) {
 result.add(queue.poll().num);
 }
 //reverse the order
 Collections.reverse(result);

 return result;
 }
}

Java Concurrency

Daniel Sun — Mon, 16 Jul 2018 12:28:47 +0700

为何要同步线程？

Since all threads run in the same address space, they all have access to the same data and variables. If two threads simultaneously attempt to update a global counter variable, it is possible for their operations to interleave in such way that the global state is not correctly modified. Although such a case may only arise only one time out of thousands, a concurrent program needs to coordinate the activities of multiple threads using something more reliable that just depending on the fact that such interference is rare.

Executor: An object that executes submitted Runnable tasks.
ExecutorService: A more extensive interface.
ThreadPoolExecutor: Provides an extensible thread pool implementation.
Executors: Provides convenient factory methods for these Executors.

AbstractExecutorService: Provides default implementations of ExecutorService execution methods.
ScheduledExecutorService: An ExecutorService that can schedule commands to run after a given delay, or to execute periodically.

`ExecutorService`的生命周期

Active
Shutting Down
Shutdown

Synchronizers (synchronization aids)

CyclicBarrier循环屏障: A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
Phaser
CountDownLatch: 当counter为1时为被用作start signal，为N时为complete signal。
Exchanger
Semaphore
SynchronousQueue

Potential threading problems

Deadlock
Starvation
Livelock
Race conditions

Concurrent Collections

缅甸旅游签证轻松办

Daniel Sun — Fri, 29 Jun 2018 22:36:17 +0700

从没想到缅甸签证原来那么好办，当然我指的是电子签证。

网办缅甸签证的官网

Java中的assert断言

Daniel Sun — Fri, 29 Jun 2018 15:52:18 +0700

使用Java已经有了10个年头，难以想象居然很少使用assert关键字。

Oracle官方指南中详细介绍了assert的用法。

An assertion is a statement in the Java programming language that enables you to test your assumptions about your program. For example, if you write a method that calculates the speed of a particle, you might assert that the calculated speed is less than the speed of light.

Each assertion contains a boolean expression that you believe will be true when the assertion executes. If it is not true, the system will throw an error. By verifying that the boolean expression is indeed true, the assertion confirms your assumptions about the behavior of your program, increasing your confidence that the program is free of errors.

Experience has shown that writing assertions while programming is one of the quickest and most effective ways to detect and correct bugs. As an added benefit, assertions serve to document the inner workings of your program, enhancing maintainability.

David Pawson《箴言》第一部观感

Daniel Sun — Sat, 23 Jun 2018 07:39:16 +0700

箴言这卷书一共有九百条箴言，涵盖人生各个层面，涵盖各种主题。

圣经上没有世俗这个词，我们不应该使用。

希腊思想才会把生活划分成神圣和世俗。

圣经里的智慧和愚昧都不是指智力，而是道德。

箴言这卷书是在讲如何善用人生，也在讲如何虚度人生，愚昧的人虚度人生。

我们很容易虚度一生。

人生很短，经不起你浪费一分一秒；但是人生的长度足够你活出上帝的旨意。

箴言不是应许。在希伯来语中，箴言的意思是“就像这样”。箴言是对人生一般性的观察。至于应许是特殊的承诺，这两者要分得很清楚。

智慧就是在某个情况下知道要应用什么箴言。箴言是一般性的常识，但是遇到不同情况的时候，需要有智慧才知道该应用哪一个箴言。

Java Date and Time Problem

Daniel Sun — Fri, 22 Jun 2018 22:08:32 +0700

https://www.hackerrank.com/challenges/java-date-and-time/problem

这道算法题使用Java 8的Date & Time API很容易解决了。

public class Solution {
 private static String getDay(String day, String month, String year) {
 int d = Integer.parseInt(day);
 int m = Integer.parseInt(month);
 int y = Integer.parseInt(year);

 LocalDate date = LocalDate.of(y, m, d);
 return date.getDayOfWeek().toString();
 }

 public static void main(String[] args) {
 Scanner in = new Scanner(System.in);
 String month = in.next();
 String day = in.next();
 String year = in.next();

 System.out.println(getDay(day, month, year));
 }
}

Git Cookbook

Daniel Sun — Thu, 21 Jun 2018 12:07:45 +0700

这个博客包含了在日常开发中经常会使用，但是却不太容易记住的Git命令和用法。

如何重命名本地和远程分支

如何删除本地和远程分支

如何撤销已被push到远程Git仓库的最新的commit

git revert HEAD
git push

如何从某个分支cherry-pick一个commit，并生成patch文件

如何stash当前分支本地的修改

git stash

如何unstash本地修改

git stash pop

Java 8 Date & Time API

Daniel Sun — Sat, 16 Jun 2018 22:43:02 +0700

Android官方文档里

java.time.temporal: lower level access to the fields.
java.time.format: customization options.

The offset-based date-time types OffsetTime and OffsetDateTime, are intended primarily for use with network protocols and database access. For example, most databases cannot automatically store a time-zone like ‘Europe/Paris’, but they can store an offset like ‘+02:00’.

获取当前月份

Month.from(Instant.now().atZone(ZoneId.of("Asia/Bangkok"));

Instant

An Instant represents a specific moment in time using GMT.

Daylight Saving Time

The United States observes daylight savings time on March 12, 2017, by moving the clocks forward an hour at 2 a.m.

In the United States, daylight savings time ends on November 5th, 2017 at 02:00 a.m. and we repeat the previous hour.

实验如下：

LocalDate localDate = LocalDate.of(2017, Month.NOVEMBER, 5);
LocalTime localTime = LocalTime.of(1, 0);
ZoneId zone = ZoneId.of("America/New_York");
ZonedDateTime z = ZonedDateTime.of(localDate, localTime, zone);
for (int i = 0; i < 6; i++) {
 System.out.println(z.plusHours(i));
}

输出如下：

2017-11-05T01:00-04:00[America/New_York]
2017-11-05T01:00-05:00[America/New_York]
2017-11-05T02:00-05:00[America/New_York]
2017-11-05T03:00-05:00[America/New_York]
2017-11-05T04:00-05:00[America/New_York]
2017-11-05T05:00-05:00[America/New_York]

谈谈赴泰工作的问题

Daniel Sun — Thu, 14 Jun 2018 16:48:42 +0700

自从16年10月到泰国工作，迄今已经超过一年半了。我也想分享一下如何去泰国工作，其中最重要的就是签证问题。

根据来泰国的目的，需要申请对应的签证。对于大多数人来说旅游签的门槛很低，但是持有旅游签是不能直接来泰国申请Work Permit的。事实上这种做法是非法的。

事实上有两个法律凭证需要搞清楚，第一个是工作签证；第二个是工作证。

需要解答的问题

Java泛型中一些难点解析

Daniel Sun — Tue, 12 Jun 2018 11:44:52 +0700

Joshua Bloch：

For maximum flexibility, use wildcard types on input parameters that represent producers or consumers. If an input parameter is both a producer and a consumer, then wildcard types will do you no good: you need an exact type match, which is what you get without any wildcards. Here is a mnemonic to help you remember which wildcard type to use: PECS stands for producer-extends, consumer-super.

参考Stackoverflow上这个问答或是参考这个Java Generics FAQs

What is a bounded wildcard?

A wildcard with either an upper or a lower bound. A wildcard with an upper bound looks like " ? extends Type " and stands for the family of all types that are subtypes of Type , type Type being included. Type is called the upper bound . A wildcard with a lower bound looks like " ? super Type " and stands for the family of all types that are supertypes of Type , type Type being included. Type is called the lower bound .

Bounded wildcards are used as arguments for instantiation of generic types. Bounded wildcards are useful in situations where only partial knowledge about the type argument of a parameterized type is needed, but where unbounded wildcards carry too little type information.

Example:

public class Collections {
 // bounded wildcard parameterized types
 public static <T> void copy(List<? super T> dest, List<? extends T> src) {
 for (int i = 0; i < src.size(); i++)
 dest.set(i, src.get(i));
 }
}

The copy method copies elements from a source list into a destination list. The destination list must be capable of holding the elements from the source list. We express this by means of bounded wildcards: the output list is required to have an element type with a lower bound T and the input list must have an element type with an upper bound T .

Java 8 Optional类的要点分析

Daniel Sun — Mon, 11 Jun 2018 21:15:02 +0700

首先仔细浏览Oracle和Android官方API文档。

然后仔细浏览Urma所著的Oracle的Java官方Tutorial。

Urma关于空指针的一段话：

I will argue in this article that using null to represent the absence of a value is a wrong approach. What we need is a better way to model the absence and presence of a value.

关于引入java.util.Optional类的初衷：

It is important to note that the intention of the Optional class is not to replace every single null reference. Instead, its purpose is to help design more-comprehensible APIs so that by just reading the signature of a method, you can tell whether you can expect an optional value. This forces you to actively unwrap an Optional to deal with the absence of a value.

Optional.map和Optional.flatMap的区别

其实只要仔细读读Optional类的源码就明白两者的区别了：

/**
 * If a value is present, apply the provided mapping function to it,
 * and if the result is non-null, return an {@code Optional} describing the
 * result. Otherwise return an empty {@code Optional}.
 *
 * @apiNote This method supports post-processing on optional values, without
 * the need to explicitly check for a return status. For example, the
 * following code traverses a stream of file names, selects one that has
 * not yet been processed, and then opens that file, returning an
 * {@code Optional<FileInputStream>}:
 *
 * <pre>{@code
 * Optional<FileInputStream> fis =
 * names.stream().filter(name -> !isProcessedYet(name))
 * .findFirst()
 * .map(name -> new FileInputStream(name));
 * }</pre>
 *
 * Here, {@code findFirst} returns an {@code Optional<String>}, and then
 * {@code map} returns an {@code Optional<FileInputStream>} for the desired
 * file if one exists.
 *
 * @param <U> The type of the result of the mapping function
 * @param mapper a mapping function to apply to the value, if present
 * @return an {@code Optional} describing the result of applying a mapping
 * function to the value of this {@code Optional}, if a value is present,
 * otherwise an empty {@code Optional}
 * @throws NullPointerException if the mapping function is null
 */
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
 Objects.requireNonNull(mapper);
 if (!isPresent())
 return empty();
 else {
 return Optional.ofNullable(mapper.apply(value));
 }
}

/**
 * If a value is present, apply the provided {@code Optional}-bearing
 * mapping function to it, return that result, otherwise return an empty
 * {@code Optional}. This method is similar to {@link #map(Function)},
 * but the provided mapper is one whose result is already an {@code Optional},
 * and if invoked, {@code flatMap} does not wrap it with an additional
 * {@code Optional}.
 *
 * @param <U> The type parameter to the {@code Optional} returned by
 * @param mapper a mapping function to apply to the value, if present
 * the mapping function
 * @return the result of applying an {@code Optional}-bearing mapping
 * function to the value of this {@code Optional}, if a value is present,
 * otherwise an empty {@code Optional}
 * @throws NullPointerException if the mapping function is null or returns
 * a null result
 */
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
 Objects.requireNonNull(mapper);
 if (!isPresent())
 return empty();
 else {
 return Objects.requireNonNull(mapper.apply(value));
 }
}

可见两者唯一的区别就是map方法在最后用 Optional.ofNullable 包装了返回值，而flatMap没有。

Optional类的primitive版本

OptionalInt、OptionalLong、OptionalDouble，它们的对应get方法签名变成了getAsInt、getAsLong、getAsDouble。

Introduction to Java 8

Daniel Sun — Mon, 11 Jun 2018 11:59:30 +0700

关于Java的术语总结。

Java Stream API

Daniel Sun — Wed, 06 Jun 2018 18:02:25 +0700

Java 8引入了Stream的概念，掌握这个概念的最佳方式是阅读Java官方文档。

可以浏览一下Oracle Java文档或是Android官方文档。

有些关键的概念需要掌握：stream、source、stream pipeline、stream operations、intermediate operations、terminal operation。

/**
 * Returns a sequential {@code Stream} with this collection as its source.
 *
 * <p>This method should be overridden when the {@link #spliterator()}
 * method cannot return a spliterator that is {@code IMMUTABLE},
 * {@code CONCURRENT}, or <em>late-binding</em>. (See {@link #spliterator()}
 * for details.)
 *
 * @implSpec
 * The default implementation creates a sequential {@code Stream} from the
 * collection's {@code Spliterator}.
 *
 * @return a sequential {@code Stream} over the elements in this collection
 * @since 1.8
 */
default Stream<E> stream() {
 return StreamSupport.stream(spliterator(), false);
}

Stream实例只能被使用一次，否则会抛出Runtime Exception：

java.lang.IllegalStateException: stream has already been operated upon or closed

The right and most convenient way to use streams are by a stream pipeline, which is a chain of stream source, intermediate operations, and a terminal operation.

将`Stream`转换为`int`、`long`或`double`流

abstract DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)

abstract IntStream mapToInt(ToIntFunction<? super T> mapper)

abstract LongStream mapToLong(ToLongFunction<? super T> mapper)

allMatch，anyMatch和noneMatch方法

abstract boolean allMatch(Predicate<? super T> predicate)

abstract boolean anyMatch(Predicate<? super T> predicate)

abstract boolean noneMatch(Predicate<? super T> predicate)

Java 8 Functional Interfaces笔记

Daniel Sun — Wed, 06 Jun 2018 17:15:33 +0700

最近在准备OCJP 8考试，需要熟悉一下Java 8引入的函数式编程的概念。具体包括了Functional Interfaces、Lambda表达式、Stream API等新知识。

最值得阅读的文档一般都是官方文档。Oracle和Android都有文档的链接。

4个内建(Built-in)的Functional interfaces

Functional Interfaces，或称为函数式接口，主要是指列于java.util.function包下的所有新的接口。它们被设计出来以满足通用的需求。乍看下共有43个接口，会觉得很吓人。其实它们都是从4个最典型的接口派生而来，为了某个specialization的、更具体化的场景而设计的，说白了就是为了让程序员能够根据需求选择出最具体化的接口。

1. Function接口

@FunctionalInterface
public interface Function<T, R> {
 /**
 * Applies this function to the given argument.
 *
 * @param t the function argument
 * @return the function result
 */
 R apply(T t);

2. Supplier接口

@FunctionalInterface
public interface Supplier<T> {
 /**
 * Gets a result.
 *
 * @return a result
 */
 T get();

3. Predicate接口

@FunctionalInterface
public interface Predicate<T> {
 /**
 * Evaluates this predicate on the given argument.
 *
 * @param t the input argument
 * @return {@code true} if the input argument matches the predicate,
 * otherwise {@code false}
 */
 boolean test(T t);

4. Consumer接口

@FunctionalInterface
public interface Consumer<T> {
 /**
 * Performs this operation on the given argument.
 *
 * @param t the input argument
 */
 void accept(T t);

Lambda表达式和函数式接口并不是一一对应的关系，一个Lambda表达式可以与多个Functional Interfaces兼容（compatible）。

Primitive Functional Interfaces

Primitive Functional Interfaces只包含double、int和long类型，而不包含char、float和short类型，所以java.util.function包下就不存在类似CharSupplier的接口。

补充

arity的解释是"元数"，就是参数数目的意思。

在Mac系统上安装Java 7最佳实践

Daniel Sun — Tue, 16 Sep 2014 14:02:10 +0800

截止今日，Oracle已经推出了JDK 8，对于这么新的版本，相信很多人和我一样不敢尝试。由于JDK 7已经在一些平台上（如最新的Android系统）得到支持，所以如果能在Mac上将JDK 6升级到7将会解决一些开发上的需求。

Mac系统历代OS都内置了JDK版本，不过最新的Mavericks上却只内置了JRE 6。Mac系统省缺JDK但是可以通过其升级机制安装JDK，遗憾的是苹果官方支持/安装的是JDK 6。看来Mac在Java的支持上有些滞后。幸运的是，在Mac上升级JDK很简单，可以按照如下步骤：

前往Oracle官网的Java SE Development Kit 7下载页下载Mac平台的dmg安装包。由于Mac系统的处理器都是64位的，所以只有唯一对应的安装包可以选择！
双击dmg安装包，会显示如下安装界面，双击pkg图标就会开始安装。

安装结束后在命令行输入：

java --version

回显：

java version "1.7.0_67"
Java(TM) SE Runtime Environment (build 1.7.0_67-b01)
Java HotSpot(TM) 64-Bit Server VM (build 24.65-b04, mixed mode)

Bingo，JDK 7已经安装完毕，不过先别急着离开，在实际的软件开发中，还会需要设置JAVA_HOME环境变量。

附加任务：设置JAVA_HOME环境变量

打开home目录下的.bash_profile文件，在最后加入如下代码：

export JAVA_HOME=$(/usr/libexec/java_home)

关闭文件后，在命令行输入：

source .bash_profile

这样，JAVA_HOME环境变量就设置完毕了，可以这样验证：

echo $JAVA_HOME

回显如下：

/Library/Java/JavaVirtualMachines/jdk1.7.0_67.jdk/Contents/Home

OK，大功告成！