MBG

Setting up an AREDN supernode + local node with `systemd-nspawn`

2026-01-14T00:00:00+00:00

News: If you are near the Pittsburgh area, contact me to join the local AREDN mesh!

Warning

Containers are officially unsupported by OpenWRT, so it will likely never be supported for AREDN either.

Background

systemd-nspawn is a containerization tool built into pretty much all modern Linux distributions. It compartmentalizes applications using native Linux kernel features such as namespaces.

Currently, AREDN supports running on physical devices and virtual machines. This is an experiment to see if we can configure working AREDN nodes inside lightweight containers, like systemd-nspawn.

In this guide, we will set up two containers: a supernode and a local node. The resulting network topology will look like this:

The advantages of this approach are:

Very lightweight compared to a VM-based solution.
Potentially higher performance — since the network stack is shared with the host OS.
Availablity of the full iproute2 toolset: just use ip netns exec <namespace> <command> to run commands inside the container’s network namespace.

Disadvantages:

Not beginner-friendly at all. There are many manual network configuration steps.

Warning

Be aware that AREDN runs everything as root inside the container. This means that container breakout is totally possible.

I developed this setup knowing that I can mostly trust the AREDN firmware, and that the host machine is dedicated to this purpose.

You should evaluate your own threat model. If in doubt, use a VM instead.

Prerequisites

A Linux host using systemd. You might need to install the systemd-container or systemd-nspawn package.
Some time.

Steps

I will skip all the basic OS installation steps and assume your host machine

boots and runs a systemd-based Linux distribution (most do since 2015),
runs on a kernel that supports network namespaces (likely the case),
has the systemd-nspawn and ip commands and other common Unix utilities installed,
has a working internet connection,

I will also omit all sudo, since pretty much all steps in this guide require root privileges.

Prepare the container filesystems

Download the AREDN firmware image: choose the “x86_64 Generic” version from the firmware selection page. It should give you a file ending with .img.gz. Unpack it with gunzip to get a .img file. I will be referring to this file as aredn-x86-64-generic-ext4-combined.img.
Create two directories to hold the container filesystems. I used:
```
 mkdir -p /srv/supernode /srv/localnode
```

Unpack the AREDN image:

 losetup -P loop0 aredn-x86-64-generic-ext4-combined.img
 mount /dev/loop0p2 /mnt
 rsync -aP /mnt/ /srv/localnode/
 rsync -aP /mnt/ /srv/supernode/
 umount /mnt
 losetup -d loop0

Note that the filesystem is located on the second partition of the image, hence loop0p2.

Work around a systemd-nspawn limitation: systemd-nspawn resets its own set of sysctl values and mounts /proc/sys as read-only inside the container.

(2025-01-17) The best solution I’ve found so far is to replace /sbin/init with a wrapper:
```
 mv /srv/supernode/sbin/init /srv/supernode/sbin/init.inner
```
Then create the wrapper /srv/supernode/sbin/init:
```
 #!/bin/sh
 for dir in /sys /proc/sys
 do
     /bin/mount -o remount,rw "$dir"
 done
 exec /sbin/init.inner
```
and mark it executable:
```
 chmod 0755 /srv/supernode/sbin/init
```
This will remount /proc/sys as read-write on every boot.

Note that using /etc/rc.local, or any other /etc/rc.d script, is too late.

The sysctl settings inside the containers are isolated from the host OS, so allowing write access is mostly acceptable.

Configure network namespaces

We will use the network-namespace mode of systemd-nspawn to give each container its own network stack.

We will set up two pairs of veth interfaces to connect the host OS to the two containers. Then, we will set up a bridge interface on the host OS between the two veth interfaces, and add a VLAN-tagged interface on top of the bridge for the WAN connection.

At the time of writing, AREDN does this by default during the first boot:

eth0: LAN 192.168.1.1
eth0.1 (VLAN): WAN dhcp
eth0.2 (VLAN): dtdlink 192.168.2.1

To minimize the amount of dirty work we need to do, we will try to stick to this scheme as much as possible.

Create the AREDN bridge and the WAN VLAN interface:
```
 ip link add br-aredn type bridge
 ip link add link br-aredn name br-aredn.wan type vlan id 1
 ip address add 192.168.10.1/24 dev br-aredn.wan
```
The names br-aredn and br-aredn.wan are arbitrary.

The IP address 192.168.10.1/24 is also arbitrary but should be in a different subnet from your host’s main network. I will be assigning 192.168.10.2 and 192.168.10.3 to the supernode and local node later.
Set up network namespaces for the two containers:
```
 ip netns add supernode
 ip netns add localnode
```
You can name them whatever you want as long as they are distinct from each other and from existing namespaces (if any).
Create the host-to-container veth pairs (which will also be the untagged LAN interfaces)
```
 ip link add veth-super address 36:eb:70:b2:80:1a master br-aredn type veth peer name eth0 netns supernode address 36:eb:70:b2:80:1b
 ip link add veth-local address 36:eb:70:b2:80:1c master br-aredn type veth peer name eth0 netns localnode address 36:eb:70:b2:80:1d
```
The address xx:xx:xx:xx:xx:xx parts are optional and are randomly generated. You can omit them, and they only need to be unique within their own veth pair. I made them all distinct and consecutive for cognitive convenience.

The host interface names (the fourth word on each line) can be whatever. For the container interface names (the peer name), please stick to eth0 so we don’t confuse the AREDN firmware. The part after netns must match the namespace names in the previous step.

Bring up the host-side interfaces:

 ip link set br-aredn up
 ip link set br-aredn.wan up
 ip link set veth-super up
 ip link set veth-local up

First boot configuration

Since the AREDN firmware is not systemd-aware, we use the --boot mode so that we bring up the entire OpenWRT system.

We configure the supernode first. The steps for the local node is exactly the same.

Bring up the supernode container:

 systemd-nspawn --network-namespace-path=/run/netns/supernode -D /srv/supernode --boot --capability=CAP_NET_ADMIN

Add a LAN IP to the host-side untagged interface:
```
 ip address add 192.168.1.2/24 dev br-aredn
```
At this point, we should be able to ping the supernode at 192.168.1.1 from the host.
Navigate to the AREDN web interface at http://192.168.1.1 and complete the initial setup wizard.
Find out the newly-generated AREDN LAN IP address and prefix length (something like 10.39.62.166/29):
```
 ip netns exec supernode ip address show br-lan
```
Now we change the host LAN IP to be in the same subnet:
```
 ip address del 192.168.1.2/24 dev br-aredn
 ip address add <aredn-lan-ip + 1>/29 dev br-aredn
```
/29 is the default LAN size at the time of writing. Use the ip netns exec command to be sure.
Navigate to http://<aredn-lan-ip> and complete the rest of the setup. In particular, I recommend the following settings:
- Enable WAN web and SSH access.
- Disable LAN DHCP for the supernode.
- Set a static IP for the WAN interface. I used 192.168.10.2 for the supernode and 192.168.10.3 for the local node. This eliminates the need to set up a DHCP server on the host OS.
- Set the LAN size to /30 since neither node will have any clients connected to it.
- (in Advanced options) Set a unique LAN VLAN tag (I used 12 for the supernode and 13 for the local node).
- As always, you should disable WAN telnet access and SSH password login for security.
Note that after changing the LAN size, the LAN IP might change. We should not need it for anything. However, if you do, run the ip netns exec command again to find out.

Repeat the above steps for the local node. For the supernode, don’t forget to follow the official supernode setup guide too.

If everything goes well, both nodes should be able to see each other over the DtD link.

Host routing configuration

So far, the containers can only communicate with the host OS. We need to set up routing on the host OS so that the containers can reach the internet.

I use nftables for firewalling. Replace $wan_iface with your host machine’s internet-facing interface name.

chain forward {
    type filter hook forward priority filter; policy drop;
    ct state { established, related } accept
    ct status dnat accept
    iifname "lo" accept
    iifname "br-aredn.wan" oifname $wan_iface accept
}

chain nat_post {
    type nat hook postrouting priority srcnat; policy accept;
    iifname "br-aredn.wan" oifname $wan_iface meta nfproto ipv4 masquerade
}

Finally, these sysctl settings are needed to enable IP forwarding and make babel happy:

net.ipv6.conf.all.forwarding = 1
net.ipv4.conf.all.forwarding = 1
net.ipv6.conf.all.accept_redirects = 0
net.ipv4.conf.all.rp_filter = 0

Put them in /etc/sysctl.d/80-aredn.conf and run sysctl -p /etc/sysctl.d/80-aredn.conf to apply them.

Further steps

To bring up the containers after the initial configuration, run steps 1-4 in Configure network namespaces and the first step in First boot configuration.

Some more things you may want to do:

systemd service script to bring the container up automatically. See appendix.
A reverse proxy for the node web interfaces.
Add other physical interfaces to the br-aredn bridge.
Firewall!

Appendix

Troubleshooting

Error aredn-XXXXXnode.service: Failed to spawn executor: Device or resource busy:

Starting multiple systemd-nspawn simultaneously is somehow buggy. To resolve the issue, add aredn-localnode.service to the After= list in aredn-supernode.service (or vice versa).
WireGuard nodes fail to show up:

Add these lines to /srv/(super|local)node/etc/rc.local:
```
 if ps | grep -v grep | grep netifd; then
     service network restart
 fi
```
to reconfigure networking after everything starts up.

`systemd` unit files

/etc/systemd/system/aredn-network-setup.service:

[Unit]
Description=Configure AREDN container networking
Wants=network.target
After=local-fs.target network-pre.target systemd-sysctl.service systemd-modules-load.service
Before=network.target shutdown.target network-online.target
Conflicts=shutdown.target

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/bin/ip link add br-aredn type bridge
ExecStart=/usr/bin/ip link add link br-aredn name br-aredn.wan type vlan id 1
ExecStart=/usr/bin/ip link add link br-aredn name br-aredn.slan type vlan id 12 # supernode LAN, optional
ExecStart=/usr/bin/ip link add link br-aredn name br-aredn.llan type vlan id 13 # localnode LAN, optional
ExecStart=/usr/bin/ip address add 192.168.10.1/24 dev br-aredn.wan
ExecStart=/usr/bin/ip link set br-aredn up
ExecStart=/usr/bin/ip link set br-aredn.wan up
ExecStop=/usr/bin/ip link set br-aredn.wan down
ExecStop=/usr/bin/ip link set br-aredn down
ExecStop=/usr/bin/ip link delete br-aredn.wan
ExecStop=/usr/bin/ip link delete br-aredn

/etc/systemd/system/aredn-supernode.service:

[Unit]
Description=AREDN supernode
Wants=network-online.target aredn-network-setup.service
After=network-online.target aredn-network-setup.service

[Service]
Type=simple
ExecStartPre=-/usr/bin/ip link delete veth-super
ExecStartPre=-/usr/bin/ip netns delete supernode
ExecStartPre=/usr/bin/ip netns add supernode
ExecStartPre=/usr/bin/ip link add veth-super master br-aredn type veth peer name eth0 netns supernode
ExecStartPre=/usr/bin/ip link set veth-super up
ExecStart=/usr/bin/systemd-nspawn --network-namespace-path=/run/netns/supernode -D /srv/supernode --keep-unit --boot --kill-signal=SIGPWR --resolv-conf=no --timezone=no --link-journal=no --capability=CAP_NET_ADMIN
ExecStopPost=/usr/bin/ip link set veth-super down
ExecStopPost=/usr/bin/ip link delete veth-super
ExecStopPost=/usr/bin/ip netns delete supernode
Restart=on-failure

