DEV Community: Jang Rush

Import Posts to dev.to via RSS

Jang Rush — Sun, 24 May 2020 16:10:55 +0000

I imported most of my articles from mmap.page via the "Publishing to DEV from RSS" feature.

The automatic import feature works.
But there are still some issues left:

(expected) All imported post is published today. Because I just wrote some markdown files without writing any front matter meta data, including date. (Technically speaking, GitHub Pages (Jekyll) treat my markdown files as pages, not blog posts.)
(expected) No syntax highlight for code blocks. Because dev.to converts HTML back to markdown, thus all span tags for syntax highlight has been stripped. Anyway, there is no syntax highlight in the RSS reader either, because the RSS 2.0 specification does not support CSS style sheet and most RSS readers do not bother.
(unexpected) In some posts spaces after some punctuation marks, such as commas and periods, got stripped mystically. There may be a bug in the HTML to markdown converter used by dev.to.
(unexpected) Some posts are broken. It seems that dev.to will mistakenly treat triple backticks preceded by other characters (e.g. // ```rust) as start/end of code blocks.

So the proper way to import markdown files to dev.to is writing a script invoking the API of dev.to, which uses the markdown source directly, without the unreliable process of markdown (source) -> html (rss) -> markdown (dev.to). I will leave this trivial task to my future self.

WireGuard Quick Start

Jang Rush — Sun, 24 May 2020 15:36:48 +0000

WireGuard is an extremely simple yet fast and modern VPN that utilizes state-of-the-art cryptography.

– www.wireguard.com

Client Side

Install the WireGuard package / application for your operating system.

Create key pairs:

wg genkey | tee privatekey | wg pubkey > publickey

Create configuration file:

[Interface]
Address = <private ip of virtual network>/32
PrivateKey = <content of privatekey, base64 string>
DNS = 1.1.1.1

[Peer]
PublicKey = <content of server publickey, base64 string>
Endpoint = <public ip of server:51820>
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25

Interface is client info, and Peer is server info.

/32 is a subnet mask, which means one single IP.The client only uses one IP on the virtual network.

The DNS line is optional.But typically when you need to use a VPN,you probably do not want to trust DNS of your ISP.

If the client is behind NAT, the router will need to translate its internal IP and port before forwarding the packets to the Internet.And the router will keep tracks of the connectinos in a Network Address Translation table.Based on this NAT table, it routinely closes off ports that appear dormant.If the router erroneously closes the WireGuard port,the WireGuard service, unaware of this change, will continue to send packets to the closed port.This leads to network problems. PersistentKeepalive = 25 means sending a keeplive packet to the server every 25 seconds to prevent the NAT expiration (typically in 60 seconds for most routers).

0.0.0.0/0 means sending all Internet and VPN traffic to this server.

To enable the tunnel, run:

sudo wg-quick up /path/to/wg0.conf

If you uses a GUI WireGuard application, you can import the configuration file instead.

If you uses the WireGuard mobile application, the fast way to import the configuration is scan a QR code:

cat /path/to/wg0.conf | qrencode -t ansiutf8

Server Side

Install the WireGuard package in server,then generate key pairs as mentioned above.

Create /etc/wireguard/wg0.conf:

[Interface]
Address = <private ip of virtual network>/24
PrivateKey = <content of privatekey, base64 string> 
ListenPort = 51820
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -A FORWARD -o wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -D FORWARD -o wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]
PublicKey = <content of client publickey, base64 string> 
AllowedIPs = <private ip of virtual network>/32

Interface is server info, and Peer is client info./24 is a subnet mask, which means the virtual network allows for up to 254 clients.PostUp forwards Internet requests from clients, and eth0 is the network interface to access Internet on the server.PostDown deletes the iptable rules when the VPN is off.Actually these are WireGuard hooks, you can fill any shell command here.

You can add more clients (multiple [Peer] sections).

On Linux, WireGuard utilizes Linux kernel to forward packets from one network interface to another, e.g. wg0 to eth0,since wg0 itself does not have Internet access.Thus we need to configure kernel parameters:

echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

sysctl modifies kernel parameters at runtime.This is only required on the server, since client allow Internet through server.

Start WireGuard:

sudo wg-quick up /path/to/wg0.conf

You may also add WireGuard service to your init system, e.g. systemd:

sudo systemctl enable wg-quick@wg0.service

References

A Short Borg Tutorial

Jang Rush — Sun, 24 May 2020 15:36:16 +0000

Borg is the new generation of attic.

