Communication is paramount. You must be willing to spend whatever time is needed to bring your coworkers up to speed—to help others understand—where you are going. Sometimes you will spend most of a day talking with your coworkers, not programming.

— Rasmus has started a company and is hiring

Saturday

• The state of Go
• The secret life of a goroutine
• Effortless Bug Hunting with Differential Fuzzing
• Maintaining Go as a day job - a year later
• Using chroots in a single Linux Container as an alternative to docker-compose
• Soft Reboot: keep your containers running while your image-based Linux host gets updated
• A front-end journey back to Rails
• Besides Web: a Worker story.
• The world of Passkeys

Sunday

• Opening up communication silos with Matrix 2.0 and the EU Digital Markets Act
• Aerogramme, a multi-region IMAP server
• Apache James: Modular email server
• Post-Quantum Cryptography transition: where we are now
• So you think you know Git
• Version control post-Git
• Homebrew’s Evolution

MÖP-uppdatering Tnr 211848

Idag behöver vi prata om termobariska vapen. Normala sprängämnen, sådana som används i vanliga vapen, är så att säga "self-contained" - de innehåller i sig själv allt som behövs för att skapa en explosion. Det går utmärkt att avfyra en pistol i rymden, för krutet exploderar av sig själv. Termobariska vapen, däremot, använder syre från luften som en av beståndsdelarna för att skapa en explosion. De bygger på att finfördela någon form av bränsle i luften, och sedan detonera molnet med hjälp av en liten vanlig sprängladdning.

Det är rätt svårt att förklara verkan av en termobarisk explosion på ett intuitivt begripligt sätt, men om ni har sett filmer från någon av tsunamikatastroferna vet ni att en tsunami inte bara är en ovanligt kraftig våg; det är snarare som om hela havet höjer sig och flödar in över land. Man kan ha den bilden i huvudet.

En vanlig sprängladdning ger en skarp chockvåg; det är som om man slänger en sten i ett badkar och orsakar en cirkelformig våg på vattnet. Eftersom en termobarisk explosion inte kommer från en enda punkt, utan orsakas av ett helt moln som exploderar, kommer det en hel vägg av luft. Det är som om man snabbt skulle lyfta ena änden av badkaret så att en jättevåg slår iväg mot andra änden.

Och efter den stora tryckvågen från den termobariska explosionen kommer ett undertryck. (Man pratar ibland om termobariska vapen som "vakuum-bomber"). Det blir som en stor pumprörelse genom luften. Tänk er att ni ställer ner den där badkarsänden direkt när vågen farit iväg - då har ni en djup vågdal i er ände.

Den här pumpande rörelsen är väldigt effektiv för att förstöra byggnader och strukturer, och människokroppar. Särskilt lungorna blir sönderslitna av tryckvågen.

Explosionen ger också upphov till en våg av hetta (det hörs på namnet: "termo" - värme, "bar" - tryck) som bränner sönder allt i sin väg.

En stor termobarisk explosion är bara snäppet under ett taktiskt kärnvapen.

I videon nedan syns en TOS-1A. Det är ett ryskt vapensystem som skjuter iväg raketer med termobariska sprängladdningar, upp till 24 stycken i en enda salva. (Branden som uppstår är buskage som antänds av raketavgaserna.)

Just den här salvan skjuts mot Mariupol. Även om 80% av stadens infrastruktur är förstörd, finns det fortfarande tiotusentals civila kvar.

MÖP-uppdatering Tnr 182224

Fler och fler människor slängs ner i köttkvarnen i Ukraina, utan några nämnvärda resultat. Ryssland verkar oförmöget att släppa det som bevisligen inte funkar, utan fortsätter att kasta in unga pojkar för att slaktas.

I Mariupol sökte barnfamiljer skydd i en teater där man hade gjort stora markeringar i marken utanför: "дети" - "barn" (bild nedan). Den enda effekten det hade var att teatern blev ett mål för ryska flygvapnet. De enda säkra uppgifterna som finns just nu är "många har överlevt".

Jag möter hela tiden personer som har svårt att bearbeta det här. "Men, kan de verkligen bomba barn med flit?". Det är det här jag har försökt förklara i flera år. Det här är vad Ryssland gör. De har åter och åter igen visat att deras taktik är att skapa största möjliga lidande bland civilbefolkningen.

