Da ich sie selber nicht so soft benötige und dann immer vergesse wie sie heißen hier als Notiz an mich selbst:

• rich.inspect() ist super hilfreich um zu einem Objekt das man im Debugger vor Sich hat schnell eine Übersicht zu generieren was es kann und welche Daten es hat.
• objexplore.explore() baut auf rich auf und bietet einen interaktiven explorer mit im wesentlichen den gleichen Informationen.

Beide Tools sind super hilfreich, wenn man in einer (fremden) Code-Basis schnell einen überblick kriegen will wie Objekte interagieren und zusammenarbeiten.

Bei meiner Arbeit ist mir aufgefallen, dass viele Entwickler bei uns die Shell viel effektiver nutzen könnten, um ihre Arbeit besser und schneller zu machen. Da ich die Shell sehr viel nutze, habe ich dazu ein paar Ideen. 😇 Auf der anderen Seite gibt es immer wieder ein Nugget, das ich selbst nicht kenne – und das möchte ich natürlich auch lernen.  

In diesem Sinne: Ich freue mich über Tips, lasst uns gerne daraus einen Austausch machen, wie man seine Shell effektiv einsetzt.

Damit verständlich wird wie ich meine Shell verwende ist es wichtig zu verstehen dass es verschiedene Arten gibt einen Mac effektiv zu nutzen. Ich kategorisiere das für mich grob so:

• Fensterbasiert: Viele Fenster, oft klein, die sich gegenseitig teilweise verdecken. Spezialisierte Apps anstatt Monolithen. Terminal, Editor, Git GUI, Datenbank-GUI und ein Dokumentationsbrowser, anstatt einer IDE die alles inkludiert.
• Screen/Tmux Style: Auch viele Fenster, aber ohne das diese sich überlappen. Viel Full-Screen und oft ein Window Manger oder Terminal das sicherstellt das Fenster garantiert nebeneinander sind. IDEs arbeiten in der Regel so.
• Quake Shell-Style: Im wesentlichen irgend ein anderer Stil, aber mit einem globalen Shortcut, der jederzeit eine Shell in den Vordergrund bringt oder wieder verschwinden lässt - egal wo man gerade ist.
• Mehrere Desktops: Separation von Apps über mehrere Desktops oder Workspaces.

Ich bin ganz klar tief in dem Fensterbasierten Workflow verortet. Ich kenne natürlich auch die anderen Workflows, aber sie funktionieren für mich persönlich einfach nicht so gut. Ich finde überlappende Fenster wirklich großartig, weil ich damit auf einem sehr viel kleineren Bildschirm (14-Zoll-Notebook) genauso produktiv sein kann, wie auf einem sehr viel größeren Bildschirm. 

Ich hoffe sehr, dass die Apple-Vision bald so gut funktioniert und so leicht wird, wie ich es mir wünsche. Dann kann ich es mir meine Fenster fei um mich herum anordnen. Aber bis dahin bleibe ich bei überlappenden Fenstern.

Mir hat dieser Artikel über das Denken zweiter Ordnung sehr gut gefallen.

Er erklärt am Beispiel von 'Chestertons-Fence', warum es wichtig ist, vor Änderungen an Systemen das Denken zweiter Ordnung einzusetzen. Er nutzt dazu die Methapher eines Zauns über eine Straße. Diesen sollte man nicht einfach wegräumen, nur weil er nervt. Warum? Weil die Menschen die ihn gebaut haben hatten damit Aufwand, den Sie nicht einfach nur so zum Spaß investiert haben. Deren Gründe muss man verstehen um zu sehen ob der Zaun tatsächich weg kann, oder nach wie vor nötig ist.

Angenommen hinter dem Zaun befindet sich ein Straßenabschnitt, der mit Minen verseucht ist. Leider ist dies in der Ukraine ja ein häufiges Problem. Der Zaun sollte erst entfernt werden, wenn die Minen geräumt sind, um Todesfälle und Verletzungen zu vermeiden. Die Toten und Verletzten sind hier der Effekt zweiter Ordnung.

Denken zweiter Ordnung heißt also nicht nur zu hinterfragen, warum etwas so ist, wie es ist, sondern auch zu verstehen, warum die Menschen, die es geschaffen haben (in unserem Fall meistens Code), es auf diese Weise gebaut haben. Bevor ich Änderungen vornehme, sollte ich mir Zeit nehmen, um die Gründe für die ursprüngliche Gestaltung zu verstehen, da unbedachte Änderungen unerwünschte Effekte haben werden.

