Maistro

Back in 2012 I wrote a blog post titled just Programmer about both my job title and a company I'd just joined as a Programmer. I was very happy to be called a Programmer until quite recently. In the last few months, with the assistance of AIs like Kimi 2.5 and Claude, I've become something else. Something that uses my experience as a programmer by amplifies it massively. And, at the same time, makes me spend most of my time on the design and features of what I'm building and not the code. 

What is this called?

Maybe it's a still a "software engineer" (for those who like that title). But the engineering is being done with new tools. But I don't think that quite captures it because the balance between the "writing code" and "designing architecture and choosing features" has shifted to the latter. 

I'm more like the conductor of an orchestra but working with two AIs (one writing code, the other writing tests) to get something built rather than getting an orchestra of many to produce something beautiful. But conductor still doesn't feel quite right because this new job is heavily skewed towards creation (and not interpretation and expression).

I think the right word is a "maestro" or, if the pun can be forgiven, a maistro.

maistro (n): a software engineer who uses AI tools to create software by focusing on design, architecture, testing, and features.

The European Schuko socket bothers me

Because it isn't polarized, and that can lead to a situation where something is switched "off" but there's 230V of electricity still present. Take a look at this thing:

At the bottom you have a standard European Schuko socket and Plugged into the socket is the power strip on the right. Plugged into the power strip is the lightbulb on the left that I've mounted and wired so I can measure the voltages between live, neutral and earth. 

Above the power is on to the strip, but the switch in the power strip for the light off. Unsurprisingly, the lightbulb is lit off. Even less of a surprise is that turning the switch to on lights the light.

For the rest of the blog I'll remove the lightbulb and just concentrate on what voltages are present at the lightbulb holder. When off there's no voltage (or rather a tiny phantom voltage) between live and neutral (brown and blue).

But when the switch is on, the multimeter is showing 230V AC between live and neutral. So, no surprise that the light comes on when the switch is on!

The same voltage is present between live and earth. In a standard European or UK house the earth and neutral wires are joined together (called "bonded") somewhere close to where the power comes into the house. The live and neutral wires are two halves of the circuit and electricity needs to flow from one to the other for the light to come on. In this standard set up the neutral and earth have (theoretically) the same "potential" of 0V. When the light is on the idea is that electricity flows from the live to the neutral.

If you touch live and neutral you'll electrocute yourself, but also if you just touch live because the electricity will run through you to earth. 

Between neutral and earth there's close to 0V of difference. The multimeter is showing tiny phantom voltages induced in the wires.

The important thing to remember is that the voltage in a home is "referenced to earth" and thus will run to earth (potentially through you) given the chance. That's why you get an electric shock if you touch a live wire. The current flows through you to earth. You do not want that to happen. In theory you could touch the neutral wire and not get electrocuted because it's at the same voltage/potential as earth: 0V. BUT DO NOT DO THIS EVER. EVER. YOU DO NOT KNOW THAT NEUTRAL IS ACTUALLY 0V.

Take a look at this; all I've done is unplugged the power strip at the bottom and plugged it back in the other way around. Suddenly, there's apparently 230V between neutral and earth, and that's with the power strip turned off!

That's because the little power switch on the strip does not cut both the live and neutral wires when turned off; it cuts off one of them. If you plug the strip in one way you might get lucky and cut live, but you can easily plug it in the other way round and find that what looks like it's neutral as actually live and has 230V. THIS IS ANOTHER REASON NEVER TO TOUCH SOMETHING YOU THINK IS NEUTRAL. Also, imagine you've turned this off and are changing the lightbulb. The same 230V is present inside the light fitting just waiting for a human finger to become a conductor!

You can see that despite there being 230V present the lightbulb does not glow. But there are dangerous voltages present. In fact, with the lightbulb present it's even worse, because the "live" and "neutral" wires coming out of the light fitting are 230V because the 230V has passed through the light and is now present on the wire on the other side of it.