borg init --encryption=keyfile /path/to/repo
borg create -C lz4 /path/to/repo::NAME-YOUR-BACKUP ~/Documents

Free space

Before you start creating backups,please make sure that there is always a good amount of free spaceon the filesystem that has your backup repository (and also on ~/.cache).

Encryption

Default enabled with repokey method.

borg init --encryption=none|repokey|keyfile PATH

When repository encryption is enabled,all data is encrypted using 256-bit AES encryptionand the integrity and authenticity is verified using HMAC-SHA256.

repokey: key is stored inside the repository (config);
keyfile: key is stored under ~/.config/borg/keys/;

In both modes, the key is stored in encrypted formand can be only decrypted by providing the correct passphrase.

Do not forget to backup the key (e.g. via borg key export).

For automated backups the passphrase can be specifiedusing the BORG_PASSPHRASE environment variable.

Be careful how you set the environment;using the env command, a system() call or using inline shell scriptsmight expose the credentials in the process list directlyand they will be readable to all users on a system.Using export in a shell script file should be safe, however,as the environment of a process is accessible only to that user.Also, using a shell command may leak the passphrase in shell history file.

For server backup, have a look at borgmatic.

Compression

borg create --compression TYPE

Default is no compression.

fast repo storage and some compression: lz4
less fast repo storage and a bit more compression: zlib
very slow repo storage and high compression: lzma

lz4 is very fast thus preferred.lzma is preferred when the repository is on a remote host with slow (dial-up) connection.

Upgrade from attic

borg upgrade --inplace REPOSITORY

If a backup copy is required, omit the --inplace option.

Hosted Services

rsync.net also works with scp, rsync, git, etc. Nodes available globally.
BorgBase dedicated borg repository hosting with specific APIs. It also offers a free plan (5 GB and 2 repos), and paid plans are cheaper than rsync.net. Nodes available in US and EU.

OSX Survival Guide

Jang Rush — Sun, 24 May 2020 15:35:54 +0000

Bootstrap

strap is the successor of boxen created by the current homebrew maintainer Mike McQuaid.

Download the Script

curl https://raw.githubusercontent.com/MikeMcQuaid/strap/master/bin/strap.sh > strap.sh

Configuration

Edit the strap.sh script, e.g. using vim, and uncomment and fill up the following environment variables:

# STRAP_GIT_NAME=
# STRAP_GIT_EMAIL=
# STRAP_GITHUB_USER=
# STRAP_GITHUB_TOKEN=
# CUSTOM_HOMEBREW_TAP=
# CUSTOM_BREW_COMMAND=

STRAP_GIT_NAME and STRAP_GIT_EMAIL is to setup git user.name and user.email, and contact info on login screen.
STRAP_GITHUB_USER is to setup git github.user and to access your dotfiles and homebrew-brewfile repositories.
STRAP_GITHUB_TOKEN is needed to allow homebrew to reduce the rate limit of brew search command and to tap your private repositories (the token can be generated at GitHub > Settings > Developer settings > Personal access tokens, with scope repo, user).
CUSTOM_HOMEBREW_TAP and CUSTOM_BREW_COMMAND are optional, to add your personal homebrew tap and custom brew command which will be run at the end of the bootstrap.

The customized strap.sh can be automatically generated at https://macos-strap.herokuapp.com/,which asks for your authorization on GitHub.But I prefer to edit the script manually.

strap is idempotent, so you can run it first,adding custom dotfiles and brewfile repositories later,then run it again.

Run

/bin/bash strap.sh

Keyboard

In System Preference > Keyboard > Modifier Keys,Control and Command keys can be swapped,and Caps can be used as an additional Escape key.

Karabiner-Elements is a powerful keyboard modifier for osx.For example, it supports PC-style keyboard shortcuts.However, some of them do not work, and result in inconsistent keyboard shortcuts.It is recommend to swap Control and Command through Karabiner-Elements’ simple modification instead.And import certain complex rules like Alt-Tab from it individually.

Mouse

Unselect “Scroll direction: Natural” in System Preferences > Mouse.(The direction may be natural to touch screen, but it is not natural for mouse at all.)

Trackpad

Select “Tap to click” in System Preferences > Trackpad.

Lock Screen

Press Control+Shift+Power to turn off and lock screen.Alternatively, you can put the Screen Lock icon on touch bar (System Preference > Keyboard > Touch Bar).

Turn off Internal Display

When the power adapter is connected:

Close the lid to put laptop to sleep.
Reactivate laptop via external input devices, e.g. keyboard.