So zu denken finde ich nicht leicht. Oft misslingt es mir. Aber es ist für mich ein Ziel.

Was heißt das für uns Entwickler?

Besonders bei der Frage: Wieso sind unsere Systeme so wie sie sind? Ist das für mich super relevant. Aber auch immer wenn ich Programmiere. Wenn ich einen Zaun aufstelle, also z.B. etwas komplizierter mache als es sein könnte, dann schreibe ich einen Kommentar wieso ich mich gegen die einfachere Lösung entschieden habe, damit die nach mir kommenden verstehen ob meine - für Sie - überkomplizierte Lösung noch nötig ist. Wenn ich eine weiter reichende Entscheidung fälle, dann Dokumentiere ich diese gerne mit eineme Architektural Decision Record (ADR) der enthällt aus welchen Gründen wir uns so entschieden haben. Wenn ich eine Story schreibe, dann muss da nicht nur das Feature drauf, sondern eben auch der Grund dafür, damit ich oder andere später nachvollzieen können, wieso dieses Feature existiert, oder eben wieso es nicht mehr nötig ist. Idealerweise würde ich auch gerne vom Code über die Commits zur Story zurück kommen - aber das gelingt mir bisher regelmäßig nicht.

Fazit

Viele der Praktiken, die wir in der Softwareentwicklung als Standards ansehen, dienen eigentlich dazu, das Denken zweiter Ordnung zu erleichtern – ein wichtiger Zusammenhang, der oft unerwähnt bleibt, mir aber zunehmend klarer wird.

Ganz besonders wichtig ist mir aber der Respekt, im Zweifel sollte ich erst einmal annehmen das der andere sich etwas dabei gedacht hat. Bevor ich das nicht verstehe sollte ich nicht die Axt ansetzen.

Zu meinen Ikea Trådfri Leuchten habe ich mir jetzt einen Phillips Hue LED-Streifen dazu geholt. Letztlich aus drei Gründen:

• Weil die viel Heller sind als fast alle Konkurrenzprodukte
• Weil sie auch ZigBee verwendet und damit nahtlos in meine Ikea Trådfri infrastruktur passt (theoretisch…)
• Weil ich mir die Ikea Bridge sehr bewusst ausgesucht habe, weil sie eben ohne einen Cloud zwang daher kommt.
• Weil ich sie in einem Sonderangebot 3 Meter für 50 € bekommen habe.

Well, also der Klebestreifen auf der LED-Schlange verdient diesen Namen schon mal nicht. Nicht nur das man den in 10 cm Inkrementen abpulen musste, er klebt zwar prima an der Tapete - aber nicht am LED-Streifen. WTF?

Davon abgesehen ist er super hell und lässt sich über Tradfri gut anbinden und steuern. ABER: Tradfri pusht ihn NICHT nach HomeKit wie es das mit den anderne Ikea eigenen Produkten macht. 😣💩😣💩😣🤬

Software Updates spielt die Tradfri Basis auch nicht ein - aber ok, das kriege ich via Bluetooth hin, was der LED-Streifen auch noch kann.

Jetzt extra noch eine Hue Bridge zu kaufen, nur damit ich dieses eine Gerät auch in HomeKit schalten kann, sehe ich jedenfalls mal gar nicht ein. Also hab ich mein trusty schweizer Messer Python ausgepackt und mit etwas Code nachgeholfen das fehlenden Device von Trådfri nach HomeKit zu pushen. Et Voila. :-)

Fazit: Die Schaltzeiten leiden etwas, Kann durchaus auch mal eine Sekunde dauern, anstatt der fast instantanen schaltzeit der Lampen die direkt über die Tradfri Bridge gehen. Aber wurscht, keine extra Bridge, etwas Spaß mit Python und die Erfahrung das es leicht geht da beliebigen eigenen Code einzubinden, der z.B. schöne Hintergrund-Farbwechsel ambient Lights produziert.

Beim lesen dieses Interview mit Elon Musk (hier auch als Video) hatte ich wirklich Spaß.

Diese Dinge sind nichts neues - aber mir ist klar geworden dass ich in der Vergangenheit viel zu Wenig wert darauf gelegt habe Requirements als Dumm zu identifizieren und Los zu werden, sowie Prozesse zu löschen. Autsch. Mea Culpa - ich gelobe Besserung.

Hier vor allem für mich selbst archiviert:

Musk’s Engineering Philosophy:

Musk overviewed his five step engineering process, which must be completed in order:

1. Make the requirements less dumb. The requirements are definitely dumb; it does not matter who gave them to you. He notes that it’s particularly dangerous if someone who is smart gives them the requirements, as one may not question the requirements enough. “Everyone’s wrong. No matter who you are, everyone is wrong some of the time.” He further notes that “all designs are wrong, it’s just a matter of how wrong.”
2. Try very hard to delete the part or process. If parts are not being added back into the design at least 10% of the time, not enough parts are being deleted. Musk noted that the bias tends to be very strongly toward “let’s add this part or process step in case we need it.” Additionally, each required part and process must come from a name, not a department, as a department cannot be asked why a requirement exists, but a person can.
3. Simplify and optimize the design. This is step three as the most common error of a smart engineer is to optimize something that should not exist.
4. Accelerate cycle time. Musk states “you’re moving too slowly, go faster! But don’t go faster until you’ve worked on the other three things first.”
5. Automate. An important part of this is to remove in-process testing after the problems have been diagnosed; if a product is reaching the end of a production line with a high acceptance rate, there is no need for in-process testing. Additionally, Musk restated that he believes everyone should be a chief engineer. Engineers need to understand the system at a high level to understand when they are making a bad optimization. As an example, Musk noted that an order of magnitude more time has been spent reducing engine mass than reducing residual propellant, despite both being equally as important.

Inspiriert von diesem Video von 3Blue1Brown, hat sich mein Verständnis wie man über Covid-Tests nachdenkt, grundsätzlich gewandelt.

Zwar war mir schon sehr lange Bewusst, dass Test-Ergebnisse kontra-intuitiv sein können, weil sie eben auch Gesunde als krank erkennen können.

Das ist einfach nachzuvollziehen, wenn man einen Covid-Schnelltest anschaut. Die Güte dieser Tests wird fast immer mit zwei Zahlen angegeben: Sensitivität (wie viele der tatsächlich Kranken werden erkannt) und Spezifizität (wie viele der Gesunden werden auch als Gesund erkannt). Nehmen wir an unser Test hat jetzt 90% Sensitivität und 90% Spezifität (fiktive Zahlen für leichteres Rechnen - echte Zahlen kommen später).

Wende ich diesen Test jetzt auf 100 menschen in einem Land an, das Zero-Covid hat. Dann sollten trotzdem 10 Personen als Krank gemeldet werden. Was heißt das jetzt? Logischerweise nix, denn es sind ja alle Gesund.

Gehe ich stattdessen ins Krankenhaus auf die Covid-Station und mache den Test dort mit 100 Personen, dann sollten trotzdem 10 Personen als Gesund gemeldet werden. Was heißt das jetzt? Logischerweise auch nix, die Leute sind ja schon wegen Covid in Behandlung und nicht durch den Test plötzlich gesundet.

Und das ist die wichtige Denk-Änderung die 3Blue1Brown in seinem Video motiviert - man muss beim nachdenken über Testergebnisse einfach immer auch darüber nachdenken wie wahrscheinlich es ist das man tatsächlich Krank ist. (Bayes läßt grüßen)

Und jetzt kommt der Dreh - alles wird viel einfacher, wenn man von vorne herein nicht denkt dass der Test mir sagt ob ich gesund oder Krank bin, sondern:

Jeder Test hat ein Vorhersagekraft, und dieser Faktor verändert meine Wahrscheinlichkeit Krank zu sein.

Es wäre also viel Einfacher, wenn man bei Tests nicht Sensitivität und Spezifizität angibt, sondern daraus die Vorhersagekraft des Tests berechnet. Damit kann man dann nämlich plötzlich viel einfacher Denken und verstehen. Und insbesondere ist es viel einfacher eine 'Vorhersagekraft' nicht mit 'Wahrscheinlichkeit das ich Krank bin' zu verwechseln, was einfach jeder tut der sich mit dem Thema nicht intensiv auseinander setzt.

Und das beste: Wenn man nicht in Prozent, sondern in Verhältnissen rechnet, dann ist das sogar präzise!

Wie kommt man jetzt auf diese Vorhersagekraft (auch Bayes Faktor genannt)

Jeder Test ist durch zwei Zahlen (Sensitivität[welcher Anteil der Kranken wird erkannt], Spezifität[welcher Anteil der Gesunden wird als Gesund erkannt]) bzw. durch die Komplemente davon (Falsch-Negativ-Rate, Falsch-Positiv-Rate) bestimmt.

