Progress

July 01, 2017 · recv A

cd ~/.local/share/libvirt/images
mv Win7.qcow2 Win7.backup
qemu-img create -f qcow2 Win7.qcow2 100G
virt-df -h ./Win7.backup
virt-resize ./Win7.backup ./Win7.qcow2 --expand /dev/sda2
Reminder: if you want to support our animation film,
ZeMarmot, made with Free Software, for which we also
contribute back a lot of code, and released under
Creative Commons by-sa 4.0 international, you can
support it in USD on Patreon or in EUR on Tipeee.
Co-authored-by: Some One <some.one@example.foo>

rm -rf Projects/
rm -rf ~/.var/app/org.gnome.Builder/cache/
package main

func double(ch chan int) {
  for { ch <- (<-ch * 2) }
}

func main() {
  ch := make(chan int)
  go double(ch)
  ch <- 2
  x := <-ch
  print(x)
}

ch
double
double
(define (recv ch)
  (match ch
    (($ $channel recvq sendq)
     (match (try-dequeue! sendq)
       (#(value resume-sender)
        (resume-sender)
        value)
       (#f
        (suspend
         (lambda (k)
           (define (resume val)
             (schedule (lambda () (k val)))
           (enqueue! recvq resume))))))))

;; Note: this code has a race!  Fixed later.

recvq
sendq
recvq
recvq
sendq
suspend
i/o
recvq
CAS
select
select
select {
case c <- x:
  x, y = y, x+y
case <-quit:
  return
}

select
select
(select (recv A) (send B v))

select
(select (recv-op A) (send-op B v))

recv-op
send-op
select
choice-op
(define (select . ops)
  (perform (apply choice-op ops)))

select
(wrap-op op k)
(perform
 (wrap-op
  (recv-op A)
  (lambda (v)
    (string-append "hello, " v))))

"world"
A
perform
"hello, world"
select
exp
(lambda () exp)
recv
recv
sendq
recvq
(define (perform op)
  (match op
    (($ $op try block wrap)
     (define (do-op)
       ;; Return a thunk that has result values.
       (or optimistic
           pessimistic)))
     ;; Return values, passed through wrap function.
     ((compose wrap do-op)))))

