At a first glance passive RFID would be a perfect match for ride photos, the whole mechanism is ridiculously fast so speed of the ride would not matter much (the technology works at highway speeds just fine) and can work over ~15 meters.
But there are two somewhat significant issues with the radio layer in this application: the geometry of tag antenna is somewhat critical (making it into a band would be problematic) and the back scatter is attenuated by salt water blobs (ie. people) almost perfectly.
I suspect that is not an inherent limitation of the dual-ISA design (the HotChips slides mention some sort of bidirectional thread state mapping between arm and z), but just about there not being z/VM release that supports that (building such a thing is probably SMoP, but another question is whether that makes business sense).
IBM's mainframes do not really have a reset vector, the CPU gets initialized by some external means into whatever state the OS expects and then the clock gets enabled, so that distinction is quite moot.
They were always required. IIRC early AMD64 CPUs did not support x87 instructions in long mode at all (causing #UD), and that support was Intel's extension in first EM64T CPUs.
LAHF and SAHF are an interesting rabbit hole themselves.
If you ever dug into x86 assembler programming... at first they make no sense at all. They only save/restore a tiny part of the available flag registers. The mnemonics themselves make little sense - load/store are not really used in any other base x86 mnemonics (unlike e.g. 6502 mnemonics, which use LD?/ST? instead of MOV like x86).
It only clicked when I read an Intel document about porting assembler code from the 8080 to the 8086.
LAHF/SAHF are basically convenience instructions to make porting easier. Many 8080 instructions did not alter the flags, unlike their 8086 counterparts. Substituting an `INX` instruction with `LAHF; INC; SAHF` made it possible to mechanically translate assembler source code.
And yeah, 8080 mnemonics had LDA and STA like the 6502...
Basically the only thing interesting about the ConcertMaster is that Carmack used it (and that it looks somewhat cool). As for the keyboard itself, it is just a basic OEM membrane keyboard and not that good one even. The speakers are lets say adequate for the time and size.
Interestingly, the speaker part and the keyboard part are completely separate. The "cable" consists of four separate cables (keyboard, power, line out, mic in) in a thin sleeve. Mine was supplied with AT plug on the keyboard cable and Y-adapter that converted PS2 into AT DIN and barell jack for the speaker power. The keyboard label indeed says it is powered by 9V DC, but I guess that never really happened as PS/2 is 5V no matter what various devices say.
Edit: And as for the supper hard to find nowadays part: I suspect that part of the reason is that the keyboard module inside the thing is ridiculously sensitive to even minor spills.
I have one! It's fun for retro PCs that don't have speakers or a mic, as it provides everything you need right there without having to setup the Altec Lansings.
Also LOL:
> it has the advantage of packing the best sound system I have ever come across on a keyboard
Do not do this unless you do not have any other choice. Preferrably use whatever native barcode support of the printer involved, if it does not have that, just generate the barcode as vector image or bitmap with a resolution that is a integer fraction of the printers resolution. Generating correct Code128 as a SVG is about the same amount of work as generating the correct input for some sort of barcode font (the hard part is determining the switches between character sets, not generating bars from bytes).
Shameless plug for my web-based Zint frontend: https://barcode.new
(in-browser WASM)
I wrote it specifically because most online barcode generators don’t support vector output or suck in some other way: ads, signup necessary, code payload exposed to server-side processing etc.
Aside from obfuscating the source code to sell licenses, how does this benefit from WASM?
Barcodes have been generated for decades on low-resource embedded devices. Even what would have been a modest-to-low-end machine 25 years ago would have no problem handling the compute needed for this job.
On this end, it just looks like the user has to deal with the penalty of dealing with 1 MB of resources when hitting the main page.
The benefit of WASM in this case is that you can wrap a mature library written in C/C++ (in this case, Zint), and run it in a runtime that supports WASM, e.g. the browser. There's plenty of people who occasionally need to create barcodes, and not in some industrial, automated way, and a browser is just an easy way to accomplish that. Yes, you have 1MB loaded when you load the page, but hopefully that will be served from a cache.
As a connoisseur of SVG, I like the approach, the results, the use of Zint and WASM. That said, there are a few opportunities.
The version string isn't needed these days, nor the XML header or the doctype.
The code/url/page title can go in the SVG title, to make it show on mouseover.
The id=barcode is also superfluous. Since id codes should be unique, this could be a problem when many QR codes exist on a page.
The background rectangle does not need x=0, y=0 since that is implied.
The 'hard coding' of the black and white is what you want to avoid any dark mode issues, however, I would still use currentColor and transparent rather than black, just to put myself in a world of dark/light mode pain, fixed in CSS.
The SVG is actually generated by Zint itself, only lightly patched in the wrapper. Zint is a pretty old barcode generator (not meant disrespectfully, quite the opposite actually), it's quite possible that some of its decisions when rendering to SVG are out of date or very conservative. The use of id/global namespace does feel like a potential pain point though, which I will take up with the upstream project.
I once worked at a company that used a Code39 font cartridge in HP Laserjets. When HP stopped putting font cartridge slots in their printers, I had the task of intercepting print jobs and detecting the font selection sequence, then taking the text and converting it to a Code128 bitmap graphic. It wasn't hard at all, kind of fun actually.
Like another poster said, laser printers "back in the day" were freestanding computers with various communications interfaces that happened to have fancy paper handling and printing peripherals attached. In the case of the Apple LaserWriter, for example, it was arguably a more powerful computer[0] than the Mac machines of the day that were sending print jobs to it.
There were different ROM "personalities" available for laser printers, some of which came on pluggable cartridges.
Michael Steil, the blogger responsible for those links, has done work extracting code and PostScript data out of some of those old cartridges. It's a really cool aspect of retrocomputing many people aren't even aware of.
commented elsewhere but The links you shared are pretty cool, a little before my time (born late 80s). That's kinda neat, it makes me think of a post on HN some time back by Donald Knuth on the letter S and the technical challenges back then about that as a letter, mathmatically. I'm guessing given that, that's why printers needed these modules and were set up this way. Neat!
The LaserWriter was like something from the future compared to the Laserjet. I think they used the same Canon print engine, but the HP was far less sophisticated. It only used bitmap fonts, nothing scalable like Adobe's Type 1 for Postscript. Knuth probably used a supercomputer for his typesetting.
In the dark ages, when printers were PostScript and more powerful (and expensive) than the computers which printed on them, you added fonts by installing additional hardware modules, similar to a game console cartridge.
The links someone else shared are pretty cool, a little before my time (born late 80s). That's kinda neat, it makes me think of a post on HN some time back by Donald Knuth on the letter S and the technical challenges back then about that as a letter, mathmatically. I'm guessing given that, that's why printers needed these modules and were set up this way. Neat!
Up until like 15 years ago, lots of laser printers even had RAM slots as well. Populating them with extra RAM made them behave better when printing big PDFs and stuff.
I did exactly that ( bitmap ) for a retail application back in ~2000. It was just a couple of constants for the stop and start sigils plus an array of bits for the digits....it was a quick work.
Recently I put some 8-bit graphics in SVG using lines and stroke dash arrays. I also got them animated, in a space efficient way, by keeping the lines that do not change from frame to frame. (I now have Maria and Willy from 'Jet Set Willy' for the wait after a form is submitted, plus a few Space Invaders. I am resisting the urge to do Pac-Man ghosts, but I will invent a need for them...)
Since an SVG can be a mystery box full of CSS, SMIL, Javascript and 'foreign object' imports, I am tempted to give it a go, so that a CSS variable is passed to the depths of the shadow DOM in a URL fragment or query string, to magically return either a barcode or a QR code.
This will take a little while, but I am keen to give it a go. In some ways, SVG is like 'Duplo LEGO' with the Libre Barcode as a font more like 'LEGO Technik', requiring vastly more skill.
Just because you can doesn't mean that you should, plus there are many barcode libraries that I know well, so why reinvent the wheel?
The typical barcode library usually comes with fluff, formats and libraries that I don't need. Hence 'qr.svg#upc-number' with it just being one file has appeal.
I am not yet up to speed on the latest AI toys, however, given the problem space is well defined, could I just ask AI chat bot to churn out the code for this in a matter of seconds, for it to encapsulate the logic in an SVG? Would it know how to specify 'crisp edges' and what the deal is with aspect ratio?
Similarly, could I also ask the AI nicely to create my own barcode font?
These seem manageable problems for todays trillion-dollar wonder tech, it is not as if I am asking for a cure for cancer or anything hard, yet I lack confidence in an AI solution, and feel I might as well work it out myself, given my goal is learning SVG rather than prompting.
My lack of confidence is the AI solution is due to the scarcity of people writing online about doing cool things with CSS variables, URL fragments and code in SVG. A Google search does not show 'stroke dash array' things for QR codes and online QR code generators create lots of fully fledged rect-angles, that lack the space efficiency or human-readability of my prefered approach, even if gzip doesn't care.
Sorry for bringing AI into everything, I just have my doubts that the new toys are that capable when it comes to novel solutions.
The fact that this is standard practice does not mean that it is not perverse. It kind of works sanely for plain Code39 (and even then you will see effects of doing that in weird places, like VAG stamping human readable VIN on a chassis, including the Code39 start/stop symbols), once you start using barcode fonts for Code128-derived symbologies (ie. UPC/EAN) the whole thing becomes a pointless exercise.
One thing is 120bit RSA (readily broken with a graphing calculator at the time of release), another thing is the provenance of the RSA implementation code in the original binary.
The most important fix in SP1 for Office 2007 was fixing exactly that in Excel. Doing ridiculous amount of 4 byte reads made it basically unusable on network filesystems.
One point is that there is no reason for the entire secret to be one element of the underlying field, it can very well be a n-tuple of elements of a smaller field, with GF(2^8) being the somewhat obvious choice if you do not expect ridiculous numbers of shares, no need to deal with bignum math.
But there are two somewhat significant issues with the radio layer in this application: the geometry of tag antenna is somewhat critical (making it into a band would be problematic) and the back scatter is attenuated by salt water blobs (ie. people) almost perfectly.