Interessiert man sich jetzt für die Frage was ein Positiver-Test aussagt, kann man aus dem Quotient von Sensitivität geteilt durch Falsch-Positiv-Rate die Vorhersagekraft eines Positiven Tests und aus dem Quotient von Falsch-Negativ-Rate geteilt durch Spezifität die Vorhersagekraft eines Negativen Tests erhalten.

Ein Beispiel: Angenommen ein Test hat Sensitivität 90% und Spezifität 95% (also Falsch-Negativ-Rate 10%, Falsch-Positiv-Rate 5%). Dann ist die Vorhersagekraft eines Positiven Tests 90%/5%=18. Das heißt, wenn ich einen Positiven Test habe, dann weiß ich, dass sich die Wahrscheinlichkeit das ich Krank bin 18 mal vergrößert hat zu dem wie sie vorher war. Und umgekehrt: Ein Negativer Test 10%/95%≈  1/10. In Worten: Ein Negativer Test verkleinert meine Chance krank zu sein um etwa eine Größenordnung.

🤯

Rechnet man in Prozent ist das leider nur eine Abschätzung, aber wenn man das ganze in Chancen) rechnet wird aus der Abschätzung eine präzise Formel!

🤯 🤯

Schauen wir also mal auf ein paar reale Zahlen an.

In Berlin (stand 13. Mai 21, sind nach Pavels Covid Tabelle) derzeit einer von 394 Personen Ansteckend.

Für einen Covid-Test den ich gerade da habe findet sich hier eine Sensitivität ~93,5% und Spezifität ~98%.

Die Vorhersagekraft eines Positiven Tests ist 93,5%/2% ~47. Demnach wächst meine Chance heute ansteckend zu sein von 1/394 um das fast fünfzigfache auf etwas mehr als 1/4.

Die Vorhersagekraft eines negativen Tests ist 6,5%/98%~0,06. Demnach wächst meine Chance Gesund zu sein um fast zwei Größenordnungen von 1/394 auf etwa 6,5/38.612.

Oh wie schön wäre es, wenn das auch überall so kommuniziert würde…

Langsam nähere ich mich meinen Soft-RF-Geräten an. Ich kann jetzt auch über Bluetooth Low Energy (BLE) mit dem Gerät reden. Das Python Framework Bleak war dabei unglaublich hilfreich, da ich fast den ganzen BLE-Code sehr plattform-neutral Scheiben kann. I.e. der Code ist zwar nur auf MacOS getestet, wird aber sehr wahrscheinlich auch unter Linux funktionieren. Der Code zu diesem Post liegt auf github.

Wie läuft das jetzt? Zuerst braucht man einen BLE-Scanner, um die Adresse des Geräts zu finden. Bei mir sieht das so aus:

% ./ble_scanner.py
........................................
[...]
0975FAB7-6F50-4B60-A0D8-9F11C817FB6D: SoftRF-f0c010-LE
[...]

Mit dieser Adresse kann man dann reden um sich anzuschauen welche BLE-Services sie anbietet:

% ./ble_explore_device.py 0975FAB7-6F50-4B60-A0D8-9F11C817FB6D
Connected: True
[Service] 0000ffe0-0000-1000-8000-00805f9b34fb (Handle: 40): Vendor specific
    [Characteristic] 0000ffe1-0000-1000-8000-00805f9b34fb (Handle: 41): Vendor specific (read,write-without-response,notify), Value: b',,,,,,,,,99.99,99.99'
        [Descriptor] 00002901-0000-1000-8000-00805f9b34fb (Handle: 43): Characteristic User Description) | Value: b'HMSoft'
        [Descriptor] 00002902-0000-1000-8000-00805f9b34fb (Handle: 44): Client Characteristic Configuration) | Value: b'\x00\x00'

Was heißt das? Das gerät bietet den Service 0000ffe0-* an und darauf eine Characteristik 0000ffe1-* die wiederum zwei Deskriptoren enthält. 00002901-*und 00002902-*. Nicht das ich BLE vollständig verstehe, aber zumindest weiß ich das ein Service der Grundsätzliche Behälter für alle BLE Interaktionen ist und eine Charactreristik einen lese und schreibbaren Wert darstellt. Deskriptoren können darin verschachtelt sein und sind entweder zusätzliche lese und schreibbare Werte oder haben einen technischen Sinn. In diesem Beispiel ist der zweite Descriptor notwendig um auf der Charakteristik nicht nur lesen und schreiben, sondern auch Notify zu implementieren -> und das braucht es für die Serielle Schnittstelle.