[Install]
WantedBy=multi-user.target

sed s/super/local/g /etc/systemd/system/aredn-supernode.service > /etc/systemd/system/aredn-localnode.service
systemctl enable --now aredn-supernode.service aredn-localnode.service

AREDN® is a registered trademark of Amateur Radio Emergency Data Network, Inc.

Installing Arch Linux ARM on M1 UTM (Terminal)

2025-05-15T00:00:00+00:00

Prerequisites

Have a Linux box somewhere (required for creating a rootfs image)
Install UTM on your Mac

Prepare necessary files

Download the ARMv8 generic tar.gz rootfs file from Arch Linux ARM to the Linux box.

Extract the archive and obtain /boot/Image and /boot/initramfs-linux.img files.

Create an ext4 filesystem on a file and transfer the rootfs to it:

fallocate -l 2G rootfs.img
mkfs.ext4 rootfs.img
sudo mount rootfs.img /mnt
sudo tar -xvf ArchLinuxARM-aarch64-latest.tar.gz -C /mnt
sudo umount /mnt

Then, transfer the three files to the Mac host (e.g. with scp).

Create UTM VM

Open UTM and create a new VM:
- Choose “Virtualize” and select “Linux”
- “Use Apple Virtualization” is optional
- Tick “Boot from kernel image”
- Select the Image file for “Linux kernel”
- Select the initramfs-linux.img file for “Linux initial ramdisk”
- Don’t select a Root FS image at this point, so that UTM can create the actual virtual hard disk for us
- For terminal output, type `console=hvc0” in the “Kernel arguments” field
Set other parameters as desired

Further configuration

With the VM created, go to the settings window and click the last button on the left side labelled “New Drive”.

Select “Import” and then choose the rootfs.img file we created earlier.

Install Arch Linux

Start the VM: it would open two windows: the display window and the terminal window. The display window is not useful at this point, but don’t close it.
Go to the terminal window. Booting likely already failed, and there will be a rescue shell. This is expected.
The rootfs is likely /dev/vdb. Try
```
mount /dev/vdb /new_root
```
If that works, enter
```
exit
```
so that the system will continue booting.
If that doesn’t work, list ls /dev and try some other block devices. It could be /dev/vda or /dev/vdc, etc.
Now, we should be in the Arch Linux ARM live environment. The default passowrds are root:root and alarm:alarm.
To prepare the Arch Linux ARM live environment for the installation guide, we need a few packages:
```
pacman-key --init
pacman-key --populate archlinuxarm
pacman -Sy arch-install-scripts pacman glibc
```
I also installed btrfs-progs because I wanted a btrfs root.
Finally, follow the official Arch Linux installation guide.

In particular, I use

pacstrap -K /mnt archlinuxarm-keyring base linux linux-firmware btrfs-progs vim git sudo

linux and linux-firmware are actually unnecessary for the system itself, and can be removed afterwards. It is only needed during installation for generating the initramfs for the new kernel.

Inside the chroot

Add QEMU drivers to the initramfs by modifying /etc/mkinitcpio.conf:

MODULES=(virtio virtio_blk virtio_pci virtio_net)
BINARIES=(btrfs) # If btrfs is used

After finishing the installation guide, copy /mnt/boot/Image and /mnt/boot/initramfs-linux.img from the VM back to the host. The live environment has sshd enabled by default.

Before the first boot

It is necessary to copy or move Image and initramfs-linux.img to the UTM data directory at (normally) ~/Library/Containers/com.utmapp.UTM/Data/Documents/<NAME>.utm on the host because UTM makes a copy of the files we originally selected for the kernel and initramfs files.

Then, modify the kernel arguments:

console=hvc0 root=/dev/vda

Try starting the VM again. It should boot into the Arch Linux ARM system.

I use systemd-networkd for networking, so I need to create /etc/systemd/network/enp0s1.network with the following content:

[Match]
Name=enp0s1
[Network]
DHCP=yes

Then, enable the service:

systemctl enable --now systemd-networkd systemd-resolved
ln -sf /run/systemd/resolve/resolv.conf /etc/resolv.conf

Further set up

Shared drive and rosetta

Set up shared folders and rosetta mounts by adding these to /etc/fstab:

rosetta /rosetta        virtiofs        ro,nofail       0       0
share   /mnt/utm        virtiofs        rw,nofail       0       0

Set up rosetta in /etc/binfmt.d/rosetta.conf:

:rosetta:M::\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x3e\x00:\xff\xff\xff\xff\xff\xfe\xfe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/rosetta/rosetta:PCF

(Optional) Install a full x64 system

I want to install some non-free Linux-only software like ANSYS Lumerical. They usually support Ubuntu more than Arch, so I will debootstrap an entire Ubuntu system that uses rosetta.

First, we need to install the installers:

pacman -S debootstrap binutils

Create and bind-mount the target folder:

mkdir -p /x64/dev /x64/proc /x64/sys
mount --bind /dev /x64/dev
mount --bind /dev/pts /x64/dev/pts
mount --bind /sys /x64/sys
mount --bind /run /x64/run
mount --bind /proc /x64/proc

Run the Ubuntu installer:

debootstrap --extractor=ar --arch=amd64 --merged-usr noble /x64 https://archive.ubuntu.com/ubuntu

Set up a resolver:

echo "nameserver 1.1.1.1" >> /x64/etc/resolv.conf

Now, we can chroot into the system (with a different architecture!):

chroot /x64

Making a boost converter

2024-03-07T00:00:00+00:00

Background

As described in the previous post in 2022, I made a simple buck converter controlled by a Raspberry Pi. After some drama happened with its SD card, I migrated the entire circuit to my brand new RPi Pico with some slight modifications. To make the circuit run on pure 5V, I added a cheap boost board before my circuit to generate 20V.

For those around me, these things all happened during and after the Great Power Outage of 2022, in which I had to run everything on a 6V lead-acid battery. Therefore, this buck-boost-buck topology had been bugging me from day one: it is terrible in terms of efficiency and EM interference. I had always wanted to make my own boost converter instead. However, it scares me that “theoretically” this circuit will be capable of generating an infinite voltage. Do I need to add closed-loop feedback for it? What if I miscalculated and it fries my Pico?

This week I finally ran some SPICE models and decided to get my hands dirty.

Design

I am not actually designing the topology from scratch. I took the one on Wikipedia and simply chose the components based on my needs.

The first problem was that I could not get anything higher than 7V with the RJK1536DPN I took off. I felt like there could be two possible reasons: either the on-resistance was too high, or the gate voltage was too low. I tried both, and it turned out that the gate voltage was the problem. Fortunately, I still had five IRL520N MOSFETs with a gate threshold voltage of 2V. It worked like a charm and gave me 9.2V without tuning anything else.

I also included a voltage divider on the output to measure the voltage with the Pico’s ADC in this diagram. I have not physically implemented it yet though.

The rest was pretty much just controlling the PWM signal. By trial and error on the breadboard, I found that a frequency of around 125kHz generated the highest voltage. I also swapped the inductor to one I took from another dead switch-mode power supply.

The next thing that worried me was that this circuit cannot be turned off: even when the PWM duty cycle is 0, the load will still see 5V. However, my measurements showed that the light bulb only drew some microamps at this state, so I decided to leave it as it was.

Finally, I cannot leave the MOSFET on constantly: at this state, we are essentially shorting the 5V supply at steady state. For now, this is done on the software side. Maybe I should add something else to the circuit to prevent this from happening.

Results

I did these measurements on my Mac’s USB port, which definitely did not try to provide a constant voltage.

When switching at 60kHz, 58% duty cycle, I got 60mA@14.2V with an input of 0.415A@4.8V. That is a terrible efficiency of 43%. At 125kHz, 58% duty cycle, I got 72mA@13.12V with an input of just 0.227A@4.9V. Now the efficiency is a whopping 85%.

Again I studied the relationship between the output voltage and the duty cycle on the completed circuit. This one was able to reach a higher voltage of 40V, probably because the finished circuit has much lower resistance than my rusty breadboard plus jumper wires setup. However, the data was still weird, probably because the input voltage was not constant. I will try to do this again with a more stable power supply. Note: This time, the duty cycle is out of 1000. The light turns on at around 21.

Reflection

I was surprised by how high the efficiency was, even just on the breadboard. I used to be surprised at the efficiencies shown in those SMPS IC datasheets, but now I feel like maybe it is just a matter of choosing the right components. Also, I am using a discrete MOSFET instead of one crammed in a tiny package, so the loss and heat dissipation are much better. In fact, the MOSFET was barely warm after running for a while (except for the time I accidentally left the gate high).

A boost converter definitely comes with more responsibilities than a buck converter. In fact, the last two data points on the graph were already outside of the light bulb’s rating, voltage-wise. Maybe I should add a feedback loop. Since the circuit is always working with the same load, I am simply limiting the duty cycle to 530 out of 1000. It works for now.

Update (2024-03-08)

Today, I did a more “proper” test with a regulated supply. The input voltage had a range of 5.22V to 5.28V.

Two interesting results that happened in both tests:

This circuit has some kind of a hysteresis behaviour around 42% duty cycle:
- If I start low from an output of below 9.1V (duty cycle below 37%) and step up the duty cycle across 42%, the voltage jumps from 9V to 12V.
- If it enters this 37% to 42% region when the duty cycle is already above 37%, the output voltage curve is smooth.
There is an output dip at around 58% duty cycle.

I suspect that both of these are because of the interaction with the (very nonlinear) load. I do not plan to test again with a constant load though… I just want to make an ASIC (haha).

I also used our lab’s nice oscilloscope to measure the gate signal and the output. I forgot to set the mode, so although it shows a vertical division of 100mA, it actually means 1V.

What I cannot explain is the gate ringing. It is probably not the result of resonance on the gate, because the ringing does not immediately begin after an edge: it actually always terminates at the rising edge. Its initial amplitude also increases with the duty cycle, instead of being constant like the rising or falling time. This probably means it is related to the MOSFET and the load. The ringing can bring the gate voltage to below -0.5V after the duty cycle exceeds 50%, which exceeds the absolute maximum rating of the Pico’s GPIO pin. I need to try to fix this when I have time.

The output ripple at 53% duty cycle was around 0.36V. The spikes of around 3.3V are a bigger worry.

Gate signal at 10% duty cycle

Gate signal at 15% duty cycle

Gate signal at 47% duty cycle

Gate signal at 58% duty cycle

Output at 53% duty cycle (AC coupling)

Making a buck converter

2022-11-11T00:00:00+00:00

Background

I have a “smart” control system in my room. Actually, it is quite dumb: it is just a Raspberry Pi 3B+ connected to a beefy power supply. The Pi itself is connected to a temperature probe to monitor my room temperature, and a Ubiquiti UAP-LR I dug out from the IT dumpster powered by a homemade passive POE cable to provide tunnelled Wi-Fi. The Pi also acts as a router.

Last year, I had a solid-state relay (provided by my physics teacher) in the light fixture that I could use to control the light. Later, I moved the relay to other projects for the house. So that I still have a “smart” light, I put up a 20V light bulb controlled by the Pi via a transistor. I tried to dim it like an ordinary LED by outputting a PWM signal, but it did not work. I did not understand it back then, so I replaced the transistor with a spare ESC I had, which did not help either. Considering that this light bulb is designed to operate from 10V to 35V and there is a whole bunch of circuits inside, this is probably reasonable: it may have its own stabilizing circuitry inside.

Earlier this school year, I decided to apply my RF knowledge and do something to my little light. I put an aluminum capacitor across it and a resistor in series with it: forming an RC filter.

It turns out that the resistor can get quite hot, although I already used four bigger resistors in parallel. The voltage drop across the resistors was also significant, leaving the light never completely on. Well, at least the system is dimming now.

Then one day, when I was adjusting another power supply, I realized I was making a buck converter unknowingly! Realizing that, I moved on to design a real buck converter so as to make my place look nicer.

Design

Most of the simple buck circuits online put the switch on the positive side of the circuit. It may make sense in other common use cases, but definitely not here. My Pi and the 20V power supply share the same reference, so I would either need a driver circuit or fry my Pi.

Well, IB students are critical thinkers. We won’t be puzzled by this: I designed my own circuit with a common ground.

The N-channel MOSFET in the circuit, RJK1536DPN, was taken from a dead EV charger in the dumpster as well. Initially, I tried to work out all the parameters with the loop rule and the junction rule. Well, I did make some progress, but I ended up using an LTSpice simulation to iterate the design faster. Now I understand the advantage of the “conventional” design: in my version, the load has a floating reference. However, this should not matter for my little light bulb.

Reflection

There is still a glitch with this design. When the duty cycle is more than 41%, the voltage does not seem to change much. That’s probably because the light does not consume enough charge from the capacitor. In other words, I want it to operate in continuous mode, where the output voltage is proportional to the duty cycle. However, the load is too light, so the converter is in discontinuous mode. It is just a light anyways, I do not mind if the rise/fall time is larger, so I will probably adjust the inductors and capacitors. In the meantime, I will compensate for the nonlinearity on the software side.

Nonetheless, this is my first buck converter made by hand, and I am glad to see it work.

Update (2022-11-23)

I found some extra time during the power outage and experimented with the response curve of my creation. At 100kHz’s switching frequency and 19.90V’s input, here is the result:

Note: The circuit seems to resonate at the ducy cycle of 420000. After the duty cycle is below 80000, the load light turns off.

I guess one thing I can do is to fit a curve on the operation region and find a way to give linear output stepping.

Update (2022-11-30)

Here is the new dimmer:

def intensity_to_dcycle(perceived_intensity: float) -> int:
    # Logarithmic dimming
    real_intensity = e ** (perceived_intensity * log(101, e) / 100) - 1
    # Linearly scale to voltage
    voltage = real_intensity * (19.2 - 7.845)/100 + 7.845
    # Piecewise fit
    if 7.845 < voltage <= 9.275:
        return int(281970 * (-7.664 + voltage))
    if 9.275 < voltage <= 13.75:
        return int(26520 * (6.959 + voltage))
    if 13.75 < voltage <= 16.88:
        return int(49485 * (-2.529 + voltage))
    if 16.88 < voltage <= 19.2:
        return min(int(21692 * (26.90 + voltage)), 1000000)
    # Out of range
    return 0

Leaving Hotmail.com

2022-11-02T00:00:00+00:00

Hotmail.com, or really, Outlook.com, is one of the email providers I have used for the longest time. In fact, if I remembered correctly, this is my tenth year using it. Back then, it was a pretty sound choice: I was already using 163.com as my main email, and Hotmail was quite a credible alternative — considering that Google was already exiting China.

Over those years, Microsoft was not that bad at all. Windows remains the most widely used operating system on desktops and laptops, Bing.com, another Microsoft service, has been one of the only usable search engines in Mainland China: after Google exited, Baidu.com essentially became an advertisement board. More impactfully, after Microsoft acquired GitHub in June 2018, it has become an inseparable part of my online presence. I eventually made the shift to change my primary email to Hotmail in March 2020, because at that time, NetEase (163) emails had way too many promotional emails.

People do not notice problems before getting close to each other.

As students, we wish each other Happy Birthdays. Soon after switching over to Outlook calendars, I noticed that the birthdays were shown off-by-one-day on Apple devices. Then, when I switched over to Linux, using Thunderbird as my email client, I noticed that Outlook calendars do not use a standard protocol, and are, therefore, difficult to synchronize.

The spam filter did not become an issue, until I saw my school application, my scholarship application, and even my visa application, ending up in the junk folder. The server very “nicely” deletes any “junk” emails permanently after ten days, meaning that I have to check that folder very often: see it or miss it. What is even worse, there is no way to turn it off. Most guides online only tell you how to turn it off on Outlook clients, but Outlook.com will continue filtering important emails happily.

I ended up creating a Power Automate flow to automatically move junk to inbox.

When a new email arrives (V2) in "Junk", move it to "INBOX".

Ironic, isn’t it? Despite that, at the time of writing, it seems that Outlook still has a way to populate my junk folder with legitimate emails.

That is not it either. My own domain, with a dedicated IP from Oracle Cloud, can send emails to Gmails, other domains, and even Outlook for Business domains, but not hotmail.com nor outlook.com. Why would you block me from sending emails to myself?

Sorry, but not all users need a spam filter.

Sometimes, people need the ability to control their own destinies. As ESPs, they have too much power over what users see.

This time, it is a road blocker.

Sorry, Outlook. I am moving to my own email. Please treat well those without the ability to set one up.

On caring - Nate Soares

2022-04-03T00:00:00+00:00

Original Post published on 04 Oct. 2014. None of the original text has been changed and this is simply a copy of the original post for convenience.

1

I’m not very good at feeling the size of large numbers. Once you start tossing around numbers larger than 1000 (or maybe even 100), the numbers just seem “big”.

Consider Sirius, the brightest star in the night sky. If you told me that Sirius is as big as a million earths, I would feel like that’s a lot of Earths. If, instead, you told me that you could fit a billion Earths inside Sirius… I would still just feel like that’s a lot of Earths.

The feelings are almost identical. In context, my brain grudgingly admits that a billion is a lot larger than a million, and puts forth a token effort to feel like a billion-Earth-sized star is bigger than a million-Earth-sized star. But out of context — if I wasn’t anchored at “a million” when I heard “a billion” — both these numbers just feel vaguely large.

I feel a little respect for the bigness of numbers, if you pick really really large numbers. If you say “one followed by a hundred zeroes”, then this feels a lot bigger than a billion. But it certainly doesn’t feel (in my gut) like it’s 10 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 times bigger than a billion. Not in the way that four apples internally feels like twice as many as two apples. My brain can’t even begin to wrap itself around this sort of magnitude differential.

This phenomena is related to scope insensitivity, and it’s important to me because I live in a world where sometimes the things I care about are really really numerous.

For example, billions of people live in squalor, with hundreds of millions of them deprived of basic needs and/or dying from disease. And though most of them are out of my sight, I still care about them.

The loss of a human life with all is joys and all its sorrows is tragic no matter what the cause, and the tragedy is not reduced simply because I was far away, or because I did not know of it, or because I did not know how to help, or because I was not personally responsible.

Knowing this, I care about every single individual on this planet. The problem is, my brain is simply incapable of taking the amount of caring I feel for a single person and scaling it up by a billion times. I lack the internal capacity to feel that much. My care-o-meter simply doesn’t go up that far.

And this is a problem.

2

It’s a common trope that courage isn’t about being fearless, it’s about being afraid but doing the right thing anyway. In the same sense, caring about the world isn’t about having a gut feeling that corresponds to the amount of suffering in the world, it’s about doing the right thing anyway. Even without the feeling.

My internal care-o-meter was calibrated to deal with about a hundred and fifty people, and it simply can’t express the amount of caring that I have for billions of sufferers. The internal care-o-meter just doesn’t go up that high.

Humanity is playing for unimaginably high stakes. At the very least, there are billions of people suffering today. At the worst, there are quadrillions (or more) potential humans, transhumans, or posthumans whose existence depends upon what we do here and now. All the intricate civilizations that the future could hold, the experience and art and beauty that is possible in the future, depends upon the present.

When you’re faced with stakes like these, your internal caring heuristics — calibrated on numbers like “ten” or “twenty” — completely fail to grasp the gravity of the situation.

Saving a person’s life feels great, and it would probably feel just about as good to save one life as it would feel to save the world. It surely wouldn’t be many billion times more of a high to save the world, because your hardware can’t express a feeling a billion times bigger than the feeling of saving a person’s life. But even though the altruistic high from saving someone’s life would be shockingly similar to the altruistic high from saving the world, always remember that behind those similar feelings there is a whole world of difference.

Our internal care-feelings are woefully inadequate for deciding how to act in a world with big problems.

3

There’s a mental shift that happened to me when I first started internalizing scope insensitivity. It is a little difficult to articulate, so I’m going to start with a few stories.

Consider Alice, a software engineer at Amazon in Seattle. Once a month or so, those college students with show up on street corners with clipboards, looking ever more disillusioned as they struggle to convince people to donate to Doctors Without Borders. Usually, Alice avoids eye contact and goes about her day, but this month they finally manage to corner her. They explain Doctors Without Borders, and she actually has to admit that it sounds like a pretty good cause. She ends up handing them $20 through a combination of guilt, social pressure, and altruism, and then rushes back to work. (Next month, when they show up again, she avoids eye contact.)

Now consider Bob, who has been given the Ice Bucket Challenge by a friend on facebook. He feels too busy to do the ice bucket challenge, and instead just donates $100 to ALSA.

Now consider Christine, who is in the college sorority ΑΔΠ. ΑΔΠ is engaged in a competition with ΠΒΦ (another sorority) to see who can raise the most money for the National Breast Cancer Foundation in a week. Christine has a competitive spirit and gets engaged in fund-raising, and gives a few hundred dollars herself over the course of the week (especially at times when ΑΔΠ is especially behind).

All three of these people are donating money to charitable organizations… and that’s great. But notice that there’s something similar in these three stories: these donations are largely motivated by a social context. Alice feels obligation and social pressure. Bob feels social pressure and maybe a bit of camaraderie. Christine feels camaraderie and competitiveness. These are all fine motivations, but notice that these motivations are related to the social setting, and only tangentially to the content of the charitable donation.

If you took any of Alice or Bob or Christine and asked them why they aren’t donating all of their time and money to these causes that they apparently believe are worthwhile, they’d look at you funny and they’d probably think you were being rude (with good reason!). If you pressed, they might tell you that money is a little tight right now, or that they would donate more if they were a better person.

But the question would still feel kind of wrong. Giving all your money away is just not what you do with money. We can all say out loud that people who give all their possessions away are really great, but behind closed doors we all know that such people are crazy. (Good crazy, perhaps, but crazy all the same.)

This is a mindset that I inhabited for a while. There’s an alternative mindset that can hit you like a freight train when you start internalizing scope insensitivity.

4

Consider Daniel, a college student shortly after the Deepwater Horizon BP oil spill. He encounters one of those college students with the clipboards on the street corners, soliciting donations to the World Wildlife Foundation. They’re trying to save as many oiled birds as possible. Normally, Daniel would simply dismiss the charity as Not The Most Important Thing, or Not Worth His Time Right Now, or Somebody Else’s Problem, but this time Daniel has been thinking about how his brain is bad at numbers and decides to do a quick sanity check.

He pictures himself walking along the beach after the oil spill, and encountering a group of people cleaning birds as fast as they can. They simply don’t have the resources to clean all the available birds. A pathetic young bird flops towards his feet, slick with oil, eyes barely able to open. He kneels down to pick it up and help it onto the table. One of the bird-cleaners informs him that they won’t have time to get to that bird themselves, but he could pull on some gloves and could probably save the bird with three minutes of washing.

Daniel decides that he would spend three minutes of his time to save the bird, and that he would also be happy to pay at least $3 to have someone else spend a few minutes cleaning the bird. He introspects and finds that this is not just because he imagined a bird right in front of him: he feels that it is worth at least three minutes of his time (or $3) to save an oiled bird in some vague platonic sense.

And, because he’s been thinking about scope insensitivity, he expects his brain to misreport how much he actually cares about large numbers of birds: the internal feeling of caring can’t be expected to line up with the actual importance of the situation. So instead of just asking his gut how much he cares about de-oiling lots of birds, he shuts up and multiplies.

Thousands and thousands of birds were oiled by the BP spill alone. After shutting up and multiplying, Daniel realizes (with growing horror) that the amount he acutally cares about oiled birds is lower bounded by two months of hard work and/or fifty thousand dollars. And that’s not even counting wildlife threatened by other oil spills.

And if he cares that much about de-oiling birds, then how much does he actually care about factory farming, nevermind hunger, or poverty, or sickness? How much does he actually care about wars that ravage nations? About neglected, deprived children? About the future of humanity? He actually cares about these things to the tune of much more money than he has, and much more time than he has.

For the first time, Daniel sees a glimpse of of how much he actually cares, and how poor a state the world is in.

This has the strange effect that Daniel’s reasoning goes full-circle, and he realizes that he actually can’t care about oiled birds to the tune of 3 minutes or $3: not because the birds aren’t worth the time and money (and, in fact, he thinks that the economy produces things priced at $3 which are worth less than the bird’s survival), but because he can’t spend his time or money on saving the birds. The opportunity cost suddenly seems far too high: there is too much else to do! People are sick and starving and dying! The very future of our civilization is at stake!

Daniel doesn’t wind up giving $50k to the WWF, and he also doesn’t donate to ALSA or NBCF. But if you ask Daniel why he’s not donating all his money, he won’t look at you funny or think you’re rude. He’s left the place where you don’t care far behind, and has realized that his mind was lying to him the whole time about the gravity of the real problems.

Now he realizes that he can’t possibly do enough. After adjusting for his scope insensitivity (and the fact that his brain lies about the size of large numbers), even the “less important” causes like the WWF suddenly seem worthy of dedicating a life to. Wildlife destruction and ALS and breast cancer are suddenly all problems that he would move mountains to solve — except he’s finally understood that there are just too many mountains, and ALS isn’t the bottleneck, and AHHH HOW DID ALL THESE MOUNTAINS GET HERE?

In the original mindstate, the reason he didn’t drop everything to work on ALS was because it just didn’t seem… pressing enough. Or tractable enough. Or important enough. Kind of. These are sort of the reason, but the real reason is more that the concept of “dropping everything to address ALS” never even crossed his mind as a real possibility. The idea was too much of a break from the standard narrative. It wasn’t his problem.

In the new mindstate, everything is his problem. The only reason he’s not dropping everything to work on ALS is because there are far too many things to do first.

Alice and Bob and Christine usually aren’t spending time solving all the world’s problems because they forget to see them. If you remind them — put them in a social context where they remember how much they care (hopefully without guilt or pressure) — then they’ll likely donate a little money.

By contrast, Daniel and others who have undergone the mental shift aren’t spending time solving all the world’s problems because there are just too many problems. (Daniel hopefully goes on to discover movements like effective altruism and starts contributing towards fixing the world’s most pressing problems.)

5

I’m not trying to preach here about how to be a good person. You don’t need to share my viewpoint to be a good person (obviously).

Rather, I’m trying to point at a shift in perspective. Many of us go through life understanding that we should care about people suffering far away from us, but failing to. I think that this attitude is tied, at least in part, to the fact that most of us implicitly trust our internal care-o-meters.

The “care feeling” isn’t usually strong enough to compel us to frantically save everyone dying. So while we acknowledge that it would be virtuous to do more for the world, we think that we can’t, because we weren’t gifted with that virtuous extra-caring that prominent altruists must have.

But this is an error — prominent altruists aren’t the people who have a larger care-o-meter, they’re the people who have learned not to trust their care-o-meters.

Our care-o-meters are broken. They don’t work on large numbers. Nobody has one capable of faithfully representing the scope of the world’s problems. But the fact that you can’t feel the caring doesn’t mean that you can’t do the caring.

You don’t get to feel the appropriate amount of “care”, in your body. Sorry — the world’s problems are just too large, and your body is not built to respond appropriately to problems of this magnitude. But if you choose to do so, you can still act like the world’s problems are as big as they are. You can stop trusting the internal feelings to guide your actions and switch over to manual control.

6

This, of course, leads us to the question of “what the hell do you then?”

And I don’t really know yet. (Though I’ll plug the Giving What We Can pledge, GiveWell, MIRI, and The Future of Humanity Institute as a good start).

I think that at least part of it comes from a certain sort of desperate perspective. It’s not enough to think you should change the world — you also need the sort of desperation that comes from realizing that you would dedicate your entire life to solving the world’s 100th biggest problem if you could, but you can’t, because there are 99 bigger problems you have to address first.

I’m not trying to guilt you into giving more money away — becoming a philanthropist is really really hard. (If you’re already a philanthropist, then you have my acclaim and my affection.) First it requires you to have money, which is uncommon, and then it requires you to throw that money at distant invisible problems, which is not an easy sell to a human brain. Akrasia is a formidable enemy. And most importantly, guilt doesn’t seem like a good long-term motivator: if you want to join the ranks of people saving the world, I would rather you join them proudly. There are many trials and tribulations ahead, and we’d do better to face them with our heads held high.

7

Courage isn’t about being fearless, it’s about being able to do the right thing even if you’re afraid.

And similarly, addressing the major problems of our time isn’t about feeling a strong compulsion to do so. It’s about doing it anyway, even when internal compulsion utterly fails to capture the scope of the problems we face.

It’s easy to look at especially virtuous people — Gandhi, Mother Theresa, Nelson Mandela — and conclude that they must have cared more than we do. But I don’t think that’s the case.

Nobody gets to comprehend the scope of these problems. The closest we can get is doing the multiplication: finding something we care about, putting a number on it, and multiplying. And then trusting the numbers more than we trust our feelings.

Because our feelings lie to us.

When you do the multiplication, you realize that addressing global poverty and building a brighter future deserve more resources than currently exist. There is not enough money, time, or effort in the world to do what we need to do.

There is only you, and me, and everyone else who is trying anyway.

8

You can’t actually feel the weight of the world. The human mind is not capable of that feat.

But sometimes, you can catch a glimpse.

Typing Mathematical Symbols on Apple devices

2021-09-13T00:00:00+00:00

Now we can easily type mathematic symbols on macOS and iOS devices! Great for explaining scientific or mathematic problems on line without writing !.

Welcome Back, My Blog

2021-08-25T00:00:00+00:00

Welcome back. The first thing that you will NOT notice is that the password is gone. Well - no one should have noticed this, because no one can see whether this is a blog or not with that password.

This blog is without doubt one of my longest-kept continuous journals. Well, I do keep a diary. But that was a year after this blog… Anyway.

To whom it may concern, I’ve said that the password was added to protect privacy - and that remains correct - All previous sensitive posts have been not only removed but also erased. You know, the internet may not have memory, but we as humans obviously do.

During this four years’ journey with this blog and the three years with my diary, I have learned to appreciate my own history by looking back at it. Never will I try to erase my history, yet I will not prevent others from erasing theirs from me - that’s a fundamental human right. That’s why my diary will never be open to the public, and that’s also why this blog is open so that people can come and understand me:

I’m here: always here to listen to you, and keep what I’ve heard as is.

I’m also here: to tell my own stories, and convey the very self of mine.

Password Added

2020-10-10T00:00:00+00:00

Recently some concerns have raised about Google indexing this blog. Therefore, a password is added, and robots.txt is set to explicitly prohibit blogs from being indexed.

Password tips - Michael Kjörling

2020-03-09T00:00:00+00:00

Original Post None of the original text has been changed and this is simply a copy of the original post for convenience.

Passwords Are Important.. Basically your entire online life, and a lot of your offline life, is protected in some way by passwords. In many cases, other peoples’ lives are protected by your passwords; this applies, for example, if you have access to personal information on others through your professional position.

Yet passwords often get the short end of the stick. Lots of people use simple passwords; it is common for people to use a single password or a small number of different passwords; and most passwords that people use aren’t very imaginative, let alone random. Lists like “the top 1000 passwords on the Internet” show up every once in a while, and invariably, a large fraction of accounts can be broken into using those relatively few passwords. There are relatively easy ways to not be one of the easy targets.

Terminology: entropy

An important word to know with regards to passwords is entropy. Without going into mathematics, “entropy” in the context of passwords is simply a measure of how difficult a given password would be to guess.

The entropy of a password can barely be defined, but the entropy of a method of generating passwords can be defined. The entropy is an expression of how many different passwords can be generated by the method of generating passwords, often expressed in terms of bits. Adding one bit doubles the number of possible passwords.

Many attacks on passwords can broadly be broken into two categories. There are social attacks, which rely on tricking you into divulging your password, where the password itself does not help much; and technological attacks, where the strength of the password can matter a great deal. Adding a few extra characters to your password, chosen at random, greatly increases the entropy of your password and thus its resistance to attacks.

How not to do it

The first myth to be done away with is that passwords should be possible to remember. For the very most part, memorable passwords tend to have low enough entropy that a computer these days can find them easily. We need something better.

The second myth that needs to be displaced is that attackers use the same web form to log in as you do. That just is not the case in many attacks. Rather, attackers often get their hands on account databases; huge lists of usernames, email addresses, password hints, (hopefully) well-protected versions of the passwords, and/or other paraphernalia. They then use huge numbers of computers to attack these directly. In this case, depending on the exact methods used by whoever had their password database leaked, a single computer can potentially easily check millions of candidate passwords per second (some multiple of 2²⁰/sec). A network of systems can quite quickly bring this number into the billions of passwords per second (some multiple of 2³⁰/sec). The NSA is claimed to have been, in 2013, able to try on the order of a trillion passwords per second (2⁴⁰/sec); realistically, they are unlikely to do worse today. Properly protected passwords can bring these rates down to dozens per second per computer or even less; 2⁵/sec instead of 2²⁰/sec or so.

The third myth that has become obsolete is that you should never write passwords down. Actually, that is still about half true: what you shouldn’t do is write passwords down in a way such that an attacker can get at them. For passwords that can reasonably be believed to be secure against modern attackers, writing them down is almost a requirement, but you have to pay attention to the manner in which you write them down.

How to do it

So how should we be selecting and handling passwords these days? In short, I recommend that you:

Do not share your passwords with anyone
Use a password manager
Use unique passwords everywhere
Use random passwords everywhere (for both accounts where you don’t need to memorize the password, as well as those where you do need to memorize the password)
Back up your password database, religiously
Decide on and stick to a reasonable minimum password entropy
Do not change your passwords needlessly
Do not use “secret questions” for password recovery
Consider using password-quality usernames
Turn on any available last lines of defense

I go into more detail about each of these points below.

It’s really about as simple as that. There is virtually never any reason whatsoever to share your password with someone else, or divulge it anywhere but during the login process to the account it is protecting.

Social engineering attacks are called such because they focus not on the technological systems, but on the individual humans involved. And they are surprisingly effective; very often, they are far more effective than attacking the technology. Attackers using this technique can be very confidence-inspiring and sound very legitimate, so just because what they say sounds legitimate does not mean that they have your best interests at heart.

If you find yourself in the situation of thinking about sharing your password with someone, even someone you trust, consider if there is no other way to accomplish the same goal. Virtually always, there is.

A security-oriented professional should never, ever ask you for your password or other sensitive information. If they do, ask yourself why they need to know this information, why they need to get it from you, and if there is some other way to accomplish that same end.

For example: Why would your bank e-mail you and ask you to confirm your contact information in order to keep your account active? Why would they call you and ask you what your card number with them is? How could Microsoft afford the manpower to call their literally millions and millions of customers and help them, individually, to remove a virus from their (your) computer? And so on.

If a notice, particularly one that arrives as an e-mail, looks legitimate, then locate an older invoice, account statement or similar from the party involved and contact them using the contact information you already have for them. If it is legitimate, they will very likely be happy to help you out, but now you have contacted them on a point of contact that you already trust; if it’s not, then you just potentially saved your account with them from being hijacked, and possibly even saved yourself from an attempt at real-world identity theft or monetary theft.

The simple rule is to never, ever divulge your password to anyone else. If you want someone to help you do something to your account, log in yourself while they look away and then let them sit down at the computer while you stand beside them looking on.

Use a password manager

A password manager is a special-purpose database program that is specifically designed to simply and securely store and retrieve passwords and other relevant details for user accounts. They often include password generators, and can include other convenience features such as auto-type, web browser integration, search, and subcategories to help organize your password collection. There are password managers offered as cloud services, as well as software running locally on a computer under your control.

Find one that you like and start using it. I personally do not trust storing passwords with an external entity (such as a cloud service provider) but even that, with a good master password, is probably safer against most realistic attackers for the vast majority of people than you trying to make up and remember potentially hundreds of different passwords, or reusing passwords. Just have an idea what you will do if you receive a notice that the database has been breached, and if you do receive such a notice, implement it immediately. This most likely involves changing every single password that you have stored in that database, because the confidentiality of those passwords can no longer be guaranteed.

If you have reason to believe that you might be of special interest to a determined adversary, then you should probably pay even closer attention to the above, as well as adjust it according to your personal threat model.

Whether you use an online or local solution, make sure you back up the password database regularly.

Use unique passwords everywhere

Never use the same password for more than one account. I don’t care how clever you think your password scheme is or how much you love that password you came up with; just don’t. If the confidentiality of one of the passwords is somehow breached, then any other accounts where you have used the same password are suddenly at much higher risk of compromise.

Similarly, never use an obvious pattern for passwords to different services, unless those passwords have sufficient underlying cryptographic strength to withstand a reasonable attacker’s efforts anyway. (For example, it’s not a problem to use similar-length passwords generated from a similar character set everywhere if and only if a password of that length generated from that character set would be secure anyway. If you use the password helloworld1 for some service, it is probably not a good idea to use the password helloworld2 somewhere else, but if you use aif2eeth1oh for one service then using yek1xiekool for another is probably fine.)

The easiest approach is to simply use a truly unique password for each and every account or other place that requires a password. That way, should that password somehow be compromised, you only need to change that single password and deal with that single account compromise.

Use random passwords everywhere

Don’t try to come up with a password yourself. Use a properly generated, random password of sufficient strength for the thing, account or asset that you are trying to protect.

Passwords that you don’t have to remember

Frankly, this is the vast majority of passwords. Password managers can generate and keep track of virtually any number of passwords, and they can use character sets that are difficult to type (because most places where you need a password allow copying and pasting passwords during entry).

For these accounts, simply use your password manager’s feature to generate a long, random password with a large character set and use that. If you are unsure of which characters to use, you can start with the 32/Z85 character set:

0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#

This character set should be safe in most situations you are likely to encounter, and consists of digits, letters (lower- and uppercase), and special characters, but no whitespace, for a total of 85 different characters. A random password of appropriate length generated out of this set should be sufficient to satisfy any reasonable password requirements while providing reasonable cryptographic strength (log₂(85) or about 6.4 bits per character). For example, a 14-character password using the 32/Z85 set where characters are selected in a truly random fashion will provide about 90 bits of security, which should be sufficient to protect against all but the most determined of adversaries. To match the theoretical strength of 128-bit AES, you need a 20-character password selected out of an 85-character set.

Passwords that you have to remember

Unfortunately, there are a few passwords that we simply, realistically, have to be able to memorize. System login passwords and password manager master passwords are the main candidates that lend themselves poorly to being stored in a password manager.

For these, I recommend the Diceware method of generating passwords. (Diceware-style passwords are also known as XKCD-style passwords after the Password Strength comic, XKCD #936, posted by Randall Munroe in 2011; you may see references to both, but they are essentially the same thing.) A Diceware password is made up of words, selected out of a dictionary of 7,776 different words, selected by throwing physical dice. The number 7,776 represents the possible outcomes of throwing a single six-sided dice five times (6⁵ = 7,776), and each word is indexed in the word list by five digits from 1 through 6 (corresponding to the outcome of the dice throws). Each word added to the password contributes approximately 12.9 bits of cryptographic strength to the password. Because this method uses direct, physical randomness, we can directly estimate the cryptographic strength of a Diceware password; for example, a five-word password generated from this 7,776-entry dictionary provides about 64 bits of security, or a nine-word password provides about 116 bits.

With the standard Diceware dictionary, a separator is required, which works well if the system requires special characters in the password (just pick one that it likes as the word separator). Alternatively, the Electronic Frontier Foundation (EFF) has published a total of three alternative word lists, one “long” and two “short” lists, which are designed such that a separator is not required, although one can obviously still be used if desired. The “short” lists have fewer but shorter words, providing log₂(6⁴) = 10.3 bits per word instead of 12.9 bits per word. Hence, for approximately 64 bits of security with the short list, six words are needed giving about 62 bits of security, instead of five words from the long list for 64 bits of security.

The fact that Diceware passwords are made up of words is largely immaterial to their security. You could use the output of the dice directly, and the search space would be the same, but turning the numbers into words make the resulting passwords far easier to remember.

The most important part of generating Diceware-style passwords is that you must trust the randomness of the dice, and not try to improve on it or select words that are somehow more memorable to you. If you are unhappy with how it turned out, throw away the result and start all over. Anything less reduces the effective security of these passwords in a potentially unpredictable manner. This applies also to any generated password which makes sense in a linguistic sense; while this is unlikely, if the password reads as something you could say, then start all over.

Whichever word list you choose to use, properly generated Diceware passwords have a very strong advantage over actual phrases because it is actually possible to estimate their cryptographic strength while also being reasonably easy to memorize. Memorizing a six- or seven-word Diceware passphrase is perfectly reasonable; for most people, memorizing a 14-character 32/Z85 password is not.

If you can, something like a Yubikey configured to emit a static password can be used to greatly reduce the risk of someone shoulder-surfing your password. This static password can be used either as a prefix or a suffix to the password that you type. Yubikeys are not appropriate in all situations, and there are ways in which Yubikey static passwords can fail to significantly enhance the overall security, but if a Yubikey can work in your situation, strongly consider purchasing one and using it to enhance the security of the overall system. Do write down the password it emits and store the note in a secure location in case something happens to the Yubikey. Some cloud service providers allow you to use a Yubikey in one-time password mode to improve the security of the login process; do not confuse static password mode with one-time password mode.

Back up your password database, religiously

If you follow the advice elsewhere on this page, your passwords will be extremely difficult to crack. The vast majority of them will also, for all intents and purposes, be impossible to remember. If the password manager database becomes lost, corrupted, unavailable or otherwise can’t be read by normal means, you will be in major trouble.

To protect against losing access to all of your accounts, you have to make regular backups of the file(s) that contain your password database. If the password manager is doing its job properly, the files on disk will be strongly encrypted with a key ultimately protected by your master password, and thus be relatively safe to simply back up as-is without any additional protection. Copy them to some other media regularly (the exact interval depends on how often you make changes to your password database and how important you feel those changes are), and keep a few old revisions in case one of them becomes corrupted for some reason. Make sure you don’t forget the corresponding master password.

Do make sure to regularly test the copies. Nobody makes backups because it’s such fun to make backups; people make backups in order to be able to restore a working copy of the file in question. Determine how to test the restorability of these copies, and test restoring them every once in a while. Never fully trust a backup that you haven’t restored yourself.

If you are using local software on your own computer to store and manage the passwords, make sure to keep a copy of the installation file or archive for the version you are using, including any license keys or similar, together with the backed up password database. That way, should the need arise, you have everything on hand that is needed to get back to where you were on a completely new computer with an otherwise blank operating system installation.

Using a cloud service does not absolve you of the responsibility of making backups. In fact, unless you are specifically paying the provider to make backups and have successfully restored older versions of your data, assume that anything you store online is not being backed up at all and act accordingly. Locate some way to export or download the full list of accounts in a format that you can later import back into the solution, try it out, and download a copy of your database whenever you have made sufficient changes that recovering them manually would be difficult. Consider whether you can import the data into some other password manager, for example in case your preferred provider shuts down service for any reason. (This is less of a concern, but not completely eliminated, if you run a local software solution on your own computer.) Consider whether such an export needs any additional protection; if in doubt, contact your service provider. Again, keep a few old revisions in case one copy somehow becomes corrupt.

Decide on and stick to a reasonable minimum password entropy

I recommend not going below about 50 bits of security for most account passwords. This corresponds to maybe a few weeks of computing for a cybercrime-group level of attacker, which should be plenty enough to entice them to move on to easier targets, and provides a non-negligible hurdle for higher-funded attackers as well.

With Diceware-style passwords, this corresponds to a total of 20 dice throws, in turn corresponding to four words out of the ordinary-size dictionaries. With the 32/Z85 character set (or any other 85-character set) and random selection, this corresponds to 8 characters. With only lowercase letters and digits (a-z, 0-9), selected at random, it corresponds to 10 characters.

Keep in mind that this is what I suggest as a minimum and that, within reason, more is almost always better if you can wing it.

For high-value secrets, such as your password database, you should use a significantly stronger password. I suggest aiming for no less than 80-100 bits of security there, depending on your level of paranoia. Remember, if your password manager master password is broken, every password within it is compromised, so choose and treat the master password accordingly. 80-100 bits of entropy means 31-39 dice throws or 7-8 words for a diceware-style password, or 13-16 characters selected at random out of a set of 85, or 16-19 characters selected at random out of a-z, 0-9.

Keep in mind that some ordinary passwords may also be protecting high-value assets. For example, if someone is able to gain access to your e-mail account, they can often issue password reset requests on various services and gain access to your other accounts that way. Take this into consideration when you decide whether a minimum-security password is sufficient for a particular account, or if a longer password is called for.

Going beyond 256 bits of password entropy is almost never worth it, even with a safety fudging factor. Hence, 20 diceware words, 40 characters out of a set of 85, or 50 characters out of a-z 0-9, is the most you should realistically ever need.

Do not change your passwords needlessly

Some systems require you to change your passwords regularly, and if there is a forced policy in place that requires that you change your password, this obviously does not apply because it cannot apply.

However, most systems don’t require regular password changes. For those, unless you have reason to believe that your password may have been compromised or otherwise might have become known to a third party, don’t change your password.

If you follow the advice elsewhere on this page, your passwords will be plenty strong enough to resist almost any attacker for a very long period of time unless your own system is compromised.

If you follow the advice I give here, then

changing your password regularly does not make it significantly more difficult for an attacker to figure it out, and
if your own system is compromised, changing your password does not improve the security of your account unless you deal with the system compromise first

You should by all means change your password if you have any reason to believe that it has been compromised in any way. In fact, in such a situation, I would be the first to argue that you must change your password as quickly as possible, along with any answers to secret questions. (In such a situation, it might very well be better to immediately change to some simple password at the first indication of a breach, then change it again to a stronger one, just to lock an unauthorized person out of your account while you generate a new, strong password.) However, changing them every X weeks or months is pretty much completely pointless in most situations, particularly if you follow otherwise good password hygiene.

Make your passwords strong to begin with, and keep them to yourself. then, unless the password is actually compromised, there should be very little reason to change them.

Do not use “secret questions” for password recovery

Many sites offer “secret questions” for password recovery. In effect, these form a secondary password which can be used to gain access to your account in case you forget your actual password.

Worse still, these are often limited to a small set of possible questions, with one answer given for each, and the stock questions tend to be about information that can be quite easy to get. Even if a potential attacker doesn’t immediately have access to the information, any reasonable search space is usually far smaller than that of a proper length, random password.

Instead of filling these in truthfully, I recommend that you disable this altogether if that is possible. If you can’t do that (if the system forces you to pick such “security questions” and provide answers), then at least provide reasonably long, but bogus, answers. Treat them as the passwords they are, and give garbage “answers” that have absolutely no bearing on the question and are no easier to guess than your actual password.

For example, if you absolutely have to provide an answer to a “secret question”, and one option for the question is “in what town did you grow up?”, don’t answer it with anything remotely resembling the name of a real town, let alone the one where you actually grew up. Instead, here is a better answer that you could provide:

SsK}:aEjfkQ=koj-2t}$2$wxa:>#rTxg

If you are required to provide answers which look like words, turn to Diceware. For example, you could use (providing about 64 bits of security against someone who knows that you have a Diceware answer):

wow-witty-rap-bunny-pay

Of course, now that I have suggested these particular ones, don’t use those, but rather something similar. At the risk of repeating myself, treat the answer(s) to these security questions as the passwords they are.

Write down the question(s) and answer(s) in the notes field in your password database, or as separate entries in the unlikely case that your password manager provides no separate notes field. That way, if they ever turn out to actually be needed, you will have them on hand, but they will be no easier to get to than your actual account password.

Consider using password-quality usernames

Not all services require your username to be public or memorable. Some even make a point of that your username is not publicly available information. If the one you are registering with falls into such a category, such as an online store or financial institution where you log in with something other than an e-mail address and which you can choose yourself, consider creating a password-quality username to use along with your high-quality password.

This is not for everyone, and it is not for every place where a password is needed. But where it applies, having a username that is not related to you in any way beyond being used for your account can make breaking into the account far more difficult because now an attacker has to guess both your username and its corresponding password.

By using a username made up of (for example) 3-4 Diceware words, the length of the username remains reasonable yet the username is far harder for anyone to guess. Since you are using a password manager anyway, there is little to keep you from using different usernames for different services.

A password-quality username is not at all a replacement for a high-quality password, particularly because usernames are rarely protected even remotely as well as passwords. However, in situations where it applies, a password-quality username can be a great complement to slow an attacker down.

Turn on any available last lines of defense

Use two-factor authentication, if available

Two-factor authentication relies on something more than just a password to provide additional security. This can be an access code delivered over SMS, or generated by a physical token in your possession, or some other method. This makes it much harder for someone to log in to your account should they be able to guess your password, significantly improving the security.

Two-factor authentication doesn’t solve everything, and different methods have different security properties, but most turn what would have been an undetected attack against a static string (your password) into a significantly more overt attack against something that is far more likely to be detected. Using two-factor authentication will not stop a truly determined attacker, but it will make their job far more difficult.

If the service offers some form of notifications on login, turn those on. Make sure those notifications are delivered to some place other than the service or system that they are about. That way, should someone be able to guess your password, at least you will notice the login that you didn’t do and can hopefully take corrective action before the damage is too severe.

Keep in mind that particularly login notifications really form a last line of defense, kind of like a home security alarm system, in that they do not prevent the breach, but rather only notifies you of the breach after the fact. If this goes off, then everything else has already failed to protect you and your assets and the attacker has gained access to your account; proceed accordingly.

运动会总记

2019-11-15T00:00:00+00:00

是啊，2019年11月15日，又一届校运会闭幕了。也许要承接去年的同一篇Post，又抑或是要新作一篇文。无论如何。
自去年起，大部分文字早已诉诸于日记本了，太多曾经“梁山”“祝家庄”上思考的意味，也归于了那一本绿色的小册子。这Blog，也似乎不再有存在的必要。但无论如何，让它留着吧。也许哪一天，我就要捡起你。
本文的具体内容，请见日记本。

Test Write-a-post

2019-06-29T00:00:00+00:00

Test write-a-post

测试write-a-post

GitHub API test

2019-06-23T00:00:00+00:00

# This is the first post created by a GitHub API PUT request!

英语剧漫记

2019-02-28T00:00:00+00:00

英语剧是云大附中的传统迎新项目，每个元旦前几乎都会举办。表演者是初二年级，面向全校观众。今年，初二的我应班级要求负责了13，14班英语剧——Zootopia的音频剪辑工作。我学到了许多知识，也有了许多心得。
这项工作是我从未做过的，一切从新。范老师告诉我可以试试Adobe的软件，略加搜索，是Audition。可惜这款极佳的软件价值不菲，试用期却只有七天。我只好另找了开源免费的Audacity暂承担录音工作，待后期处理开始，再启用Audition的试用期。
录音是超级无聊但好玩的。
时间只有两个中午，是非常紧张的，作为录音师，你必须一刻不停地坐在电脑前，大气不出，在录音、播放、停止、删除几个键间来回挥动你手上的鼠标，并耐心地听着每一位演员的台词，看着老师的指示，作为英语班级第一，甚至还要担心演员们的发音（？）。
但是这又是十分有趣的事。剧中有一个角色，树懒闪电。在录这个角色时，可搞笑到了我们。这一幕持续近4分钟，期间搞笑片段无穷，我们却只能硬憋着笑，强忍着录完，最后因为有翻书声，这一段还差点重录，幸亏降噪功能给力才作罢。
还有，由于隔音教室紧张，老师让我和凯麟提前去那里霸教室，由于我们两个班的数学老师都是尹老师，我们便以“老尹语录”“你爹你妈买(mě)车，只买四个轱辘”一句作为暗号，以“确定”前来人员的身份。每每使用，总引来教室里一阵爆笑。
后期处理工作也是艰难但收获满满的。
Audition黑色的界面中，各种新奇功能应有尽有，但是——你要从头学。每一个术语，像“噪声样本”(即Noise Sample)，“频谱频率图”(即Spectrogram)都是未为我所知的；此外，我还学到了音乐的淡出，这是一个好玩的功能，还分为“线性淡出”“对数淡出”“余弦淡出”三种，用来复杂而有趣。同时，也感谢信息技术老师教给我的Adobe的界面设计思想，让我能够以软件设计者的方式思考，从而找到各个功能。
在工作中，我学到了不少。首先，最震撼了我的，是“喷麦”的处理。我本以为这是一个不可能的事，因为在我的印象中，这些声音是同时存在的，删一则均无。然则前文所及频谱频率图，却可以将它们分开，虽然如果操作不当，可能伴有失真。
此外，我还学到了，一处噪声样本不能再用于别处，用于一个人的噪声样本不能用于另一个人。在降噪刚开始时，我在刘畅的词处随意捕捉了一处噪声样本，便轻率地用于全部降噪。本想着这样就可以了，却没想到沙子辰的声音就全被降没了。再者，录音用了两中午，一下午，不同时间的噪声亦不同，混用亦不行。这也告诉我，学习不可能一蹴而就，只能一步步兢兢业业地向前。
最后，我还知道了，舞台要尽量杜绝空场；搜索背景音乐可以搜“…bgm”；还可以搜到没有词的背景音乐。
不过，之后重听录音，发现工作中也充满了我的失误。
作为“副导演”，我没有认真记录各演员的走场时间，所以第一稿有许多过于宽裕或紧凑的地方，甚至终稿也如此，在录音过程中，有很多吐字不清晰的地方，我也没有及时叫停重录。导致了英语剧的瑕疵。
在降噪过程中，正如前文所说，我滥用降噪功能，导致了沙子辰等部分人的词声音过小。又有几处“喷麦”，我企图偷懒，导致了几处失真。
最后，应14班的架子鼓手要求，我将最后的Try Everything一舞的音乐音乐音量调大，却没有确认调整的范围就应用了，结果最后音量忽大忽小，影响了最后演出的效果。
我们的工作中也是充满了合作的。凯麟同学自掏腰包为我们购买了无损的Michael Giacchino的原电影背景音乐，效果很好；申林灵和雷岚君两位同学牺牲了自己的休息时间，为我们创作出了两段极富感染力的舞蹈；沈曈为我们整理撰写了英语剧稿，其中虽有少量错漏，其也是不可替代的；最后范老师为我们的付出，最是不可计数的。
总而言之，在英语剧背景音乐的剪辑过程中，我收获良多。

运动会漫记

2018-11-16T00:00:00+00:00

2018年11月16日，又一届校运动会闭幕了。运动会，在我的心里，不知有什么特殊的意义。自从进了小学，就有了运动会。小学时的运动会，我总只是啦啦队，从没有什么项目。参加得最多的，是集体项目和开闭幕式的方阵。集体项目总是在学校里举行，且那时又不要求每天都到场，所以我在体育场便满是清闲，总之，很少为集体做什么贡献。再说方阵，我参加过三次方阵，而每次都会有不同的口号，比如一年级是“我运动，我健康，我快乐”。还有，我曾于六年级时当过小记者，于是进了场地，也写了几十篇稿，可是一篇也没有被念。这些兴许就是六年中关于运动会最深的回忆了。小学六年很快过去，这些也就成了回忆。进了云大附中，又是一番情景。初中强制我们每天到场，为运动员加油，所以我们每天都去看台晒太阳。中午午餐便是约着伙伴们解决，初一和加拿大的同学们吃了一餐；初二又和同学们跑远甩了两趟。又因为那次期中考考的不错，同学们都让我当班委，所以运动会从此我就加上了查人的任务。还有，初中的集体项目也移到了体育场进行。话说查人呀，还真不是一件容易的事。每天都要早去。组里的每个同学要上厕所，买水，或是其他事情都要向组长汇报，尽管如此，每一次老师让我们点人，总还是有几个人“不明失踪”。无论如何，我总是有了事做。初二，（依然是组长的）我又突发奇想，准备查清体育场内各机构的布局和厕所的分布情况，于是我便携着黄崟霏绕了三圈。其中有什么“信鸽协会”“老协”什么的甚是开人眼界；还有两个厕所只有男厕，没有女厕？真是奇特。总之，运动会代表着自由，代表着发现，代表着领导，也代表着“更高，更快，更远”的奥运精神。

忆昔昆石线

2018-10-22T00:00:00+00:00

在书桌前，偶然听到一声汽笛声，我连忙抬头望向窗外。转眼，跨越了百年历史的，昆明境内米轨昆石线已完全停运快一年了。
还记得那是2012年，是我才上小学时。我怀着无限的好奇第一次踏上了这一列每日两趟的蓝色火车。车票的形状是我早已记不清了的，只知道，与当时通行的红色车票很不同。从市区到石咀，坐上一会儿就到了。沿途经过了马街，跨过了昆明，充溢着浓浓的昆明市井气。到了站，我又兴奋地追火车，观看火车连接。我还好奇地问妈妈，火车这么长，是怎么掉头的。自己一研究，才明白了人字形的设计。这些事为我带来了对于铁路，这个最古老的交通工具之一的最初的兴趣。那真是一份十分新奇的体验。
后来班上组办的篮球班移到了每周六，在师大。于是，我每周又要和这班火车打交道了。那些早上，我的同学们都专注地拍着球，心中却总在等着什么。忽然，课上到一半，一声汽笛声呜呜地传来——火车来啦！火车来啦！我们都欢呼起来，齐刷刷地看向轨道。又是两声汽笛声，火车到了。那慢慢的火车却总能吸引我们的眼光，直到火车开过，才又回到课中。
2013年，连续两个多星期，我又在铁轨上行驶——这回是步行，不是坐车。那次，我突发奇想，这一条静卧了亘古的铁轨，究竟有多长？又有几根枕木在默默支撑？于是，我每个周末都和妈妈一起数枕木。从昆明北站，到海源中路，又是半个昆明。一根根枕木被我尽数踏遍，一个个道口被我依次记着。这条铁轨乃是十九世纪，英法入侵时期所建，向东南两次穿过高铁线，经过了九大高原湖泊之五的滇池，阳宗海，抚仙湖，星云湖，杞麓湖，异龙湖。直通河口，是当年抗战时期的“大动脉”——滇越铁路的终点，既承载了历史的风雨云烟，又记录了我童年的喜怒哀乐。
如今搬家到了铁路边，每日踏轨上学，却不见了曾经漫步在铁轨上的“东方红”柴油机车。心中不禁怅惘了几分。她去哪了？她还会回来吗？
以前走路穿越铁轨，总在想，道口处信号灯下的“红灯停车，灭灯停用”八个黑底白字，是什么意思。直到如今，才知道，这一声陪伴了我的火车汽笛，这一条绵延的米宽铁轨，也有离开我的时候。虽然新闻上说，她还会再开，只是为了新的地铁让路。但是，还是有太多的东西，只要放任失去了，就再也没有了；只有无尽的回忆，会永远萦绕在心头。

窗外

2018-09-16T00:00:00+00:00

雨季入夜，书桌前，我伏案苦读。忽然，风云突变，我不觉抬起头来，凝视着窗外。
天暗下来了。那平日早就稀薄的白云，不知何时，却被那普鲁士军事统治下般的乌云大军，赶出了它们极力想要掩护的蓝天。那乌云迈着大步，配合着早就吹起的大风，连太阳也被吓跑了。昏暗的窗外，一棵棵几人合抱粗的古树如同一株被践踏的小草一般左右摇曳，甚至开始嘎嘎作响，不禁令人疑惑：这景象是婀娜多姿？抑或是不堪重负？
忽然，一片亮光进入了尚未缩小的瞳孔——未等人们反应过来，“夸拉”——便是一片充满了空气的炸雷。顿时，婴儿的哭声，汽车的蜂鸣声不绝于耳，没有准备的我的耳朵里于是开始了嗡嗡作响——雷公威严，我不禁打了几个寒战。
那令万物惊心动魄的好戏却早已开始上演。不知何时，耳边开始充满一种淅淅沥沥的声音。打了这雷，人们方才略一思量——原来雨早已加入了这大战。雨打湿了窗，也冷却了我受惊的心。雨越下越大。窗外的雨声、风声配合紧密，试图用那响声将我催眠。却没料到半路雷声又怒吼着杀了回马枪——“噼啪噼啪”——“我才是老大！”此时这雷却是如那元日放响的爆竹一般炸耳了。
夜渐深了。雷声渐稀，雨却越密了。此时的雨，则成了医疗兵，安抚着受那大风摧残的树木；安慰着被那雷电点燃的大气，这兴许是“好雨知时节”的新解吧。雨声虽大，却不吵，反而哗啦哗啦地冲跑了其他的杂音——也许正适合睡觉。雷电也还不时闪几下，却是大势已去，再不能如方才般兴风作浪，扰人清梦了。
我凝视着窗外，谛听着窗外。如此神奇的窗外，带来大自然的神力的窗外。

春城爱雨

2018-08-27T00:00:00+00:00

至爱。昆明的雨季。这爱的是雨，是雷，还是雨季，我是分不清了的。
天暗下来了。那平日早就稀薄的白云，不知何时，却被那普鲁士军事统治下般的乌云大军，赶出了国土。黑云配合着早就吹起的大风，昏暗的窗外，一棵棵几人合抱粗的古树被吹得狂摇起来，甚至嘎嘎作响，不禁令人疑惑：这景象是婀娜多姿？抑或是不堪重负？
赏着，忽然看见一片亮光——未等人们反应过来，“夸拉”——便是一片炸雷充满了空气。顿时，婴儿的哭声，汽车的蜂鸣声不绝于耳，我没有准备，耳朵里于是开始了嗡嗡作响——也当然是心有余悸。
那令万物惊心动魄的好戏却早已开始上演。不知何时，耳边开始充满了一种淅淅沥沥的声音。打了这雷，人们方才略一思量——原来雨早已到来了。雨越下越大。雨声，风声配合紧密，使环境里充满了均匀噪声，似乎正是宜人，却不如那雷声引人注意——“噼啪噼啪”——这雷却是如那春日放响的炸耳鞭炮一般了。
夜渐深了。雷声渐稀，雨却越密了。雨声虽大，却不吵，反而哗啦哗啦地冲跑了其他的杂音——正适合睡觉。雷电也不时闪几下，却是大势已去，再不能如方才般打扰人了。
至爱雨声入梦，不觉，天亮了。

前进吧，附小人

2018-08-04T00:00:00+00:00

唱完国歌，总还是浮现出“在这里，四季如春”的歌词。
也许，
这就是周群校长对我们所有的附小人，无论何时加入，何时离开，的期望吧——“不忘初心，方得始终。”
会记得，我们曾说过，要有爱没有恨。
会记得，我们要活泼精神，相敬相亲；
要读书认真，头脑清新。
无论漂泊何方，都一定记住您的教诲——
良习修美德，好好做个人。
同时，也记住你们，我亲爱的同学们——
愿我们一日同学，终身是友！
要记住你们，我敬爱的老师们——
必然是一日为师，终身为父！
云南师大附小，以她博大的胸怀、悠久的历史，永远引领着一代代附小人，为社会带来生机！

A long bus ride

2018-07-14T00:00:00+00:00

今天坐了一次耗时1小时45分的公交车，东莞L6路，共坐了36个站，路上共上了51个人，其中刷卡25人，现金25人，二维码1人

小诗两首

2018-06-29T00:00:00+00:00

体育期末考

那天体育——期末考
下点小雨——真好跑
成绩进步——几十秒
天公作美——就是好
几天以后——笔头考
七科并进——真辛劳
学习不仅——期末考
小考大考——都不少
两年以后——考中考
无论如何——都要好
五年以后——是高考
一个转折——人人搞
人生路上——几多考
是坏是好——无人晓
只愿明日——复明日
咿唉——不要成蹉跎

厕所

莫言如厕便无难
赚得急者错喜欢
箭头只会往前指
厕所还在万山前
找到厕所依旧烦
过道里面长龙排
你喜我欢还不够
依旧堵在人群间

语义化版本 2.0.0

2017-11-18T00:00:00+00:00

语义化版本 2.0.0 By Wayou Liu ===

摘要

版本格式：主版本号.次版本号.修订号，版本号递增规则如下：

主版本号：当你做了不兼容的 API 修改，
次版本号：当你做了向下兼容的功能性新增，
修订号：当你做了向下兼容的问题修正。

先行版本号及版本编译信息可以加到“主版本号.次版本号.修订号”的后面，作为延伸。

简介

在软件管理的领域里存在着被称作“依赖地狱”的死亡之谷，系统规模越大，加入的套件越多，你就越有可能在未来的某一天发现自己已深陷绝望之中。

在依赖高的系统中发布新版本套件可能很快会成为恶梦。如果依赖关系过高，可能面临版本控制被锁死的风险（必须对每一个相依套件改版才能完成某次升级）。而如果依赖关系过于松散，又将无法避免版本的混乱（假设兼容于未来的多个版本已超出了合理数量）。当你专案的进展因为版本相依被锁死或版本混乱变得不够简便和可靠，就意味着你正处于依赖地狱之中。

作为这个问题的解决方案之一，我提议用一组简单的规则及条件来约束版本号的配置和增长。这些规则是根据（但不局限于）已经被各种封闭、开放源码软件所广泛使用的惯例所设计。为了让这套理论运作，你必须先有定义好的公共 API。这可以透过文件定义或代码强制要求来实现。无论如何，这套 API 的清楚明了是十分重要的。一旦你定义了公共 API，你就可以透过修改相应的版本号来向大家说明你的修改。考虑使用这样的版本号格式：X.Y.Z（主版本号.次版本号.修订号）修复问题但不影响 API 时，递增修订号；API 保持向下兼容的新增及修改时，递增次版本号；进行不向下兼容的修改时，递增主版本号。

我称这套系统为“语义化的版本控制”，在这套约定下，版本号及其更新方式包含了相邻版本间的底层代码和修改内容的信息。

语义化版本控制规范（SemVer）

以下关键词 MUST、MUST NOT、REQUIRED、SHALL、SHALL NOT、SHOULD、SHOULD NOT、 RECOMMENDED、MAY、OPTIONAL 依照 RFC 2119 的叙述解读。（译注：为了保持语句顺畅，以下文件遇到的关键词将依照整句语义进行翻译，在此先不进行个别翻译。）

使用语义化版本控制的软件“必须 MUST ”定义公共 API。该 API 可以在代码中被定义或出现于严谨的文件内。无论何种形式都应该力求精确且完整。
标准的版本号“必须 MUST ”采用 XYZ 的格式，其中 X、Y 和 Z 为非负的整数，且“禁止 MUST NOT”在数字前方补零。X 是主版本号、Y 是次版本号、而 Z 为修订号。每个元素“必须 MUST ”以数值来递增。例如：1.9.1 -> 1.10.0 -> 1.11.0。
标记版本号的软件发行后，“禁止 MUST NOT ”改变该版本软件的内容。任何修改都“必须 MUST ”以新版本发行。
主版本号为零（0.y.z）的软件处于开发初始阶段，一切都可能随时被改变。这样的公共 API 不应该被视为稳定版。
1.0.0 的版本号用于界定公共 API 的形成。这一版本之后所有的版本号更新都基于公共 API 及其修改内容。
修订号 Z（x.y.Z | x > 0）“必须 MUST ”在只做了向下兼容的修正时才递增。这里的修正指的是针对不正确结果而进行的内部修改。
次版本号 Y（x.Y.z | x > 0）“必须 MUST ”在有向下兼容的新功能出现时递增。在任何公共 API 的功能被标记为弃用时也“必须 MUST ”递增。也“可以 MAY ”在内部程序有大量新功能或改进被加入时递增，其中“可以 MAY ”包括修订级别的改变。每当次版本号递增时，修订号“必须 MUST ”归零。
主版本号 X（X.y.z | X > 0）“必须 MUST ”在有任何不兼容的修改被加入公共 API 时递增。其中“可以 MAY ”包括次版本号及修订级别的改变。每当主版本号递增时，次版本号和修订号“必须 MUST ”归零。
先行版本号“可以 MAY ”被标注在修订版之后，先加上一个连接号再加上一连串以句点分隔的标识符号来修饰。标识符号“必须 MUST ”由 ASCII 码的英数字和连接号 [0-9A-Za-z-] 组成，且“禁止 MUST NOT ”留白。数字型的标识符号“禁止 MUST NOT ”在前方补零。先行版的优先级低于相关联的标准版本。被标上先行版本号则表示这个版本并非稳定而且可能无法达到兼容的需求。范例：1.0.0-alpha、1.0.0-alpha.1、1.0.0-0.3.7、1.0.0-x.7.z.92。
版本编译信息“可以 MAY ”被标注在修订版或先行版本号之后，先加上一个加号再加上一连串以句点分隔的标识符号来修饰。标识符号“必须 MUST ”由 ASCII 的英数字和连接号 [0-9A-Za-z-] 组成，且“禁止 MUST NOT ”留白。当判断版本的优先层级时，版本编译信息“可 SHOULD ”被忽略。因此当两个版本只有在版本编译信息有差别时，属于相同的优先层级。范例：1.0.0-alpha+001、1.0.0+20130313144700、1.0.0-beta+exp.sha.5114f85。
版本的优先层级指的是不同版本在排序时如何比较。判断优先层级时，“必须 MUST ”把版本依序拆分为主版本号、次版本号、修订号及先行版本号后进行比较（版本编译信息不在这份比较的列表中）。由左到右依序比较每个标识符号，第一个差异值用来决定优先层级：主版本号、次版本号及修订号以数值比较，例如：1.0.0 < 2.0.0 < 2.1.0 < 2.1.1。当主版本号、次版本号及修订号都相同时，改以优先层级比较低的先行版本号决定。例如：1.0.0-alpha < 1.0.0。有相同主版本号、次版本号及修订号的两个先行版本号，其优先层级“必须 MUST ”透过由左到右的每个被句点分隔的标识符号来比较，直到找到一个差异值后决定：只有数字的标识符号以数值高低比较，有字母或连接号时则逐字以 ASCII 的排序来比较。数字的标识符号比非数字的标识符号优先层级低。若开头的标识符号都相同时，栏位比较多的先行版本号优先层级比较高。范例：1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta < 1.0.0-beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0- rc.1 < 1.0.0。

为什么要使用语义化的版本控制？

这并不是一个新的或者革命性的想法。实际上，你可能已经在做一些近似的事情了。问题在于只是“近似”还不够。如果没有某个正式的规范可循，版本号对于依赖的管理并无实质意义。将上述的想法命名并给予清楚的定义，让你对软件使用者传达意向变得容易。一旦这些意向变得清楚，弹性（但又不会太弹性）的依赖规范就能达成。

举个简单的例子就可以展示语义化的版本控制如何让依赖地狱成为过去。假设有个名为“救火车”的函式库，它需要另一个名为“梯子”并已经有使用语义化版本控制的套件。当救火车创建时，梯子的版本号为 3.1.0。因为救火车使用了一些版本 3.1.0 所新增的功能，你可以放心地指定相依于梯子的版本号大等于 3.1.0 但小于 4.0.0。这样，当梯子版本 3.1.1 和 3.2.0 发布时，你可以将直接它们纳入你的套件管理系统，因为它们能与原有相依的软件兼容。

作为一位负责任的开发者，你理当确保每次套件升级的运作与版本号的表述一致。现实世界是复杂的，我们除了提高警觉外能做的不多。你所能做的就是让语义化的版本控制为你提供一个健全的方式来发行以及升级套件，而无需推出新的相依套件，节省你的时间及烦恼。

如果你对此认同，希望立即开始使用语义化版本控制，你只需声明你的函式库正在使用它并遵循这些规则就可以了。请在你的 README 文件中保留此页连结，让别人也知道这些规则并从中受益。

FAQ

在 0.y.z 初始开发阶段，我该如何进行版本控制？

最简单的做法是以 0.1.0 作为你的初始化开发版本，并在后续的每次发行时递增次版本号。

如何判断发布 1.0.0 版本的时机？

当你的软件被用于正式环境，它应该已经达到了 1.0.0 版。如果你已经有个稳定的 API 被使用者依赖，也会是 1.0.0 版。如果你很担心向下兼容的问题，也应该算是 1.0.0 版了。

这不会阻碍快速开发和迭代吗？

主版本号为零的时候就是为了做快速开发。如果你每天都在改变 API，那么你应该仍在主版本号为零的阶段（0.y.z），或是正在下个主版本的独立开发分支中。

对于公共 API，若即使是最小但不向下兼容的改变都需要产生新的主版本号，岂不是很快就达到 42.0.0 版？

这是开发的责任感和前瞻性的问题。不兼容的改变不应该轻易被加入到有许多依赖代码的软件中。升级所付出的代价可能是巨大的。要递增主版本号来发行不兼容的改版，意味着你必须为这些改变所带来的影响深思熟虑，并且评估所涉及的成本及效益比。

为整个公共 API 写文件太费事了！

为供他人使用的软件编写适当的文件，是你作为一名专业开发者应尽的职责。保持专案高效一个非常重要的部份是掌控软件的复杂度，如果没有人知道如何使用你的软件或不知道哪些函数的调用是可靠的，要掌控复杂度会是困难的。长远来看，使用语义化版本控制以及对于公共 API 有良好规范的坚持，可以让每个人及每件事都运行顺畅。

万一不小心把一个不兼容的改版当成了次版本号发行了该怎么办？

一旦发现自己破坏了语义化版本控制的规范，就要修正这个问题，并发行一个新的次版本号来更正这个问题并且恢复向下兼容。即使是这种情况，也不能去修改已发行的版本。可以的话，将有问题的版本号记录到文件中，告诉使用者问题所在，让他们能够意识到这是有问题的版本。

如果我更新了自己的依赖但没有改变公共 API 该怎么办？

由于没有影响到公共 API，这可以被认定是兼容的。若某个软件和你的套件有共同依赖，则它会有自己的依赖规范，作者也会告知可能的冲突。要判断改版是属于修订等级或是次版等级，是依据你更新的依赖关系是为了修复问题或是加入新功能。对于后者，我经常会预期伴随着更多的代码，这显然会是一个次版本号级别的递增。

如果我变更了公共 API 但无意中未遵循版本号的改动怎么办呢？（意即在修订等级的发布中，误将重大且不兼容的改变加到代码之中）

自行做最佳的判断。如果你有庞大的使用者群在依照公共 API 的意图而变更行为后会大受影响，那么最好做一次主版本的发布，即使严格来说这个修复仅是修订等级的发布。记住，语义化的版本控制就是透过版本号的改变来传达意义。若这些改变对你的使用者是重要的，那就透过版本号来向他们说明。

我该如何处理即将弃用的功能？

弃用现存的功能是软件开发中的家常便饭，也通常是向前发展所必须的。当你弃用部份公共 API 时，你应该做两件事：（1）更新你的文件让使用者知道这个改变，（2）在适当的时机将弃用的功能透过新的次版本号发布。在新的主版本完全移除弃用功能前，至少要有一个次版本包含这个弃用信息，这样使用者才能平顺地转移到新版 API。

语义化版本对于版本的字串长度是否有限制呢？

没有，请自行做适当的判断。举例来说，长到 255 个字元的版本已过度夸张。再者，特定的系统对于字串长度可能会有他们自己的限制。

关于

语义化版本控制的规范是由 Gravatars 创办者兼 GitHub 共同创办者 Tom Preston-Werner 所建立。

如果您有任何建议，请到 GitHub 上提出您的问题。

授权

创用 CC 姓名标示 3.0 Unported 授权条款 http://creativecommons.org/licenses/by/3.0/

A Chinese test

2017-10-28T00:00:00+00:00

This is a Chinese test

中文

Test

2017-10-15T00:00:00+00:00

MBG

Setting up an AREDN supernode + local node with `systemd-nspawn`

Background

Prerequisites

Steps

Prepare the container filesystems

Configure network namespaces

First boot configuration

Host routing configuration

Further steps

Appendix

Troubleshooting

systemd unit files

Installing Arch Linux ARM on M1 UTM (Terminal)

Prerequisites

Prepare necessary files

Create UTM VM

Further configuration

Install Arch Linux

Inside the chroot

Before the first boot

Further set up

Shared drive and rosetta

(Optional) Install a full x64 system

Making a boost converter

Background

Design

Results

Reflection

Update (2024-03-08)

Gate signal at 10% duty cycle

Gate signal at 15% duty cycle

Gate signal at 47% duty cycle

Gate signal at 58% duty cycle

Output at 53% duty cycle (AC coupling)

Making a buck converter

Background

Design

Reflection

Update (2022-11-23)

Update (2022-11-30)

Leaving Hotmail.com

On caring - Nate Soares

1

2

3

4

5

6

7

8

Typing Mathematical Symbols on Apple devices

Welcome Back, My Blog

Password Added

Password tips - Michael Kjörling

Terminology: entropy

How not to do it

How to do it

Do not share your passwords with anyone

Use a password manager

Use unique passwords everywhere

Use random passwords everywhere

Passwords that you don’t have to remember

Passwords that you have to remember

Back up your password database, religiously

Decide on and stick to a reasonable minimum password entropy

Do not change your passwords needlessly

Do not use “secret questions” for password recovery

Consider using password-quality usernames

Turn on any available last lines of defense

Use two-factor authentication, if available

Turn on login notifications, if available

运动会总记

Test Write-a-post

Test write-a-post

GitHub API test

英语剧漫记

运动会漫记

忆昔昆石线

窗外

`systemd` unit files