(Ignore the multimeter here as it's not connected).

So, in summary:

1. DO NOT TOUCH WIRES IN HOUSEHOLD WIRING EVER.

2. Do not trust power strip switches to actually remove all dangerous voltages from a device.

3. Do unplug things when working on them (e.g. changing a lightbulb)

4. Do buy power strips which have switches that cut both wires when off (such as this Brennenstuhl power strip; not an affiliate link or anything, I just use this one in my lab.).

5. Move to a country that uses the one true great power socket of all time 

OK, that last one's in jest because there are reasonable criticisms of the British plug design, but it, perhaps unreasonably, bothers me that it's possible to turn something off and discover there's 230V present.

There's a ridiculous amount of tech in a disposable vape

So, I'm walking through a park when I see this thing lying on the ground:

It's a disposable vape that someone has discarded because it's empty. Specifically, it's a "Fizzy Max III 60K Rechargeable Disposable Vape" and I was about to take it to a bin to throw away when I noticed it had USB-C. I know nothing about vapes so that was a total WTF moment. 

Naturally, I took it home, sanitized it, and plugged it in. Not only did this thing have USB-C and a rechargeable battery, it had a small display showing battery percentage and poison vape fluid percentage. It looks kind of cyberpunk.

I ripped the thing apart and discarded the now empty chambers that had contained the fluid. At the bottom there are two circuit boards and a battery. 

The battery is an 800 mAh lipo.

So, wait? This is a disposable device. After 60,000 sucks on the teat you're meant to throw away a battery, display, microprocessor etc. WTF? Turns out that you're meant to recycle it, but it's crazy large amount of technology for nicotine sucking. 

On one side you've got three pairs of pins that are inserted into the chambers containing the vape fluid and are controlled by three transistors on the other PCB. These pins heat the fluid making the vape's vapour. They are activated by the three microphones seen in this picture.

The vape knows you're sucking on the teat in one of six positions by which combination of microphones sense the sucking. This allows it to heat one or two of the chambers providing six flavour combinations.

Three transistors and a small chip that controls charging of the battery. 

Sadly, despite there being some pretty obvious pads connected to the microprocessor (labelled B0081S1) and the fact that those pads are also connected to the USB-C connecter, I have been unable to talk to it via PyOCD or other tools. I was hoping this was a small ARM device that I might be able to hack.

If you care about security you might want to move the iPhone Camera app

There's a quirk in the iPhone Camera app that can drive a security conscious iPhone owner crazy: if you touch your finger on the Camera app icon without actually opening the app, the camera starts operating. That causes the little green dot indicator on the iPhone to turn on and then after a few seconds disappear. This can easily make a security-conscious iPhone user worry that some app is nefariously using the camera.

Because touching the Camera app icon without opening the app is enough, it's easy to activate the green dot while swiping between screens or even just holding your phone. This was driving me nuts and I thought some app was using the camera when I didn't want it to.

I enabled Apple's App Privacy Report (under Privacy and Security) in Settings and, sure enough, it confirmed that the little green dot was happening because the camera was being used by the Camera app. Merely swiping while accidentally touching the Camera app's icon was enough to add an entry in the App Privacy Report.

The solution was moving Camera app away from where I was liable to brush it with my fingers or thumb. That reduced the errant green dots to almost zero and reassured me that nothing untoward was happening.

One of the big problems in security is people get used to odd behaviour they can't explain and end up overlooking a real problem masked be the things that "always happen". The accidental green dots could have been hiding actual nefarious use of the camera. Better to be tidy and eliminate the false positives.

(I previously used the term "hover" for what I was experiencing and that was causing confusion. This happens if you touch the Camera app icon without actually opening the app.)

A couple of handy KNX gadgets

KNX is a European standard used in home automation. It's primarily based around a twisted pair bus transporting DC power (30V) and data at 9600 bits/second. Devices attached to this KNX bus draw power for their operation and receive and send messages called telegrams. The devices are typically things like switches, relays, dimmers, HVAC interfaces, small displays, and blind/shutter controllers.

If you're working with a KNX bus you connect a computer to it via bus interface. These are commonly either a USB interface or an Ethernet/WiFi connection. Either way the computer is able to send and receive telegrams and monitor the bus for debugging. This interface is also used for programming the various KNX devices on the bus (for example, associating pressing a button on a particular switch with a particular light circuit going on or off).

Sometimes it's useful to program devices "off the bus" (i.e. away from the actual installation). For this purpose I put together the simplest of minimal KNX buses: a power supply to inject the necessary 30V, a USB bus interface, and a dangling KNX connector (the red and black thing in this photo) that can be plugged into the device to be programmed.

Normally the power supply (on the left) would be wired in permanently, but here I am just using a standard power cord for desktop programming. The USB bus interface is in the middle. There's nothing special about these devices, there are hundreds of KNX manufacturers that interoperate; I just happen to be using an ABB power supply and ABB bus interface.

This works great: plug the device to be programmed into the connector on the right and hook the PC running the KNX programming software ETS into the bus interface via USB. And apart from the two ABB boxes, all that's needed is a power cord, three WAGO 243-211 connectors, and some twisted pair. I used random wires that were lying around, in the real world of KNX installations you'd use proper shielded twisted pair cables!

The other gadget I built is this custom PCB (possibly the world's simplest PCB):

It just connects four KNX terminals together in parallel. The pins at the top are the standard WAGO 243-131 pins compatible with the WAGO 243-211 connector. When soldered together it looks like this:

In conjunction with a bus interface it lets you tap into an existing KNX bus if there's no bus interface present. Or if it's just more convenient to connect where you are working. You simply unplug some device from the bus, plug the bus into this PCB and then plug the device into the dangling connector.

The bus will work normally and you'll have access for debugging and programming. (Note: you can do this because the KNX bus can be a tree and so it's acceptable to plug in a spur of a couple of devices to the main bus line).

The PCB design is based on Matthias Kleine's KNX Distributor; my version can be found here. (If you build this you'll also need Matthias Kleine's footprint library).