Tiling

Long press the restore button, then select tiling in drop-down menu.

Another way is activating mission control.Then move one window to another full screen window in another virtual desktop.

Drag the edge between two tiling windows to adjust the size of the two windows at the same time.

Virtual Desktops

Press Ctrl-Left/Right to switch among virtual desktops.

Press Ctrl-Up/Down to show an overview of desktops or go back to normal mode.

Finder

By default, ~/Library is hidden.To reveal it in Finder temporarily,hold the Option key, then click the Go menu,and the Library fodler is revealed in the dropdown menu.

To permanently reveal the Library folder in Finder, run the following command:

chflags nohidden ~/Library/

BTW, most applications’ user configuration files are in ~/Library/Application Support.

Safari

To enable developer tools, select “Show Develop menu in menu bar” in Safari > Preferences > Advanced.You can also change the default encoding to UTF-8.

There are several vi shortcuts extensions for safari, for example, sVim.

sVim can be configured via sVimrc via the extension settings in Safari.I mapped d and D to close and undo close tab:

" Shortcuts

map "d" quit
map "shift+d" lastClosedTab

Google

Google accounts can be added to the Mail.app.Except for the gmail, other osx applications can also sync with Google account:

Contacts
Calenders
Messages (with Google Talk)
Notes (via gmail, tagged as notes)

Use npm without package.json

Jang Rush — Sun, 24 May 2020 15:35:12 +0000

Why NOT package.json?

package.json brings in unnecessary complexity.If you do not think so, have a look at Go and Deno.

Everyday Use without package.json

Tell npm to not save package:

npm config set save false

Install development tools as global packages:

npm i -g typescript
npm install -g eslint
npm i -g @zeit/ncc

For temporal usage or test, use npx:

npx cloc index.js

npx can also be used to test different node versions:

npx -p node@13 node -v

Install dependencies as devDependencies:

npm i -D express
npm i -D @types/express

Use ncc to package runtime dependencies into a single JavaScript file:

# install dependencies according to resolved urls to tarballs in package-lock.json
@cat package-lock.json | jq '.dependencies[].resolved' | xargs npm i --no-package-lock
ncc build index.js --minify # output file: dist/index.js

Then you can move the bundled index.js file to any place where Node.js is installed,and run it with node index.js without installing any npm modules.

Alternative to `npm run`

Just use plain old Makefile, e.g.

dist/index.js: index.js
    @cat package-lock.json | jq '.dependencies[].resolved' | xargs npm i --no-package-lock
    ncc build index.js --minify

Pitfalls of TypeScript

Jang Rush — Sun, 24 May 2020 15:32:09 +0000

Excess Property Checking for Object Literal

TypeScript uses structural typing (to work with typical JavaScript code).

function print_height(person: { height: number }): void {
    console.log(person.height)
}

const somebody = { height: 150, weight: 150 };
print_height(somebody);

However, TypeScript has excess property checking for object literal.Thus if we inline the somebody declaration above, TypeScript raises an error:

print_height({ height: 150, weight: 150 }); // Error!

However, partial overlap is still permitted:

type Point = {
    x: number;
    y: number;
}
type Label = {
    name: string;
}
const partialOverlap: Point | Label = {
    x: 0,
    y: 0,
    name: "origin"
}
function print_pl(pl: Point | Label) {
    console.log(pl)
}
print_pl({ x: 0, y: 0, name: "origin"})

But overlap with conflicting properties is not permitted:

type Point = {
    x: number;
    y: number;
}
type SPoint = {
    x: string;
    y: string;
}
const conflictingProperties: Point | SPoint = {x: 0, y: "0"}

Function Overloads

Function type declaration supports overloading.

function plus(x: number, y: number): number;
function plus(x: string, y: string): string;
function plus(x: number, y: number): boolean; // see notes below
function plus(x: number | string, y: number | string): number | string | boolean { // this line is not overload
    if (typeof x == "number" && typeof y == "number") {
        return x + y;
    } else if (typeof x == "string" && typeof y == "string") {
        return `${x}${y}`; // equivalent to `x + y`.
    }
}

In the above example, the third overload will not be matched forever.Because TypeScripts looks at the overload list,proceeding with the first overload attempts to call the function with the provided parameters.If it finds a match, it picks this overload as the correct overload.And since intersection type of functions are defined as function overloads in TypeScript,this breaks the commutative rule of intersection function.Given two function types F and G, F & G and G & F are not equivalent.

Not surprisingly, it is difficult to check function overloads for type equality.