Jag lägger också till en film från Voznesensk, staden som jag nämnde häromdagen, som käkade upp en hel mekaniserad bataljonsstridsgrupp. Innehållsvarning: den börjar med liksäckar med döda ryska soldater. Men resten är sevärd.

Slutligen:

Det är förmodligen rätt få av er som missat att jag är engagerad i Hemvärnet. Vi är runt tjugotusen soldater, och vi har på kort tid fått tiotusen ansökningar. Vi är glada, men det kommer att ta lång tid att processa alla frivilliga personer, och om man inte har tidigare militär erfarenhet hamnar man lite längre bak i kön.

Jag vill peka på att vi bara är en av en lång rad frivilligorganisationer, och att det finns många, många ställen där man kan göra konkret, omedelbar nytta som frivillig. Ett bra ingångsställe är https://www.frivilligutbildning.se/.

Särskilt vill jag slå ett slag för två alternativ:

- Röda Korset. Det är alltid Röda Korset som står främst och som håller ut längst.

- Kommunernas FRG:er; frivilliga resursgrupper. Där kan man göra omedelbar nytta utan att lära sig skjuta ihjäl andra människor med automatkarbin. Googla "[kommunnamn] FRG". 

My blog (and server in general) is up again! I still host it on that puny server. The problem was however that my parents ISP earlier misbehaved with their DHCP-server, and their front line support not knowing anything.

ComHem has however since been bought by Tele2, and while I can't vouch for their customer service, they have at least configured their DHCP server correct, allowing both their home router and this server to get their public IP:s as expected.

Now we just hope that everything keeps working until we finally get IPv6.

Understanding Lisp-macros is hard, even harder is understanding how to effectively use them. Here I delve deeper into code walking through macros on my journey to really understand what makes Lisp macros, and by extension Lisp, unique.

One of the best information sources for advanced macros I have found is the book Let over Lambda, which I'm currently (slowly) making my way through. So far the major take-away from it is that macros are my tool for parsing lisp code [Section 5.4].

The code in this page is written in Guile, but most of it is applicable to any Lisp. Syntax-case appears to be non-standard.

Let Lazy & Symbol Macros

One really simple, but still powerful example of code walking through macros is let-lazy; a variant of let which creates lazy bindings, and only evaluates them on demand. [1].

Just to be clear, the expected behavior is the value of a binding is only evaluated if needed, and then only evaluated once. For example:

(let-lazy ((x (begin (display "Hello\n")
                     10)))
  (+ x x))
⊣ Hello
⇒ 20