wrap
try
#f
try
block
wrap
try
perform
block
wrap
wrap-op
try
(define (try-recv ch)
  (match ch
    (($ $channel recvq sendq)
     (let ((q (atomic-ref sendq)))
       (match q
         (() #f)
         ((head . tail)
          (match head
            (#(val resume-sender state)
             (match (CAS! state 'W 'S)
               ('W
                (resume-sender (lambda () (values)))
                (CAS! sendq q tail) ; *
                (lambda () val))
               (_ #f))))))))))

try
#f
state
W
S
CAS!
W
S
sendq
*
block
(define (pessimistic block)
  ;; For consistency with optimistic phase, result of
  ;; pessimistic phase is a thunk that "perform" will
  ;; apply.
  (lambda ()
    ;; 1. Suspend the thread.  Expect to be resumed
    ;; with a thunk, which we arrange to invoke directly.
    ((suspend
       (lambda (k)
        (define (resume values-thunk)
          (schedule (lambda () (k values-thunk))))
        ;; 2. Make a fresh opstate.
        (define state (make-atomic-box 'W))
        ;; 3. Call op's block function.
        (block resume state))))))

perform
W
C
S
W->C
C->W
C->S
block
W->S
W->S
perform
C
recv-op
block
block
block
recvq
recv
S
(define (block-recv ch resume-recv recv-state)
  (match ch
    (($ $channel recvq sendq)
     ;; Publish -- now others can resume us!
     (enqueue! recvq (vector resume-recv recv-state))
     ;; Try again to receive.
     (let retry ()
       (let ((q (atomic-ref sendq)))
         (match q
           ((head . tail)
            (match head
              (#(val resume-send send-state)
               (match (CAS! recv-state 'W 'C)   ; Claim txn.
                 ('W
                  (match (CAS! send-state 'W 'S)
                    ('W                         ; Case (1): yay!
                     (atomic-set! recv-state 'S)
                     (CAS! sendq q tail)        ; Maybe GC.
                     (resume-send (lambda () (values)))
                     (resume-recv (lambda () val)))
                    ('C                         ; Conflict; retry.
                     (atomic-set! recv-state 'W)
                     (retry))
                    ('S                         ; GC and retry.
                     (atomic-set! recv-state 'W)
                     (CAS! sendq q tail)
                     (retry))))
                 ('S #f)))))                    ; Case (2): cool!
           (() #f)))))))                        ; Case (3): we wait.

C
C
S
W
C
sendq
CAS
try
C
block
(choice-op (send-op A v) (recv-op A))
eq?
select
select
choose-op
try
try
block
block
wrap
wrap
(define (choice-op . ops)
  (define (try)
    (or-map
     (match-lambda
      (($ $op sub-try sub-block sub-wrap)
       (define thunk (sub-try))
       (and thunk (compose sub-wrap thunk))))
     ops))
  (define (block resume opstate)
    (for-each
     (match-lambda
      (($ $op sub-try sub-block sub-wrap)
       (define (wrapped-resume results-thunk)
         (resume (compose sub-wrap results-thunk)))
       (sub-block wrapped-resume opstate)))
     ops))
  (define wrap values)
  (make-op try block wrap))

recv
recv-op
block
try
perform
block
poll
do
block
do
try
sendq
recvq
# mkosi

# mkosi

# systemd-nspawn -bi image.raw

# mkosi -t raw_btrfs --bootable -o foobar.raw
# systemd-nspawn -bi foobar.raw

qemu-kvm -m 512 -smp 2 -bios /usr/share/edk2/ovmf/OVMF_CODE.fd -drive format=raw,file=foobar.raw

# mkosi -d fedora -t directory -o quux
# systemd-nspawn -bD quux

# mkosi -d fedora -t raw_squashfs --checksum --xz --package=openssh-clients --package=emacs

# cat > mkosi.default <<EOF
[Distribution]
Distribution=fedora
Release=24

[Output]
Format=raw_btrfs
Bootable=yes

[Packages]
# The packages to appear in both the build and the final image
Packages=openssh-clients httpd
# The packages to appear in the build image, but absent from the final image
BuildPackages=make gcc libcurl-devel
EOF

# cat > mkosi.build <<EOF
#!/bin/sh
./autogen.sh
./configure --prefix=/usr
make -j `nproc`
make install
EOF
# chmod +x mkosi.build

# mkosi

# systemd-nspawn -bi image.raw

# mkdir mkosi.cache

# mkosi -i

# mkosi -if && systemd-nspawn -bi image.raw

# mkosi -iff && systemd-nspawn -bi image.raw

package foo

package bar

import (
  "foo"
  "moo"
)

func somefunc() {
  foo.Yadda()
  var a moo.Thing
  ...
}

type Thing struct {
  // Member fields.
  // Notice the lack of the var keyword.
  a int
  B int // See below about symbol visibility
}

var foo Thing
foo.B = 3

var bar Thing = Thing{3}

var goo *Thing = new(Thing)
goo.B = 5

type Thing struct {
  a int
  name string
  ...
}

func NewThing() *Thing {
  // 100 is a suitable default value for a in this type:
  f := Thing{100, nil}
  return &f
}

// Notice that different "constructors" must have different names,
// because go doesn't have function or method overloading.
func NewThingWithName(name string) *Thing {
  f := Thing{100, name}
  return &f
}

type Person struct {
   Name string
}

type Employee struct {
  Person
  Position string
}

var a Employee
a.Name = "bob"
a.Position = "builder"

var e = new(Employee)

// Compilation error.
var p *Person = e

// This works instead.
// So if we thought of this as a cast (we probably shouldn't),
// this would mean that we have to explicitly cast to the base class.
var p *Person = e.Person

// This works.
e.methodOnPerson()

// And this works.
// Name is a field in the contained Person struct.
e.Name = 2

// These work too, but the extra qualification is unnecessary.
e.Person.methodOnPerson()

func (t Thing) DoSomething() {
  ...
}

func (t *Thing) ChangeSomething() {
  t.a = 4
}

type Meters int
type Feet int

func (Meters) convertToFeet() (Feet) {
  ...
}

Meters m = 10
f := p.convertToFeet()

MyType a = getSomething();
MyType b = getSomethingElse();
if (a == b) {
  ...
}

type Thing int // This type will be available outside of the package.
var Thingleton Thing// This variable will be available outside of the package.

type thing int // Not available outside of the package.
var thing1 thing // Not available outside of the package.
var thing2 Thing // Not available outside of the package.

// Available outside of the package.
func DoThing() {
  ...
}

// Not available outside of the package.
func doThing() {
  ...
}

type Stuff struct {
  Thing1 Thing // Available outside of the package.
  thing2 Thing // "private" to the struct.
}

// Available outside of the struct.
func (s Stuff) Foo() {
  ...
}

// Not available outside of the struct.
func (s Stuff) bar() {
  ...
}

// Not available outside of the package.
type localstuff struct {
...
}

type Shape interface {
  // The interface's methods.
  // Note the lack of the func keyword.
  SetPosition(x int, y int)
  GetPosition() (x int, y int)
  DrawOnSurface(s Surface)
}

type Rectangle struct {
  ...
}

// Methods to satisfy the Shape interface.
func (r *Rectangle) SetPosition(x int, y int) {
  ...
}

func (r *Rectangle) GetPosition() (x int, y int) {
  ...
}
func (r *Rectangle) DrawOnSurface(s Surface) {
   ...
}

// Other methods:
func (r *Rectangle) setCornerType(c CornerType) {
   ...
}
func (r *Rectangle) cornerType() (CornerType) {
   ...
}

type Circle struct {
  ...
}

// Methods to satisfy the Shape interface.
func (c *Circle) SetPosition(x int, y int) {
  ...
}

func (c *Circle) GetPosition() (x int, y int) {
  ...
}

func (c *Circle) DrawOnSurface(s Surface) {
  ...
}

// Other methods:
...

var someCircle *Circle = new(Circle)
var s Shape = someCircle
s.DrawOnSurface(someSurface)

var a *Circle = new(Circle)
var b Shape = a // OK. The compiler can check that Circle has Shape's methods.

// Sometimes the Shape (our interface type) is also a Drawable
// (another interface type), sometimes not.
var a Shape = Something.GetShape()

// Notice that we want to cast to a Drawable, not a *Drawable,
// because Drawable is an interface.
var b = a.(Drawable) // Panic (crash) if this fails.

var b, ok = a.(Drawable) // No panic.
if ok {
  b.DrawOnSurface(someSurface)
}

// Get Shape() returns an interface value.
// Shape is our interface.
var a Shape = Something.GetShape()

// Notice that we want to cast to a *Thing, not a Thing,
// because Thing is a concrete type, not an interface.
var b = a.(*Thing) // Panic (crash) if this fails.

var b, ok = a.(*Thing) // No panic.
if ok {
  b.DoSomething()
}

var _ MyInterface = (*MyType)(nil)

type Positionable interface {
  SetPosition(x int, y int)
  GetPosition() (x int, y int)
}

type Drawable interface {
  drawOnSurface(s Surface) }
}

type Shape interface {
  Positionable
  Drawable
}

type Drawable interface {
 drawOnSurface(s Surface)
}

type Painter struct {
  ...
}

// Make Painter satisfy the Drawable interface.
func (p *Painter) drawOnSurface(s Surface) {
  ...
}

type Circle struct {
 // Make Circle satisfy the Drawable interface via Painter.
 Painter
 ...
}

func main() {
  ...
  var c *Circle = new(Circle)

  // This is OK.
  // Circle satisfies Drawable, via Painter
  c.drawOnSurface(someSurface)

  // This is also OK.
  // Circle can be used as an interface value of type Drawable, via Painter.
  var d Drawable = c
  d.drawOnSurface(someSurface)
}

call-with-current-continuation
call/cc
call/cc
call/cc
(define (run sched)
  (match sched
    (($ $sched inbox i/o)
     (define (dequeue-tasks)
       (append (dequeue-all! inbox)
               (poll-for-tasks i/o)))
     (let lp ()
       (for-each (lambda (task) (task))
                 (dequeue-tasks))
       (lp)))))

epollfd
poll-for-tasks
epoll_wait
epoll_wait
/home/wingo% ./prog

/home/wingo%
try {
  foo();
} catch (e) {
  bar();
}

amb
%
(use-modules (ice-9 control))

(% expr
   (lambda (k . args) #f))

tcsh
lambda
#f
%
call-with-prompt
(let ((tag (make-prompt-tag)))
  (call-with-prompt tag
    ;; Body:
    (lambda () expr)
    ;; Escape handler:
    (lambda (k . args) #f)))

%
call-with-prompt
(define-module (my-module)
  #:export (with-return))

(define-syntax-rule (with-return return body ...)
  (let ((t (make-prompt-tag)))
    (define (return . args)
      (apply abort-to-prompt t args))
    (call-with-prompt t
      (lambda () body ...)
      (lambda (k . rvals)
        (apply values rvals)))))

with-return
(use-modules (my-module))

(with-return return
  (+ 3 (return 42)))
;; => 42

return
with-return
return
call-with-prompt
(let ((tag (make-prompt-tag)))
  (call-with-prompt tag
    (lambda () ...)
    (lambda (k . args) ...)))

with-return
abort-to-prompt
call-with-prompt
(define (f)
  (define tag (make-prompt-tag))
  (call-with-prompt tag
   (lambda ()
     (+ 3
        (abort-to-prompt tag)))
   (lambda (k) k)))

(let ((k (f)))
  (k 1))
;; =& 4

abort-to-prompt
k
(+ 3 [])
(define tag (make-prompt-tag))

(define (call/susp thunk)
  (define (handler k on-suspend) (on-suspend k))
  (call-with-prompt tag thunk handler))

(define (suspend on-suspend)
  (abort-to-prompt tag on-suspend))

(define (schedule thunk)
  (match (current-scheduler)
    (($ $sched inbox i/o)
     (enqueue! inbox (lambda () (call/susp thunk))))))

suspend
suspend
on-suspend
call-with-prompt
(define (spawn-fiber thunk)
  (schedule thunk))

(define (yield)
  (suspend schedule))

on-suspend
schedule
epollfd
(define (wait-for-readable fd)
  (suspend
   (lambda (k)
     (match (current-scheduler)
       (($ $sched inbox i/o)
        (add-read-fd! i/o fd
                      (lambda () (schedule k))))))))

spawn-fiber
(define (spawn-fiber thunk)
  (schedule
   (lambda ()
     (catch #t thunk
       (lambda (key . args)
         (print-exception (current-error-port) #f key args))))))

(define (with-output-to-string thunk)
  (let ((p (open-output-string)))
    (parameterize ((current-output-port p))
      (thunk))
    (get-output-string p)))

parameterize
p
thunk
(current-input-port)
(current-input-port p)
parameterize
with-dynamic-state
(define (spawn-fiber thunk)
  (let ((state (current-dynamic-state)))
    (schedule
     (lambda ()
       (catch #t
         (lambda ()
           (with-dynamic-state state thunk))
         (lambda (key . args)
           (print-exception (current-error-port) #f key args))))))

with-dynamic-state
(parameterize ((current-output-port p))
  (spawn-fiber
   ;; New fiber should inherit current-output-port
   ;; binding as "p"
   (lambda () ...)))

(current-dynamic-state)
with-dynamic-state
catch
catch
fluid-ref*
dynamic-wind
dynamic-wind
with-throw-handler
catch
dynamic-wind
dynamic-wind
org.freedesktop.UDisks2.Manager:
CanFormat(fstype) -> (available, required_utility)
CanResize(fstype) -> (available, mode, required_utility)
CanCheck(fstype) -> (available, required_utility)
CanRepair(fstype) -> (available, required_utility)

org.freedesktop.UDisks2.Partition:
Resize(size, options)

org.freedesktop.UDisks2.Filesystem:
Resize(size, options)
Check(options) -> consistent
Repair(options) -> repaired
$ # repair first (the option dict {} is unused)
$ gdbus call --system --dest org.freedesktop.UDisks2 \
 --object-path /org/freedesktop/UDisks2/block_devices/loop0p1 \
 --method org.freedesktop.UDisks2.Filesystem.Repair {}
(true,)

$ # shrink filesystem to 50 MB
$ gdbus call --system --dest org.freedesktop.UDisks2 \
 --object-path /org/freedesktop/UDisks2/block_devices/loop0p1 \
 --method org.freedesktop.UDisks2.Filesystem.Resize 50000000 {}
()

$ # shrink partition to 50 MB
$ gdbus call --system --dest org.freedesktop.UDisks2 \
 --object-path /org/freedesktop/UDisks2/block_devices/loop0p1 \
 --method org.freedesktop.UDisks2.Partition.Resize 50000000 {}
()
a = b
c = d

for i := 0; i < 100; i++ {
  ...
}

if a == 2 {
  ...
}

for (int i = 0; i < 100; i++) {
  ...
}

if (a == 2) {
  ...
}

var a = 1 // An int.
var b = 1.0 // A float64.
var c = getThing()

a := 1 // An int.
b := 1.0 // A float64
d := getThing()

Foo foo = 2;
var foo Foo = 2
var a int = -2
var b uint = a
var c int = b

var d float64 = 1.345
var e int = c

type Meters int
type Feet int
var a Meters = 100
var b Feet = a

type Meters int
var a Meters = 100 // No problem.

var i int = 100
var b Meters = i // Will not compile.

enum class Continent {
  NORTH_AMERICA,
  SOUTH_AMERICA,
  EUROPE,
  AFRICA,
  ...
};

Continent c = Continent::EUROPE;
Continent d = 2; // Will not compile

type continent int

const (
  CONTINENT_NORTH_AMERICA continent = iota
  CONTINENT_SOUTH_AMERICA // Also a continent, with the next value via iota.
  CONTINENT_EUROPE // Also a continent, with the next value via iota.
  CONTINENT_AFRICA // Also a continent, with the next value via iota.
)

var c continent = CONTINENT_EUROPE
var d continent = 2 // But this works too.

switch str {
  case "foo":
  doFoo()
case "bar":
  doBar()
}

var a thing = getThing();
var p *thing = &a;
var b thing = *p; // Copy a by value, via the p pointer

var a *thing = new(thing)
var a thing = new(thing) // Compilation error

var a *Thing = new(Thing) // You wouldn't normally specify the type.
var b Thing = *a
a.foo();
b.foo();

func doThing(someSlice []int) {
  someSlice[2] = 3;
}

void doThing(Thing& someSlice) {
  someSlice[2] = 3;
}

const pi = 3.14

const pi float64 = 3.14

const pi = calculate_pi()

type Point struct {
  X int
  Y int
}

const point = Point{1, 2}

type Yards int
const length Yards = 100

for i := 0; i < 100; i++ {
  ...
}

for keepGoing {
  ...
}

for i, c := range things {
  ...
}

str1 := "foo"
str2 := str1 + "bar"

str := "foo"
l := utf8.RuneCountInString(str)

str := "foo"
for _, r := range str {
  fmt.Println("rune: %q", r)
}

a := []int{5, 4, 3, 2, 1} // A slice
a = append(a, 0)

a := [...]int{5, 4, 3, 2, 1} // An array.
b := [5]int{5, 4, 3, 2, 1} // Another array.

a = append(a, 123)

m := make(map[int]string)
m[3] = "three"
m[4] = "four"

func getThings() (int, Foo) {
  return 2, getFoo()
}

a, b := getThings()

std::tuple<int, Foo> get_things() {
  return make_tuple(2, get_foo());
}

auto [i, f] = get_things();

func getThing() *Thing {
  a := new(Thing)
  ...
  return a
}

b := getThing()
b.foo()

func getThing() *Thing {
  var a Thing
  ...
  return &a
}

b := getThing()
b.foo()

void Something::do_something() {
  do_something_harmless();

  {
    std::lock_guard<std::mutex> lock(our_mutex);
    change_some_shared_state();
  }

  do_something_else_harmless();
}

func something() {
  doSomethingHarmless()

  ourMutex.Lock()
  defer ourMutex.Unlock()
  changeSomeSharedState()

  // The mutex has not been released yet when this remaining code runs,
  // so you'd want to restrict the use of the resource (a mutex here) to
  // another small function, and just call it in this function.
  doSomethingElseHarmless()
}

static gboolean scan_buffer_incrementally (GtkSourceBuffer *buffer, guint64 clock)
{
	..
	/* get insert cursor GtkTextIter and bounds of current buffer */
	insert_mark = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (buffer));
	gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (buffer), &insert_iter, insert_mark);
	gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer), &start, &end);
	...

	while (TRUE)
	{
		if (g_get_monotonic_time() < clock)
			/* keep scanning the buffers */

		else /* time slab over */
			break;
	}

	/* adjust scan regions and iters to the next scan chunk */

}

static gboolean scan_buffer (GtkSourceBuffer *buffer)
{
	...

	clock = g_get_monotonic_time() + 5000;
	scan_buffer_incrementally (buffer, clock);
}

static void file_loaded(GObject *object, GAsyncResult *res, gpointer data)
{
	...
	g_timeout_add_full (G_PRIORITY_DEFAULT, 50, (GSourceFunc)scan_buffer, buffer, NULL);

}
shred --size=1M  /dev/sda* /dev/sdb*
installimage -n bitbox -r yes  -l 1 -p swap:swap:48G,/boot:ext3:1G,/mnt/disk:btrfs:128G,/:btrfs:all  -K /root/.ssh/robot_user_keys   -i /root/.oldroot/nfs/install/../images/Ubuntu-1604-xenial-64-minimal.tar.gz

## For some weird reason, Hetzner puts swap space in the RAID.
#mdadm --stop /dev/md0
#mdadm --remove /dev/md0
#mkswap /dev/sda1
#mkswap /dev/sdb1

mount /dev/md3 /mnt
btrfs subvolume snapshot -r /mnt/ /mnt/@root-initial-snapshot-ro

mkdir /tmp/disk
mount /dev/md2 /tmp/disk
btrfs send /mnt/@root-initial-snapshot-ro | btrfs receive -v /tmp/disk/ 
umount /mnt/

luksformat -t btrfs  /dev/md3 
cryptsetup luksOpen /dev/md3 cryptedmd3

mount /dev/mapper/cryptedmd3  /mnt/

btrfs send /tmp/disk/@root-initial-snapshot-ro | btrfs receive -v /mnt/
btrfs subvolume snapshot /mnt/@root-initial-snapshot-ro /mnt/@

btrfs subvolume create /mnt/@home
btrfs subvolume create /mnt/@var
btrfs subvolume create /mnt/@images

blkid -o export /dev/mapper/cryptedmd3  | grep UUID=
sed -i  's,.*md/3.*,,'   /mnt/@/etc/fstab
echo  /dev/mapper/cryptedmd3   /     btrfs defaults,subvol=@,noatime,compress=lzo  0  0  | tee -a /mnt/@/etc/fstab
echo  /dev/mapper/cryptedmd3   /home btrfs defaults,subvol=@home,compress=lzo,relatime,nodiratime  0  0  | tee -a /mnt/@/etc/fstab

umount /mnt/
mount /dev/mapper/cryptedmd3 -osubvol=@ /mnt/

mount /dev/md1 /mnt/boot

mv /mnt//run/lock /tmp/
chroot-prepare /mnt/; chroot /mnt

passwd

echo  "termcapinfo xterm* ti@:te@" | tee -a /etc/screenrc
sed "s/UMASK[[:space:]]\+022/UMASK   027/" -i /etc/login.defs  
#echo   install floppy /bin/false  | tee -a    /etc/modprobe.d/blacklist
#echo "blacklist floppy" | tee /etc/modprobe.d/blacklist-floppy.conf

# Hrm. for some reason, even with crypttab present, update-initramfs does not include cryptsetup in the initrd except when we force it:
# https://bugs.launchpad.net/ubuntu/+source/cryptsetup/+bug/1256730
# echo "export CRYPTSETUP=y" | tee /usr/share/initramfs-tools/conf-hooks.d/forcecryptsetup

echo   cryptedmd3 $(blkid -o export /dev/md3  | grep UUID=) none luks     | tee  -a  /etc/crypttab
# echo   swap   /dev/md0   /dev/urandom   swap,cipher=aes-cbc-essiv:sha256  | tee  -a  /etc/crypttab

apt-get update
apt-get install -y cryptsetup
apt-get install -y busybox dropbear

mkdir -p /etc/initramfs-tools/root/.ssh/
chmod ug=rwX,o=   /etc/initramfs-tools/root/.ssh/
dropbearkey -t rsa -f /etc/initramfs-tools/root/.ssh/id_rsa.dropbear

/usr/lib/dropbear/dropbearconvert dropbear openssh \
        /etc/initramfs-tools/root/.ssh/id_rsa.dropbear \
        /etc/initramfs-tools/root/.ssh/id_rsa

dropbearkey -y -f /etc/initramfs-tools/root/.ssh/id_rsa.dropbear | \
        grep "^ssh-rsa " > /etc/initramfs-tools/root/.ssh/id_rsa.pub

cat /etc/initramfs-tools/root/.ssh/id_rsa.pub >> /etc/initramfs-tools/root/.ssh/authorized_keys

cat /etc/initramfs-tools/root/.ssh/id_rsa

update-initramfs -u -k all
update-grub2

exit

umount -l /mnt
mount /dev/mapper/cryptedmd3 /mnt/
btrfs subvolume snapshot -r /mnt/@ /mnt/@root-after-install

umount -l /mnt

pwgen
btrfs add
UUID=
/run/lock
chroot-prepare
mkinitramfs
cryptsetup
/etc/crypttab
cryptsetup
busybox
dropbear
/usr/share/doc/cryptsetup/README.remote.gz
chroot

July 01, 2017

This resolution post begins where Python Tutorial – Part1 left off.

June 30, 2017

The initial design

The current design

Another possible improvement

June 29, 2017

User experience improvements

Let the user choose between Avahi and Wormhole

Inform users about slow or no connection

Every unnecessary UI element adds complexity

Magic Wormhole error handling

Automated unit tests

Bug fixing

From our local group, I must congratulate the labor of @toto who did clone gnome-music, @alexandros and @varian for polari. Here, their successful work so far!

Progress

Rust FFI - Foreign Function Interface

Onwards

bindgen

mozjs

grust-gen

gir

What about GJS?

Issues

Next

June 28, 2017

Introducing mkosi

What is mkosi?

Mode of Operation

How to use it

Random Interesting Features

Minimum Requirements

Future

FAQ

Should you care? Is this a tool for you?

What is cobot?

What has been achieved in this Phase?

What next?

Packages

Structs

Embedding Structs

Methods

No equality or comparison operator overloading

Symbol Visibility: Uppercase or lowercase first letter

Interfaces

Interfaces have methods

Types satisfy interfaces implicitly

Runtime dispatch

Comparing interfaces

Wishing for an implements keyword

Interface embedding

Embedding an interface in an interface

Embedding an interface-satisfying struct in a struct

June 27, 2017

June 26, 2017

No semicolons at the end of lines

No () parentheses with if and for

Type inference

Types after names

No implicit conversions

No implicit conversions because of underlying types

No enums

Switch/Case: No fallthrough by default

Switch/Case: Not just basic types

Pointers, but no ->, and no pointer arithmetic

References, sometimes

const

Only for loops

A native (Unicode) String type

Slices

Maps

Multiple return values

Garbage Collection

Things I don’t like in Go

No generics

Lack of standard containers

Indexing Tool

Indexer Plugin

June 25, 2017

June 24, 2017