With TypeScript’s conditional types, testing type equality is intuitive:

type EqEq<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false

But it cannot handle function overloads and function intersection:

type FunctionOverloadsEquality = EqEq<
    { (x: 0, y: null): void; (x: number, y: null): void },
    { (x: number, y: null): void; (x: 0, y: null): void }> // true

type F = (x: 0, y: null) => void
type G = (x: number, y: string) => void
type FunctionIntersectionEquality = EqEq<F & G, G & F> // true

To check function overloads’ type equality, use this cleaver implementation by Matt McCutchen:

type EqEqEq<X, Y> =
    (<T>() => T extends X ? 1 : 2) extends
    (<T>() => T extends Y ? 1 : 2) ? true : false;

type FunctionOverloads = EqEqEq<
    { (x: 0, y: null): void; (x: number, y: null): void },
    { (x: number, y: null): void; (x: 0, y: null): void }> // false

However, it still cannot handle function intersection:

type FunctionIntersection = EqEqEq<F & G, G & F> // true

Besides, EqEq considers any to equal to any type except never.This makes sense, since unlike Any or Anything in other languages, TypeScript’s any is not a top type.any is assignable to any type except never.EqEqEq is more strict and does not consider any to be identical to other type.

Literal String, Literal Number, But Unique Symbol

TypeScript has literal strings and literal numbers, but there is no literal symbols.Instead, there is unique symbols (only allowed in const declarations).

In other words:

let no_unique_string_type: 'non sense but valid' = 'non sense but valid'
let no_literal_symbol: symbol = Symbol("cannot express Symbol(0) | Symbol(1)")

A Quick Introduction to React

Jang Rush — Sun, 24 May 2020 15:31:52 +0000

Hello World

import React, { ReactElement } from "react"
import ReactDOM from "react-dom"

type HelloProps = { readonly name: string }

function Hello({ name }: HelloProps): ReactElement<HelloProps> {
  return <button>Hello {name}!</button>
}

const helloWorld: ReactElement<HelloProps> = <Hello name="World" />

const rootElement: HTMLElement = document.getElementById("root")
ReactDOM.render(helloWorld, rootElement)

React Components

The Hello function is a React component,which receives an object containing properties,and returns a ReactElement.Here I do not plan to change the value of the name property,so I annotates it as readonly.But these properties can be mutable.ReactElements can be considered as extensible html elements,or some content to be rendered.A react component may return null for conditional rendering.

Hooks

Hooks decouple state related logic from components.Like components, hooks are just functions, nothing magical:

const SimpleReact = (function() {
    let state
    return {
      render(Component) {
        const C = Component()
        C.render()
        return C
      },
      useState(initialValue) {
        state = state || initialValue
        function setState(newValue) {
          state = newValue
        }
        return [state, setState]
      }
    }
})()

const useState = SimpleReact.useState
const render = SimpleReact.render

function useCountCharacters(str) {
    const [text, setText] = useState(str)
    const len = text.length
    return [len, setText]
}

function Component() {
    const [len, setLen] = useCountCharacters("")
    return {
      type: txt => setLen(txt),
      render: () => console.log({ len })
    }
}

let App = render(Component) // { len: 0 }
App.type('hello')
App = render(Component) // { len: 5 }

The real React will re-render components on state changes automatically.And there are other kind of hooks, e.g. useEffect for side-effects, triggered on state changes.Also, the real React can handle multiple hooks, which can be considered as an array of hooks.Whatever, the above naive implementation captures the essence of React Hooks.

JSX

<button>Hello {name}!</button> and <Hello name="World" /> are JSX,an extension to JavaScript, or a DSL to express DOM elements.TypeScript has excellent support for JSX. Thus JSX can be considered as typed HTML template expressions.

Component names such as Hello begin with an uppercase letter,while intrinsic HTML elements such as button begin with a lowercase letter.Certain attributes in HTML are renamed to resolve conflicts with TypeScript keywords.For example, the class attributes are renamed to className in JSX.

A component cannot directly return multiple elements.To return multiple elements, nest them inside a div element, then return that div.Sometimes returning an div element is not possible.For example, nesting multiple <td> elements in div results in invalid HTML.And sometimes, you just do not want to wrap them inside a div element.Under such conditions, you can wrap them inside a <React.Fragment>,which can be considered as a seamless div element.

<React.Fragment> accepts an optional key attribute,which is its only acceptable attribute.For example:

// type annotations omitted for brevity
function Glossary({ items }) {
  return (
    <dl>
      {items.map(item => (
        <React.Fragment key={item.id}>
          <dt>{item.term}</dt>
          <dd>{item.description}</dt>
        </React.Fragment>
      ))}
    </dl>
  )
}

key is a special attribute for React to identify member element in a list.It helps React to detect which members have changed, added, or removed.

JSX is syntax sugar for calling React.createElement,for example, <Hello name="World" /> is equivalent to:

React.createElement(Hello, { name: "World" });

So JSX is optional, you can use React without JSX.

Styling

React does not have an opinion about how styles are defined.You can define styles in separate *.css files.However, I prefer to define styles in TypeScript than CSS.You can check this comparison of CSS-in-JS.Again, there are a lot of choices.

Among those projects, I checked the five projects written in TypeScript:

jsxstyle and react-free-style are inline style systems. I do not like inline style systems.
freestyler’s APIs are complex. There are too many choices.
Both stylable and typestyle provide a type safe styling language.

stylable has a syntax similar to CSS, while typestyle just uses object literals (no custom AST transform).As I said before, I want to define styles in TypeScript, thus I pick typestyle.

Alternative Implementations

Preact is the most popular alternative implementation.It is small (3KB gzipped) and fast.However, to leverage many React libraries, preact/compat is required.This compatibility layer is slow.

Inferno is a faster alternative implementation.Unlike Preact, it is not that obsessed about the size (but still small).Like Preact, its compatibility layer inferno-compat has extra overhead.Also, hooks is not supported yet.

Nerv is yet another small alternative implementation.It features compatibility with IE 8 and a more identical React API.Thus there is no nerv-compat.

References

RarCrack

Jang Rush — Sun, 24 May 2020 15:31:39 +0000

This note is written for RarCrack 0.2.

RarCrack brute forces password for encrypted zip, rar, 7z files.

rarcrack FILE_NAME --threads 4

Note that if --threads is omitted, RarCrack will use 2 threads, no matter how many cores your CPU has.

You can cancel the brute forcing (e.g. via Ctrl-c) at any time,and RarCrack will resume cracking at next startup.This is because RarCrack uses a status file FILE_NAME.xml at the same directory to record progress.

And this mechanism can be used to speed up cracking.For example, if you remember that the password is 6 digits:

<?xml version="1.0" encoding="UTF-8"?>
<rarcrack>
  <abc>0123456789</abc>
  <current>000000</current>
  <good_password/>
</rarcrack>

For zip and 7z files, an alternative to RarCrack is fcrackzip.And it has more features, e.g. specifying password range and using a dictionary.However, last time I tried to fcrackzip a zip file,it reported that the zip file is corrupt.And RarCrack successfully cracks the very zip file.

A Basic Guide for New Marionettists

Jang Rush — Sun, 24 May 2020 15:31:07 +0000

TLDR

This article only covers the so-called masterless mode, a.k.a. puppet apply,because the master-slave mode is unethical and bolt sounds violent. On the other hand, puppet apply plays the role of both master and slave, which is considered not unlikely inoffensive.

Puppet uses a declarative DSL, i.e. describing the state of puppets. Below is an example from the official document:

case $operatingsystem {
  centos, redhat: { $service_name = 'ntpd' }
  debian, ubuntu: { $service_name = 'ntp' }
}

package { 'ntp':
  ensure => installed,
}

service { 'ntp':
  name => $service_name,
  ensure => running,
  enable => true,
  subscribe => File['ntp.conf'],
}

file { 'ntp.conf':
  path => '/etc/ntp.conf',
  ensure => file,
  require => Package['ntp'],
  source => "puppet:///modules/ntp/ntp.conf",
}

This guide applies to Puppet 6.7.

Quick Start

Install the puppet-agent package (which provides puppet apply),following the instructions at official document.

As an oversimplified example, I wrote a script to ensure git is installed:

# filename: laptop.pp
package {'git':
  ensure => installed
}

Validate its syntax:

puppet parser validate laptop.pp

In practice, this is mainly for CI,since a decent editor should have warned you if you made some syntax mistakes.

Rehearse the play (dry run):

puppet apply --noop laptop.pp

It’s show time: (run as root since installing package usually requires root permission)

puppet apply laptop.pp

You can also pass a directory instead of a file to puppet apply.But in this case Puppet combines all files under that directory as one script,without isolated scope.Thus I prefer use one file.

Puppet DSL

Style

The Puppet community prefers snake_case and two spaces soft tab.

Selector Expression

Selector expression returns a value.For example, the case “statement” in the beginning code sample:

case $operatingsystem {
  centos, redhat: { $service_name = 'ntpd' }
  debian, ubuntu: { $service_name = 'ntp' }
}

can be rewritten as:

$service_name = $operatingsystem ? {
  centos, redhat => 'ntpd',
  debian, ubuntu => 'ntp',
}

Strictly speaking, they are not semantically equivalent.If the os failed to match, the former will do nothing,while the later will refuse to compile.

However, the if and case “statements” are actually expressions,returning the value of the last expression in the executed blockor undef when no block was executed.

Puppet Defaults

Puppet DSL has a wired syntax (capitalizing type name) for declaring defaults for a specific type of puppet:

# Set default values for the path attribute of the exec puppet.
Exec {
  path => '/usr/bin:/bin:/usr/sbin:/sbin',
}

The more wired part is, puppet defaults are dynamically scoped!

Therefore, using per-expression defaults is preferred.Below is an example from the official document:

file {
  default:
    ensure => file,
    owner => "root",
    group => "wheel",
    mode => "0600",
  ;
  ['ssh_host_dsa_key', 'ssh_host_key', 'ssh_host_rsa_key']:
    # use all defaults
  ;
  ['ssh_config', 'ssh_host_dsa_key.pub', 'ssh_host_key.pub', 'ssh_host_rsa_key.pub', 'sshd_config']:
    # override mode
    mode => "0644",
  ;
}

Puppet Collector

This is sometimes called the “spaceship operator”,which selects a group of puppets via attribute searching:

User <| groups == 'wheel' |>

Besides ==, there are other operators, !=, and, and or.

Lazy Puppet

The at (@) prefix marks a puppet declaration as lazy:

@user {'ubuntu':
  uid => 1000,
  comment => 'default user',
  group => wheel,
}

Lazy puppets will not be applied until:

explicitly realized, e.g. realize User['ubuntu'], or
implicitly realized by a matched collector, e.g. User <| group == wheel |>.

Glossary

This guide uses different terms to the official Puppet documentation.These are just my personal preference.For example, the script term used in this guide is called manifest in the official Puppet documentation.In my opinion, script makes more sense than manifest.In fact, chef refers to the similar notation as recipe.

agent Puppet actually uses the term agent instead of slave, but this is just a euphemism.
catalog In master slave mode, catalog are compiled by master with stage specific information. In puppet apply mode, it is just unimportant mid-product.
class A set of puppets. And a subclass is an extended set of puppets base on another set of puppets, a.k.a. a class inherits another class.
environment A play.
fact A detail about the stage.
Facter The stage manager can tell you details about the stage.
filebucket A repository for file backups.
Hiera A built-in key-value database for puppet.
lambda In Puppet, a lambda can only be used in function calls. That is, it can only be passed to functions, but cannot be assigned to variables. To some extent, it is more like Ruby’s block.
manifest The script used by a marionettist. Puppet refers to the entry point as main manifest or site manifest. puppet apply only cares about the script passed to it on the command line.
node The stage for the show. In puppet apply mode, the local machine is the only stage.
resource A puppet controlled by the marionettist. Puppet uses the term virtual resource to refer to lazy puppet.

Tinygo

Jang Rush — Sun, 24 May 2020 15:30:52 +0000

Tinygo is a Go compiler for microcontrollers and WebAssembly.It also supports x86 32 bit and 64 bit Linux.

Getting Started

Install

sudo apt install llvm-7-dev libclang-7-dev
go get -u github.com/tinygo-org/tinygo

Usage

To compile a Linux executable:

tinygo build -o hello_tiny hello.go

The output size of a hello world program is very impressive to me:

1.1M hello
12K hello_tiny

Or run it directly:

tinygo run hello.go

Go Language Features

Not supported:

Maps.
Concurrency.
Reflection.
Cgo.
Many parts of standard library (due to the above missing pieces).
recover()
complex64, complex128, and arithmetic on complex numbers.
defer a call on a function pointer.
3-index slicing, e.g. slice = array[2:4:7].

Dive into Rust

Jang Rush — Sun, 24 May 2020 15:30:23 +0000

Variable Shadowing

let mut guess = String::new();

io::stdin().read_line(&mut guess)
    .expect("Failed to read line");

let guess: u32 = guess.trim().parse()
    .expect("Please type a number!");

const CONSTANT: &str = "a constant expression, not the result of a function call computed at runtime";
let immutable_variable: &str = "variables are immutable by default";
let mut mutable_variable: u32 = 0;
let immutable_variable: &str = "shadowing the previous immutable_variable, which is bad";
let immutable_variable: u32 = 1;