Entscheidend ist hier die Service-Charakteristik 0000ffe1-0000-1000-8000-00805f9b34fb Hier spielt die ganze Musik. Die Serielle Ausgabe des SoftRF kann man mittels Notify davon auslesen und man kann auf die Serielle Schnittstelle schreiben indem man darauf schreibt. Soweit so simpel. Und damit kriegt man auch schon ein sehr primitives UART hin:

% ./ble_uart.py 0975FAB7-6F50-4B60-A0D8-9F11C817FB6D
Connected, start typing and press ENTER...
0.00,0000.0000,N,00000.0000,E,0,00,100.0,0.0,M,0.0,M,,*5C
$GPGSA,A,1,,,,,,,,,,,,,99.99,99.99,99.99*30
$PFLAU,0,0,0,1,0,,0,,,*4F
$GPRMC,,V,,,,,,,,,,N*53
$GPGGA,000000.00,0000.0000,N,00000.0000,E,0,00,100.0,0.0,M,0.0,M,,*5C
$GPGSA,A,1,,,,,,,,,,,,,99.99,99.99,99$PFLAU,0,0,0,1,0,,0,,,*4F
$GPRMC,,V,,,,,,,,,,N*53
$GPGGA,000000.00,0000.0000,N,00000.0000,E,0,00,100.0,0.0,M,0.0,M,,*5C
$GPGSA,A,1,,,,,,,,,,,,,99.99,99.99,99.99*30
$PFLAU,0,0,0,1,0,,0,,,*4F
$GPRMC,,V,,,,,,,,,,N*53

Yay!

Nächste Tasks: das NMEA Encoding verstehen und mal schauen ob ich damit eine erste simple Visualisierung hinbekomme.

Inzwischen gibt es mehrere Projekte die Lora Funktechnik für Ad-Hoc-Netzwerke in der Luft (und am Boden) verwenden.

SoftRF ist vermutlich das bekannteste, da es mit günstiger Hardware eigentlich alle Standards unterstützt. Dieses für in der Luft und und dieses als Gegengerät am Boden und für Experimente - jeweils in der in Europa zugelassenen 868Mhz Variante - habe ich mir besorgt, da sie nur jeweils ~25€ Kosten.

SoftRF kommt darauf sogar schon vorinstalliert, das ist wirklich sehr komfortabel.

In Betrieb lassen sich die Geräte auch ganz gut nehmen, einfach via USB an den Rechner anschließen, bei dem einen geht dann ein WLAN auf über das man es Konfigurieren kann, bei dem anderen hat man direkten Zugriff über die serielle:

$ pip install pyserial
$ python -m serial.tools.list_ports
[...]
$ python -m serial.tools.miniterm /path/to/port

Konfigurieren kann man das Gerät dann über eine Config-String, den man in diesem Web-Interface generieren kann.

Easy peasy.

Next Tasks:

• NMEA Nachrichten Parsen und lesbar Ausgeben
• Das zweite Gerät über Bluetooth Low Energy verbinden
• BLE mit einem meiner Flug-Computer-Smartphone Apps verbinden - FlySkyHy oder eVario
• Herausfinden was es braucht um da noch einen guten Barometrischen Sensor mit einzubauen

Diesen Vortrag von Theo de Blic finde ich sehr sehenswert, da er a) viel Erfahrung mit Rettern hat - immerhin 14 Retterwürfe hat er schon durch, und b) einen wunderschön strukturierten Gedanken-Ablauf hat wan und wie man seine Retter werfen soll.

Besonders Wertvoll fand ich die Folie 'Know your limits' in denen er wiedergibt wann Er seinen Retter wirft. Ich habe beschlossen das ich mir diese 'Gedankenkarte' auf jeden fall auch ziehen möchte. Also: 'Note to self' - Wann immer eine dieser Situationen auftritt, egal welche Höhe, ziehe ich meine Rettung!

Know your limits

Höhe

• Ich bin niedrig
• Ich bin nicht sicher ob ich hoch oder niedrig bin

Verloren Fühlen

• Ich weiß nicht was ich tun soll
• Ich weiß nicht wo ich bin
• Ich verstehe nicht was passiert

Unlösbare Situationen

• Line over
• Mehrere twists
• Große Krawatte
• Kaputter Flügel

Kreuzworträtsel finde ich eigentlich langweilig. Aber die Idee die Vorgaben über Reguläre Ausdrücke zu machen finde ich klasse.

Hier geht es zum Puzzle - mit Herzlichem Dank an Jimb Esser.

Ursprünglich entworfen hat es Dan Gulotta am MIT aber die JS Implementierung von Jimb Esser ist einfach Gold wert.