(let-lazy ((x (begin (display "Hello\n") 10)))
  'x)
⇒ x

Also note that this isn't possible to achieve with functions in an eager language, since function parameters are evaluated before a function is called.

My first naïve solution used a simple macro, along with a manual tree-map.

;; apply proc to each node in tree, keeping structure.
;; optionally pass descend: #f to skip a branch.
(define* (tree-map proc tree #:key (descend (const #t)))
  (cond ((not (list? tree)) (proc tree))
          ((null? tree) '())
          ((list? (car tree))
          (cons (if (descend (car tree))
                  (tree-map proc (car tree) #:descend descend)
                  (car tree))
              (tree-map proc (cdr tree) #:descend descend)))
          (else (cons (proc (car tree))
                      (tree-map proc (cdr tree) #:descend descend)))))

(define (quote? form)
  (and (not (null? form))
       (eq? 'quote (car form))))

(define-macro (let-lazy bindings . body)
  (let ((keys (map car bindings)))
      `(let ,(map (lambda (b) `(,(car b) (delay ,@(cdr b))))
                  bindings)
      ,@(tree-map (lambda (t) (if (memv t keys) `(force ,t) t))
                  body #:descend (negate quote?)))))

It works decently, but quickly brakes down. For example, something as simple as a back-tick in the body breaks it.

(let-lazy ((x (begin  (display "Hello\n") 10))) `x)
⇒ (force x)

And as Let over Lambda mentions, there are many more special forms in a lisp than expected, and continues to issue the following Common Lisp example, where exactly one of the following blah should be expanded.

(let (blah (blah (blah blah)))
  blah)

;; Borrowed from Let over Lambda under fair use.

My updated solution instead uses my underlying Lisp interpreter to handle my variable substitution. In the bellow example I introduce my field mappings in a let-syntax towards the bottom, followed by me giving control back to scheme to figure the rest of the tree out.

(define-syntax let-lazy
  (syntax-rules ()

      ;; Match rule, and capture symbols
      [(_ ((field value) ...)
          body ...)

       ;; give symbols their delayed slots
       (let ((field (delay value)) ...)
          ;; introduce local syntax for replacing fields with
          ;; their forced counterparts
         (let-syntax ((field (identifier-syntax (force field))) ...)
           body ...))])).

The macro is also rewritten in scheme's hygienic macro system. Here it doesn't make a big difference, but identifier-syntax gets happier, and I sleep better knowing that symbols don't slip in our out of macro-expanded code.

Structures and Self Reference

Another more practical example (which actually was written earlier) was my attempt to create objects with an implicit reference to self, similar to C++ or Java. In this example my end goal was a way to generate static configuration files [2], so I could do away with updating slots.

After expansion my forms look more or less like

(define struct-1
  `(a (b ,(lambda (self) (get-field self '(c)))))).

Of note is that the field /a/b wants the value /c, which is allowed since it doesn't get evaluated before I actually instantiate the object, and that my system allows for rudimentary inheritance.

Before expansion the same information is written:

(struct struct-1 ()
    (a (b ,(? c))))

Which is rather similar. But keep in mind that the (? c) can be deep within arbitrary other code.

The base macro struct is just basic setup, but is here for completeness sake,

;; Comments added for this article.

(define-syntax struct
  (lambda (stx)
    (syntax-case stx ()
      [(_ name (parent ...) (key value ...) ...)

       ;; allow the symbol `?' to be used within the
       ;; input. Required due to hygienic macros
       (with-syntax ((? (datum->syntax stx '?)))
         #'(define name
             ;; Call to inner
             (let ((new-data (inner ? (acc-name ,(symbol->string 'name))
                                    (key value ...) ...)))

               ;; Inheritance (mostly unimportant)
               (lambda (mergable)
                 (alist-merge mergable
                              (fold $ new-data
                                    (list parent ...)))))))])))

Inner is however where all the fun stuff happens! To get it out of the way: all rules takes ? due to above mentioned hygienic macros, the leaves of the tree are wrapped in functions to delay evaluation, and the first case below matches on unquote (,) in a stroke of ingenuity madness when I realized that I could hijack scheme's syntax for my own bidding.

(define-syntax inner
  (syntax-rules (unquote)
    ;; case 1
    [(_ ? (unquote value))
     (lambda (self)
       ;; actually give a value to `?'
       (let-syntax ((? (with-ellipsis
                        .. (syntax-rules ()
                             [(? path ..) (get-field self `(path ..))]))))
         ;; give scheme the job to find all intances of (? ...)
         value))]

    ;; case 2
    [(_ ? (key sub ...) ...)
     (sort* `((key ,(inner ? sub ...)) ...)
            symbol<=? #:get car) ]

    ;; case 3
    [(_ _ v v* ...)
     (lambda _ (values `v `v* ...))]))

Relevant to code walking and macros is case one. The self is captured, the ? is finally given a value through let-syntax, which uses our captured self in a simple call to get-field. The core is still the same as above; introduce a binding with let-syntax and let our scheme do the job of finding all appropriate instances of our symbol. Here we just have more fancy stuff around it.

The scripts in their entirety can be found on GitHub, even though it feels a bit to intimate to share them this way. Struct there is called account, due to the code's original use case.

References

Let over Lambda

• Section 5.4, Code-Walking with Macrolet https://letoverlambda.com/index.cl/guest/chap5.html#sec_4
• Section 7.7, Pandoric Macros (define-handy-method) https://letoverlambda.com/index.cl/guest/chap6.html#sec_7

Full Scripts

• https://github.com/HugoNikanor/dotfiles/blob/5c74da19aa12171495cb8b857cb2cd6135ff4ea1/scripts/conf-base.scm

Scott Galloway on why you have an Amex card, from Pivot.

En sak som irriterar mig med programvaruprojekt är när saker som fungerat i en viss version helt plötsligt slutar fungera. I bästa fall finns det tydligt dokumenterat hur man uppdaterar sina filer och inställningsfiler för att det ska fungera med en senare version. I vissa fall finns det åtminstone antytt vad som behöver ändras och i resterande fall är man utlämnad till att på egen hand försöka sig fram och googla fram svar på Stack Overflow, Github-issues eller forumtrådar med andra som haft liknande problem.

Vill man undvika framtida problem och välja projekt som tar hänsyn till uppgradering behöver man antagligen en tidsmaskin. Någon tydlig indikator på om det kommer vara smärtfritt att uppgradera i framtiden finns inte riktigt.

Samtidigt så handlar det om att kunna lämna tidigare designval som visat sig dåliga bakom sig. I programspråk som Perl och Python har övergången mellan versioner varit problematiskt. Övergången från Perl 5 till Perl 6 har tagit riktigt lång tid på sig. Steget visade sig vara jättestort och mycket behövde göras för att implementera i språket. I fallet med övergången till Python 3 från 2 kan det från utsidan kännas som en balkanisering. Dispyter om det är rätt att hålla sig kvar vid version 2 när det finns klara fördelar med Python 3 ses i tweets och blogginlägg då och då.

När Ruby-skaparen Matz talat om kommande Ruby 3 har just kämpandet för Perl och Python nämnts som avskräckande exempel och motivering till att göra övergången mer gradvis.

Gradvisa övergångar behöver nödvändigtvis inte vara självklara heller. I fallet med den här bloggen och Jekyll så är det möjligt att övergången skett gradvis men eftersom jag inte följt utvecklingen sedan november 2014 och tar steget på en gång. Har man sedan varit inne och gjort egna modifieringar eller använt obskyra plugins är det något man får sota för och man är helt ensam.

Alla har vi hört buzz-orden datadriven marknadsföring, marketing automation och liknande. Alla inom marknadsföring pratar om detta. Och digitaliseringen, såklart – det är ju nyckel till framgång – men det är ett annat inlägg.

Även om alla pratar om det och alla företag säger att det jobbar med det så dyker man förvånansvärt ofta på exempel där stora och välkända företag gör det ganska enkelt för sig och använder inte den data (alltså din personliga information) de har. Man får tänka på att konkurrensen bland webbshoparna idag är stenhård och det kan vara detaljer som gör att en kund väljer en annan webbshop än just din.

Jag tänkte därför plocka fram två färska exempel på företag som skulle kunna föra detta bättre än vad de gör idag. Dessa exempel handlar om något så enkelt som de bekräftelsemail man får när man handlat hos dem. Ett bekräftelsemail har stor potential att dels göra köparen trygg att allt gått som det ska och man kommer få varorna, men det kan även skapa merförsäljning.

Först ut: Footway

En riktigt nice webbutik som funkar väldigt bra och där jag nyss beställde från. Företaget vet precis vad jag köpt – både nu och tidigare – och kan därför passa på att ge mig erbjudande och rabatter.

Footway, i det här fallet, utnyttjar inte helt sin data här. Jag valde att betala med Klarna, vilket de naturligtvis vet om. Istället för att skriva som de gör ska de naturligtvis skriva något i stil med: ”Du valde att betala med Klarna. Håll utkik efter ett mail från dem med fakturan.” Väldigt enkelt och ger mer trygghet i hur man betalar – eller om man t.om. glömt hur man betalade så får man en påminnelse.

Här skulle man också kunna ge förslag på andra skor som passar till dem jag köpt och kanske till och med ge rabatt om man köper direkt. Här finns det stora utrymmen för att testa sig fram och med relativt enkla medel skapa merförsäljning i ett läge då kunden ofta är mottagbar för det.

Zalando

Ännu värre är Zalando. De skriver all information i brödtext, vilket gör det lätt att missa och jobbigt att läsa. Känslan av trygghet, som jag tidigare nämnde, försvinner mycket i att de måste förklara olika scenarion i texten.

I min beställning skrev jag in mitt mobilnummer, adress och mail.

Här borde de skriva ut mitt mobilnummer, vilket skulle göra att de slipper flera meningar i mailet som det ser ut nu. ”Vi kommer skicka ett SMS till dig på 070-123 45 67 när paketet finns att hämta hos dit närmaste postombud.” Hur mycket trevligare är inte det?

Jag betalade ordern med mitt kort, men istället för att skriva att allt är betalt och klart så väljer de alltså att skriva ut det väldigt kryptiskt. ”Du har valt följande betalningssätt: Bank- eller kreditkort.” Kom igen!

Zalando försöker ändå med att ge mig 10% rabatt om jag skriver upp mig för deras nyhetsbrev. Att jag redan prenumererar på det verkar inte spela någon roll. Detta skapar frågor istället för att fokusera på det bra erbjudandet.

Genom att använda den data (information) jag skrev in vid köpet plus mina tidigare köp så skulle de kunna ta bort mycket av den krångliga texten och istället lyfta fram produkter som jag troligtvis skulle kunna vara intresserad av.

De kan fortfarande ge mig rabatt men istället för att få den via att jag registrerar mig för ett nyhetsbrev – som jag alltså redan är prenumerant på – så skulle det t.ex. kunna vara att jag får 10% om jag tipsar en kompis om Zalando.

Finns det några bra exempel då?

Visst finns det bra exempel! Hotels.com är en favorit till mig. De arbetar inte med merförsäljning i bekräftelsemailet utan de arbetar bara med att göra mig som kund trygg i mitt köp, vilket är helt rätt i deras fall.

Först och främst så är det först man ser att allt är betalt och bekräftat. Inte gömt i en brödtext utan stort och tydligt så jag släpper den första oron. De ger mig sen bild på hotellet, adress med länk till karta, telefonnummer till hotellet och precis den information jag som kund är ute efter. Den snyggaste detaljen måste ändå vara att de först skriver informationen på ditt förvalda språk men sen lägger de även till språket i det landet du bokat i. Vilken skön detalj är inte det!?

Det finns fortfarande stor potential och möjligheter vad gäller att använda kundernas data i kommunikationen. I dessa fallen var det enbart bekräftelsemail men man ser liknande vid nyhetsbrev och andra marknadsföringskampanjer.

Slutsatsen blir då: Använd ALL data du har för att förbättra kundupplevelsen, även om det skapar lite merjobb för dig. Det andra är att tänka på de små detaljerna. Vad behöver kunden veta i just detta skede och hur kan vi överträffa förväntningarna?

Något man ofta ser på inredningssiter är posters med rena motiv i form av svartvita kartor. Dessa är snygga och ger ett häftigt uttryck på väggarna. Tanken om att göra något liknande, fast mer lokalt, slog mig för ett tag sedan. Därför lägger jag nu ut två varianter av dessa posters föreställande Vansbros gatunät och Vansbro Landmarks, dvs. några utvalda byggnader som har betydelse i gatubilden. Liknande Landmarks-posters finns att köpa över Stockholm, London och New York, för att nämna några städer. Och nu finns även Vansbro i detta angenäma sällskap.

Vansbro Landmarks-postern är konturerna av de ånglok som står efter Järnvägsgatan, Lokstallet sett från ena kortsidan, järnvägsbron som går över Vanån och sist, men inte minst, är såklart järnvägsstationen med. Ladda ner dem och be ditt lokala tryckeri att skriva ut dem.

Ladda ner

Ladda ner poster av karta över Vansbro. Postern är gjord i A3-format (297mm × 420mm) men går att skriva ut i andra storlekar med.

Ladda ner postern Vansbro Landmarks. Postern är gjort 500mm × 700mm men går att skriva ut i andra storlekar.

Såhär snygga blir de inramade.

Med nyåret kommer nyårslöftena. Hur blygsamt löfte man än väljer finns risken för att oförutsedda problem dyker upp redan i början. Mina två löften för året handlar om att göra saker varje dag.

Varje dag ska jag studera kinesiska och varje dag ska jag skriva något på denna blogg. Det behöver nödvändigtvis inte handla om att lära mig mycket kinesiska varje dag eller att skriva långa essäer varje dag utan istället att faktiskt göra åtminstone något varje dag.

Förstås kommer tekniken in och ställer till besvär. Appen (ChineseSkill) som jag valt att börja studierna med lyckades inte ladda ner bilder och ljud för övningarna ikväll. Bloggen som jag i november 2014 konverterade till Jekyll visade sig vara svår att uppdatera eftersom jag behövde uppdatera programbibliotek och kod för att klara av ändringar som inträffat i Jekyll, Ruby och Solr sedan 2014.

Så jag får väl ta att första publiceringen kommer efter midnatt och hitta något annat sätt att plugga kinesiska (åtminstone för den här dagen).

• Mats Strandberg & Sara Bergmark Elfgren: Nyckeln
• Jo Walton: Among Others
• Neil Gaiman: The Ocean at the End of the Lane
• Cory Doctorow: Pirate Cinema
• Simon Stålenhag: Ur varselklotet
• George R. R. Martin: A Dance with Dragons

I just released PuTTY-url based on PuTTY 0.63. PuTTY-url is a patch that adds support for clickable URLs to PuTTY.

You can download it from http://ryara.net/putty-url/.

Make sure to update, since PuTTY 0.63 includes fixes for four security issues. See the PuTTY web site for more information.

This is useful if, for example, the web interface keeps resetting the connections.

Upgrading the firmware requires first updating the boot code, and the regular console in the earlier firware doesn’t have support for flashing the boot code. However, there is a hidden IOS-like cli available, that makes it possible to upgrade the boot code over tftp. An additional benefit is that it is much faster than using xmodem.

The steps

1. Setup a tftp server on your machine, serving the files srw2024_16_boot-101.rfb and ls20xx-12230.ros (download from Cisco)
2. Connect your computer to the switch using ethernet and serial cables.
3. Boot the switch.
4. Log into the console.
5. Press C-z.
6. On the new promt, type lcli and press enter.
7. To upgrade the boot code, type copy tftp:///srw2024_16_boot-101.rfb boot
8. Then upgrade the firmware: copy tftp:///ls20xx-12230.ros image
9. Lastly, restart the switch: reload

That’s it.

As an aside, please note that the web interface only works in Internet Explorer, so if it seems like it doesn’t work, it’s probably because your’re using another browser.

Det har varit lite dåligt med postningar på bloggen, men nu är det i alla fall dags att önska ett Gott Nytt År!

Ett nytt år som är det näst sista på väldigt länge som har en dag där tvåsiffrigt årsnummer, månad och dag i månad alla har samma värde. Efter den 11 november 2011 är det bara 12 december 2012 kvar innan man får vänta ända till den 1:a januari 2101 innan det går igen, och det är fasligt länge.

Hoppas att 2011 eller 0x7DB blir ett minst lika intressant år som 2010!

Vissa kombinationer råkar man bara kombinera, och sen är man fast. Bacon och Broccoli är en sådan kombination. Dessutom låter det trevligt.

master_repository = gentoo
format = ebuild
location = /var/paludis/repositories/cross-avr
names_cache = /var/cache/paludis/names
write_cache = /var/cache/paludis/metadata

mkdir /var/paludis/repositories/cross-avr/{cross-avr,profiles} -p
cd /var/paludis/repositories/cross-avr/cross-avr
ln -s /usr/portage/dev-embedded/avr-libc
ln -s /usr/portage/sys-devel/binutils
ln -s /usr/portage/sys-devel/gcc
ln -s /usr/portage/sys-devel/gdb

cd ../profiles
echo cross-avr > repo_name
echo cross-avr > categories

#cross-build avr
if [[ "${CATEGORY}" == "cross-avr" ]]
then
    if [[ "${PN}" != "gcc" && "${PN}" != "binutils" ]]
    then
        CBUILD=${CHOST}
        CHOST=avr
        CFLAGS="-Os"
    fi
fi

paludis --regenerate-installable-cache cross-avr

paludis cross-avr/binutils cross-avr/gcc cross-avr/avr-libc cross-avr/gdb -ip

export PATH="/home/thomas/bin:${PATH}:/home/thomas/installs/bin"