Data Types

Scalar Types

Integer: i8, i16, i32, i64, i128, isize and their unsigned counterpart u8, …, usize. isize is i32 on 32 bit systems and i64 on 64 bit systems. Integer types default to i32. Compiling in debug mode will check for integer overflows. Relying on integer overflow’s wrapping behavior is considered an error, use the Wrapping type instead.
Floats: f32 and f64.
Boolean: bool (values: true and false).
Character: char (Unicode Scalar Value).

Compound Types

Tuple: tuple index must be written as a decimal literal, e.g. (0, 1, 2).1.
Array: can be considered as a tuple whose elements all have the same type. Index out of bounds is a runtime error though.

Control Flow

Condition must be a bool.Nice!

Enum

Rust’s enum is actually a tagged union.

Generics

Rust monomorphizes code that is using generics at compile time.

Traits

Rust’s traits is similar to interface in other languages.

Memory Management

Rust does not use GC or RC.For values on the heap, it only allow one variable “own” a value at a time.Assignment, passing a value to function and returning a value move the “ownership”.Also, Rust allows multiple immutable pointers (&) but only one mutable pointer (&mut),and restricts mixing immutable and mutable pointers to the same target.The basic idea is to keep the number of reference to a value to one,to make memory management easier for the compiler.

let s1 = String::from("A long long string");
let s2 = s1 + ".";

Conceptually s2 can be considered as a newly constructed immutable variable,but since the ownership moves from s1 to s2, and s1 becomes invalid afterwards,the compiler just need to appends "." to the end of the value, which is efficient.

Smart pointers can be used for reference counting.Smart pointers are structs satisfying Deref and Drop traits.

enum List {
    Cons(i32, Box<List>),
    Nil,
}

In the above example, Box<List> is a smart pointer.We use Box<List> to store the Box<List> data on the heap,otherwise Cons(i32, List) will result in infinite size on the stack,which causes Rust failed to construct the List enum.

To allow cons more than one lists from a same base list:

enum List {
    Cons(i32, Rc<List>),
    Nil,
}

Rc is another smart pointer for reference counting.It increases the reference counter on RC::clone(&l),and reduce the reference counter automatically when the related variable goes out of scope.When there are zero references, the value will be cleaned up.

Be aware that Rc only works in single-thread context.In multiple-threads context, use Arc instead.

In Rust, functions and struts working with references need lifetime annotation.However, Rust can infer function lifetime in simplest cases:

If there is only one reference input parameter, then its lifetime will be the lifetime of output values.
If there are multiple reference input parameters, but one of them is &self or &mut self, then its lifetime will be the lifetime of output values.

String literals have a 'static lifetime, which lives for the entire duration of the program.

let b;
{
    let a = "hi";
    b = a;
}
println!("{}", b); // prints "hi"

Lifetime annotation tells Rust compiler the lifetime of variables,but it cannot alter the lifetime.

Testing

While Go use special function name TestXxx, Rust uses #[test] attribute annotation.

Unit tests are written in mod tests, and integration tests are put in the test directory.

Documentation Comments

Three leading slashes /// with Markdown.

Similar to Python, Rust also supports doctest:

/// # Example
///
/// ```


/// let foo = "foo";
/// assert_eq!(foo, "foo");
///




## unsafe

In the unsafe block (`unsafe {}`), you can:

- 

Dereference a raw pointer which

  - can have both immutable and mutable pointers or multiple mutable pointers to the same location;
  - is not guaranteed to point to valid memory;
  - can be null;
  - does not implement any automatic cleanup.
- 

Call an unsafe function or method (`unsafe fn dangerous() {}`, including foreign functions such as C functions).

- 

Access or modify a mutable static variable (Rust call global variables as static variables).

- 

Implement an unsafe trait.

- 

Access fields of an union (the unsafe counterpart of Rust’s `enum`, mainly used for FFI).

JupyterLab Guide

Jang Rush — Sun, 24 May 2020 15:30:14 +0000

JupyterLab is the next generation UI of Jupyter Notebook (formly known as IPython Notebook).

Installation

JupyterLab can be installed via conda, pip, and pipenv.

For example, to install with conda:

conda install -c conda-forge jupyterlab

Once installed, you can start it with:

jupyter lab

To shutdown JupyterLab, first shutdown all kernels while Kernel menu,then type ctrl-c.

Notebooks

Jupyter notebooks combines:

live runnable code cells
text cells (Markdown, LaTeX equations, images, interactive visualizations)

Multiple view(tabs) can be opened for the same notebook,with synced content.

The blue collapser button on left of each cell can trigger collapsing and expanding cells.

Right-click on a notebook and select “New Console for Notebook” can attach to the notebook kernel.This provides a log of all computations done in the kernel (in the order in the order in which they were done),and a place to interactively inspect kernel state without changing the notebook.

Raw HTML

IPython kernel provides a variety of convenience classes for displaying rich output, including HTML:

from IPython.display import display, HTML
display(HTML('<del>Hello World</del>'))

~~Hello World~~

from IPython.display import display
display({'text/html': '<del>Hello World</del>'}, raw=True)

~~Hello World~~

MIME types supported by default:

document: text/markdown, text/html, text/latex, application/vdom.v1+json (Virtual DOM)
images: image/bmp, image/gif, image/jpeg, image/png, image/svg+xml
data: application/json, application/vnd.vega.v2+json, application/vnd.vegalite.v1+json
other: CSV (as .csv files, no MIME type), PDF (as .pdf files, with application/pdf MIME type, view only)

Other Jupyter kernels offer similar APIs.

Keymap

Keyboard shortcuts can be viewed in menu, context menu, and command palette (Commands tab of sidebar).

Keyboard shortcut for command palette: Ctrl+Shift+c

Code Cell/Console

Tab: complete.
Shift+Tab: tooltip.
Shift+Enter: run code.

Image File Viewer

+ and -: zoom
[ and ]: rotate
H and V: flip horizontally/vertically
I: invert the colors
0: reset

Mouse

Besides keyboard, mouse is also useful.Drag and drop cells within one notebook to rearrange them;drag and drop cells within notebooks to copy content;drag and drop tabs to arrange their layout.

Extensions

JupyterLab extensions are npm packages.

To install extensions, first install nodejs.For example, via conda:

conda install -c conda-forge nodejs

Then use jupyter labextension to manage extensions,via invoking subcommands like list, install/uninstall, enable/unable.

Tools and Services

nbdime

nbdime provides tools for diffing and merging of Jupyter Notebooks.

nbdiff compare notebooks in a terminal-friendly way
nbmerge three-way merge of notebooks with automatic conflict resolution
nbdiff-web shows you a rich rendered diff of notebooks
nbmerge-web gives you a web-based three-way merge tool for notebooks
nbshow present a single notebook in a terminal-friendly way

nbconvert

nbconvert allows you to convert a Jupyter .ipynb notebook document file into another static format including HTML, LaTeX, PDF, Markdown, reStructuredText, and more.

nbviewer is a free web service based on nbconvert to share static html versions of notebook files.

Binder

Binder is a free web service to turn a GitHub repo into a collection of interactive notebooks:

Enter a url to a GitHub repo of Jupyter notebooks.
Binder builds a Docker image for the repository, based on requirements.txt or environment.yml in repository’s root directory.
Binder launches a JupyterHub server. It provides a reusable/shareable link to live repository.

This guide itself is authored in JupyterLab.

DEV Community: Jang Rush

Import Posts to dev.to via RSS

WireGuard Quick Start

Client Side

Server Side

References

A Short Borg Tutorial

Free space

Encryption

Compression

Upgrade from attic

Hosted Services

OSX Survival Guide

Bootstrap

Download the Script

Configuration

Run

Keyboard

Mouse

Trackpad

Lock Screen

Turn off Internal Display

Tiling

Virtual Desktops

Finder

Safari

Google

Use npm without package.json

Why NOT package.json?

Everyday Use without package.json

Alternative to npm run

Pitfalls of TypeScript

Excess Property Checking for Object Literal

Function Overloads

Literal String, Literal Number, But Unique Symbol

A Quick Introduction to React

Hello World

React Components

Hooks

JSX

Styling

Alternative Implementations

References

RarCrack

A Basic Guide for New Marionettists

TLDR

Quick Start

Puppet DSL

Style

Selector Expression

Puppet Defaults

Puppet Collector

Lazy Puppet

Glossary

Tinygo

Getting Started

Install

Usage

Go Language Features

Dive into Rust

Variable Shadowing

Data Types

Scalar Types

Compound Types

Control Flow

Enum

Generics

Traits

Memory Management

Testing

Documentation Comments

JupyterLab Guide

Installation

Notebooks

Raw HTML

Keymap

Code Cell/Console

Image File Viewer

Mouse

Extensions

Alternative to `npm run`