What have we lost?
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Subtitle |
| |
| Title of Series | ||
| Number of Parts | 275 | |
| Author | ||
| License | CC Attribution 4.0 International: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/52358 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
| |
| Keywords |
00:00
InternetworkingIterationQueue (abstract data type)Series (mathematics)NeuroinformatikElectronic mailing listSystem programmingProcess (computing)Lecture/Conference
01:27
TrailSoftware developerMultiplication signComputer hardwareSpacetimeMainframe computerProcess (computing)Goodness of fitSoftwareElectric generatorCycle (graph theory)XMLMeeting/Interview
02:16
System programmingNeuroinformatikFigurate numberRule of inferenceGroup actionoutputSymbol tableVirtual machineMobile appMereologyPresentation of a groupBridging (networking)Insertion lossMeeting/Interview
03:04
Integrated development environmentPlastikkarteDirection (geometry)CuboidOperating systemVirtual machineSoftware developerMultiplication signOperator (mathematics)Decision theoryIntegrated development environmentEnterprise architectureProcess capability indexPowerPCComputer hardwareQuicksortAlpha (investment)Computing platformCombinational logicBus (computing)CompilerSinc functionError messageVideo gameData structureComputer animationMeeting/Interview
04:32
Computer hardwareIntegerSemiconductor memoryTask (computing)Virtual machineVideo gameResource allocationBitWordType theoryComputer programmingComputer hardwareCoprocessorCompilerElectronic visual displayDemo (music)Set (mathematics)CodeModal logicMiniDiscDecision tree learningProcess (computing)TouchscreenArithmetic progressionInterface (computing)Entire functionPixelLevel (video gaming)Enterprise architectureNumberImage resolutionConstructor (object-oriented programming)Shift operatorPoint (geometry)SpeicherbereinigungComputer animation
06:35
Open setMountain passElectronic visual displayType theoryContext awarenessVirtual machineVariable (mathematics)System programmingResultantTouchscreenElectronic mailing listComputer hardwareSeries (mathematics)Computer fileWindowContent (media)Right angleGreatest elementFormal languageDirectory servicePoint (geometry)Object (grammar)Graphical user interfaceSet (mathematics)Text editorAsynchronous Transfer ModeComputer configurationLine (geometry)outputCodeCloningMultiplication signBellman equationBitSoftware frameworkDifferent (Kate Ryan album)Parameter (computer programming)WritingImage resolutionComputer-assisted translationSource codePixelPattern languageEquivalence relationOnline helpFunctional (mathematics)Gastropod shellRepresentation (politics)Exception handlingGame controllerShared memoryMenu (computing)Reading (process)Bit rateMetropolitan area networkMaxima and minimaCASE <Informatik>MassDesign by contractExecution unitState of matterUniqueness quantificationComputer animation
13:26
Ideal (ethics)Line (geometry)Bayesian networkBytecodeInterpreter (computing)Virtual realityGraphical user interfaceComputer hardwareSoftware developerPointer (computer programming)Element (mathematics)CodeRegulärer Ausdruck <Textverarbeitung>Text editorSoftwareGraphical user interfaceObject (grammar)TouchscreenUbiquitous computingDemo (music)Error messageImplementationVirtual machineIntelligent NetworkElectronic mailing listText editorMathematicsQuicksortVirtualizationTouch typingWindowMiniDiscBytecodeWorkstation <Musikinstrument>System programmingArmExpressionForm factor (electronics)Source codeSurjective functionCodeCellular automatonGame controllerDifferent (Kate Ryan album)WordSemiconductor memoryOpen sourceEmailBitComplete metric spaceSymbol tablePointer (computer programming)DialectBoss CorporationNeuroinformatikOperating systemComputer animationMeeting/Interview
16:28
Text editorFunctional (mathematics)Context awarenessComputer programmingVariable (mathematics)Term (mathematics)Menu (computing)CodeStructural loadSystem programmingMaterialization (paranormal)Computer fileSemiconductor memoryExpressionBitExpandierender GraphIntegrated development environmentElectronic mailing listDemosceneDoubling the cubeWhiteboardChainGraph coloringWindowSheaf (mathematics)Bus (computing)Traffic reportingError messageProgram flowchart
18:41
Metropolitan area networkUser interfaceComputer fileTemplate (C++)Insertion lossFunctional (mathematics)Menu (computing)Content (media)Generic programmingBitSemiconductor memoryTable (information)Type theorySymbol tableMathematicsFlow separationVirtualizationHypertextParameter (computer programming)WindowQuicksortVirtual memoryWeb browserStructural loadRevision controlTextsystemVirtual machineDemo (music)Computer virusSpherical capSpacetimeFormal languageClosed setSensitivity analysisCASE <Informatik>Validity (statistics)Network topologyElectronic mailing listSystem callMiniDiscPrisoner's dilemmaComputer programmingData storage deviceWave packetOrbitSpeech synthesisForcing (mathematics)Instance (computer science)Row (database)Inheritance (object-oriented programming)Program flowchart
24:53
BefehlsprozessorAsynchronous Transfer ModeIntegration by partsSystem programmingReal numberOperations researchAtomic nucleusComputerImplementationEmbedded systemStandard deviationKeyboard shortcutCodeLatent heatModel theoryObject (grammar)Virtual realityType theoryHypertextText editorElement (mathematics)Data dictionaryMereologyMechatronicsType theorySpeech synthesisMedical imagingObject (grammar)Demo (music)TextsystemTable (information)VirtualizationStandard deviationNeuroinformatikSystem programmingSoftwareSpreadsheetPersonal computerEmbedded systemVideo gameVirtual machineMikroarchitekturLink (knot theory)Multiplication signReal numberInternet der DingeCartesian coordinate systemNumberDampingInternetworkingComputing platformSet (mathematics)QuicksortImplementationUniqueness quantificationRight anglePlastikkarteVideoconferencingKeyboard shortcutData structureGodLimit (category theory)Instance (computer science)Uniform resource locatorBus (computing)WeightMenu (computing)Projective planeSource codeComputer animationProgram flowchart
27:11
Electronic meeting systemRevision controlInformationMathematicsElectronic visual displaySystem programmingTerm (mathematics)Utility softwareMenu (computing)TouchscreenWindowHill differential equationPeer-to-peerVirtual machineSpecial unitary groupContext awarenessVirtualizationRevision controlWeb 2.0TextsystemObject (grammar)Software development kitDoubling the cubeSystem programmingPatch (Unix)Drag (physics)Variety (linguistics)File archiverWeb pageBlogHypertextComputer animation
28:32
Utility softwareMenu (computing)Electronic visual displayTerm (mathematics)Template (C++)Electronic mailing listWindowFormal languageBootingRight angleHyperlinkData structureObject (grammar)TextsystemOpen setSoftwareDrop (liquid)Web pageVirtualizationWeb browserComputer fileReal numberSystem programmingCASE <Informatik>Bit rateGraphics tabletSpring (hydrology)Shape (magazine)Demo (music)Computer animation
31:42
User interfaceAddress spaceRead-only memoryServer (computing)System programmingLine (geometry)PowerPCPower (physics)PC CardEmulatorLibrary (computing)InformationMathematicsString (computer science)Directory serviceProcess (computing)Service (economics)Computer fileFunction (mathematics)User profileLoginParameter (computer programming)Cursor (computers)Interactive televisionComputer configurationContext awarenessComputer programEscape characterStructured programmingBlock (periodic table)Type theoryPointer (computer programming)Streaming mediaControl flowCursor (computers)Presentation of a groupRevision controlSystem programmingPosition operatorAdditionWeb 2.0Pointer (computer programming)Computer programmingElectronic mailing listSinc functionEmulatorGame controllerComputer scienceRadical (chemistry)Buffer solutionRight angleLetterpress printingTouchscreenPower (physics)Goodness of fitDirection (geometry)Data storage deviceSpacetimeTorusOffice suiteInterface (computing)MathematicsInformationSurfaceContext awarenessFilm editingParameter (computer programming)Mainframe computerGame theoryMachine visionMixed realityType theoryComputer configurationCommunications protocolPowerPCNormal (geometry)MereologySystem callIBM MainframeDampingCuboidContext-sensitive languageEnterprise architectureRaw image formatForm (programming)1 (number)Real numberOnline helpComputer fileKey (cryptography)Virtual machineInformation securityComputer animation
34:36
Message passingComputer configurationData typeMenu (computing)Electronic visual displayOnline helpGreatest elementAreaSystem programmingOperations researchOperator (mathematics)Sign (mathematics)Task (computing)Function (mathematics)BefehlsprozessorComputer filePower (physics)Key (cryptography)Parameter (computer programming)Attribute grammarType theoryPosition operatorCursor (computers)Computer configurationCodePoint (geometry)Ferry CorstenTouchscreenDistanceMainframe computerBitProcess (computing)Menu (computing)Entire functionDifferent (Kate Ryan album)Object (grammar)Multiplication signLibrary (computing)TriangleCursor (computers)Default (computer science)Online helpString (computer science)Interface (computing)SpacetimeSystem programmingDemosceneField (computer science)Game controllerService (economics)Context awarenessSpring (hydrology)CASE <Informatik>Context-sensitive languageQuicksortComputer fileLink (knot theory)Key (cryptography)View (database)Computer animation
38:33
Kernel (computing)MereologyINTEGRALSystem programmingObject (grammar)Level (video gaming)Data storage deviceSource codeComputer fileAddress spaceSingle-precision floating-point formatPointer (computer programming)Table (information)Data typeVirtual realityRead-only memoryComputer hardwareCodeBytecodeVorwärtsfehlerkorrekturWordCompilerModel theoryInformation securityFingerprintWeb pageSystem programmingTable (information)Variety (linguistics)Single-precision floating-point formatDressing (medical)Power (physics)SpacetimeComputer fileBasis <Mathematik>Row (database)Pointer (computer programming)Data structureDemosceneTranslation (relic)Demo (music)Address spaceTerm (mathematics)Point (geometry)Functional (mathematics)Semiconductor memoryComputer programmingObject (grammar)Source codeKernel (computing)Extension (kinesiology)Client (computing)State of matterNatural numberModel theoryMereologyProcess (computing)Group actionBuffer solutionMathematicsDifferent (Kate Ryan album)Level (video gaming)Information securityBootingFile systemBytecodeMachine codeSystem callMiniDiscBitPowerPCPermanentCodeOrthogonalityCoprocessorComputer animation
40:44
Menu (computing)Electronic visual displayTask (computing)System programmingService (economics)Sign (mathematics)Hill differential equationFunction (mathematics)PC CardInformationWeb pageData typePosition operatorString (computer science)Einstein field equationsExt functorControl flowService (economics)Data structureAdditionElectronic visual displayCASE <Informatik>System programmingAssembly languageData storage deviceSinc functionPowerPCNumberObject (grammar)Exception handlingHexagonKernel (computing)CodeText editorNormal (geometry)Pointer (computer programming)DisassemblerType theorySpacetimeElectronic mailing listComputer programmingPoint (geometry)Core dumpCrash (computing)Library (computing)Table (information)Goodness of fitBytecodeMiniDiscPrimitive (album)BitQuicksortContext awarenessCodierung <Programmierung>Multiplication signInheritance (object-oriented programming)Different (Kate Ryan album)Level (video gaming)InformationFamilyResultantKey (cryptography)Scaling (geometry)AlgebraTerm (mathematics)Thomas BayesMenu (computing)Semiconductor memoryHecke operatorDemosceneSource codeComputer animation
46:04
EmulatorVery-large-scale integrationLevel (video gaming)Electronic program guideNeuroinformatikRight angleAdditionEmulatorArithmetic progressionMultiplication signAreaElectronic mailing listMiniDiscVirtual machineCore dumpMeeting/InterviewComputer animation
47:43
Computer hardwareIntegerSystem programmingComputer hardwarePatch (Unix)Multiplication signComputer scienceCodeFigurate numberShared memoryElectronic mailing listTask (computing)Entire functionSet (mathematics)Core dumpSource codeInteractive televisionVirtual machinePoint (geometry)Functional (mathematics)SoftwareSpeicherbereinigungInterface (computing)Moment of inertiaMathematicsEqualiser (mathematics)Field (computer science)Contingency tableNeuroinformatikComponent-based software engineeringSymbol tableOperating systemComputing platformCompilerIntegerSystem programmingWritingCellular automatonSemiconductor memoryConstraint (mathematics)Data managementOpen sourceDampingPerspective (visual)Enterprise architectureLink (knot theory)SpacetimeMereologyScripting languageOntologyOrder (biology)Generic programmingRow (database)Cohen's kappaSequelFreewareReal numberMatching (graph theory)CuboidInfinityCausalityBoolean algebraDependent and independent variablesMechatronicsOrbitMeeting/Interview
54:31
Video gameBitImplementationAnalogyMultiplication signAdditionVector spaceCalculationLatent heatOrder (biology)Virtual machine1 (number)Web pageDifferent (Kate Ryan album)QuicksortType theoryRight angleDistribution (mathematics)Point (geometry)Pointer (computer programming)Remote procedure callSingle-precision floating-point formatPowerPCExtension (kinesiology)Chaos theoryComputer hardwareObservational studyModel theoryIntegrated development environmentCASE <Informatik>Alpha (investment)Semiconductor memoryUniform resource locatorArmWorkstation <Musikinstrument>Generic programmingProcess (computing)RandomizationMechatronicsNumberHypermediaPower (physics)Error messageGoodness of fitConstructor (object-oriented programming)Range (statistics)Suite (music)PlanningCAN busGroup actionOffice suiteGod2 (number)Electronic mailing listCodeForcing (mathematics)NP-hardOnline helpContrast (vision)VotingReading (process)Event horizonSoftwareSurgeryMeeting/Interview
Transcript: English(auto-generated)
00:15
Our next talk will be by TQ, Kelvin and TechFury, which would have been far more difficult
00:28
actually if we would have met in Leipzig, because TQ is originally from the US, now he lives in Belgium, Kelvin is from Canada and TechFury is from the US.
00:44
So this would have been far more difficult to do in person. TQ has been into retrocomputing for around 20 years, starting with the TRS-80, moving over to minicomputers and yeah, he's especially interested in the features
01:05
that died with that market segment. Kelvin from Canada started retrocomputing also as a hobby and he lives the dream of most of us because he got to make a job out of it, so he works with the more
01:23
modern iterations of the systems he started out with as a hobby and TechFury is a daytime shipment tracking software developer and a nighttime necromancer
01:40
for weird old hardware and together the three will talk to us about what have we lost, features of mainframes and so on. Good evening everyone, let's talk about some fun old shit you can learn from at home. Your hosts tonight are Kelvin Buckley.
02:01
Hi, I basically, on my day job, I just basically do a whole bunch of PHP hacking on IBM, I, spoiler alert, we're going to be talking about that. And at night I basically enjoy preserving software for future generations. Apparently there's also this guy called TQ. Hi, I, by day I build distributed, or I build a distributed trust system for
02:23
computers and at night I figure out how to make computers, how to make old computers feel comfortable in a modern world and there's also Landon. In my day job, I maintain an in-house iOS app and at night I'm a curator and fixing it out of bygone Japanese and British computer systems, you know,
02:44
like NEC, PC-98, Acorn Archimedes, et cetera. And with that being said, let's hand off to TQ with his presentation on the Symbolics LISP machine. So in the early eighties, MIT spun off part of its research group into
03:01
a firm that produced LISP machines. That firm was called Symbolics. They built a machine called the Symbolics 3600 that ran an operating system called Genera. What exactly was this? Well, obviously based on the name, it's a LISP machine. It's a, it's got hardware that runs LISP directly.
03:21
Everything that ran on the machine was written in LISP from the microcode to the operating system, all of the drivers, everything. It included all of your development tools that you'd expect. So the editors, your editor, your compiler, your debuggers, inspectors, to be able
03:44
to look at data structures, all in LISP. Oh, and it was for a very long time considered to be one of the best development environments around. It ended up buying as sort of a noble breath because for a combination of
04:02
reasons, first of all, the company made some absolutely terrible decisions. They ported their platform to run on a new bus on Macintosh, shortly before Apple switched to PowerPC and PCI and PCI.
04:23
And then they went from there to the architecture of the future, Alpha. And then they died. We're not here to talk about the death of Symbolics. We're here to talk about their life. Oh, let's talk about their first machine, the 3600 shipped in 1983.
04:43
It had a 36-bit word, four bits of which were set aside for tag bits to tell what type of data was stored in a particular word. And the other 32 bits were for the value of that particular word. The processor microcode had up to 16 hardware tasks to be able to handle
05:09
things like interfacing with the disks, driving the display. Scanning the keyboard, accessing the network, et cetera.
05:20
That microcode also provided a high-level instruction set that had instructions like cons to allocate memory and garbage collect if necessary. It also had your usual compliment of arithmetic instructions, add, subtract, et cetera. But unlike most architectures, even modern architectures, the arithmetic
05:44
instructions operated on arbitrary precision words, even possibly rational numbers. At one point, they ported a C compiler to it. It just used the native machine integers because why not?
06:00
And somebody tried to run a program that determined the size of the word by shifting one left until it ran off the end. And this program ran for about an hour until it ran out of memory.
06:22
So I could explain the interface, but it's probably easiest to start with a demo. When you start up Genera, you're greeted by a pretty high-resolution graphics
06:41
display. The original machines shipped with an 1100 by 900 resolution screen, so this full HD display that you're seeing right now is not far off from original hardware. So many pixels to play with, it may actually be surprising that the entire display is taken up by a command line, but this is not the Unix command line that you're used to.
07:01
We'll start by logging in. That's what it tells us to do. And immediately we see that there's a significant difference. Normally with a Unix command line, you start by you type in a command, CP, LS, whatever, and it just waits for you to type in the rest of the command. If you need to give parameters, you need to already know what those
07:22
parameters are, possibly looking them up in a man page. Genera, on the other hand, Genera holds your hand a bit more and prompts you. You need to enter a username. Okay, I'll do that. Okay, so what can we do here? As any Unix user knows, the first thing that you do in any terminal, whether or
07:45
whether you've just changed the directory or whatever, first thing you do is do LS. Genera spells it a bit differently, and I'm going to list my home directory, which hopefully is already selected.
08:02
This still looks very much like a traditional Unix directory listing. But you'll notice that as I mouse over it, it actually highlights individual lines. And this is the first hint that there's something really special going on. Suppose that I want to list the contents of one of these directories.
08:23
I'll type in show directory. You'll notice actually that I just typed in the first couple of characters and it auto-completed. I want to list the Lisp directory. And I could type it, but it's already on screen.
08:40
I should be able to just click it. And when I do, it pastes it into the prompt and I can hit enter to accept it. That just lists the directory itself, which is not quite ideal. I wonder what else we can do. It happens if you just click it directly. That actually lists the contents. And you'll notice that it actually filled in a command for me.
09:05
It says show directory genera vlm home to quux lisp slash star. What has actually happened here is very subtle. Each of these objects that is shown on screen has a set of handlers attached to them.
09:20
And when I click on them, it's best that the system knows a command that should get run. Such a command could be bound to the left mouse button, which is what you'd expect. It might be bound to the right mouse button. In fact, at the bottom of the screen here, you can see, well, I can't actually point it out, but you can see that if I press the left mouse button, it will execute show file.
09:41
If I execute the right mouse button, it will show a menu. And there's a bunch of other commands. So now that I've shown the contents of the lisp directory, let's say that I want to actually show what is in a file. Just type in show file and we'll get to these files later.
10:03
For now, let's just look at this file one and file two. Paste file one and it shows the contents. It says no need to get catty, which makes sense. This is basically the equivalent of cat. I could have done the same thing by just clicking that without typing in the command first.
10:21
I have other options too. I can open up an editor, point to resize the current window, open an editor and
10:42
move that aside so that I can see the window underneath. This is ZMax, as you can probably guess from the name, it's just an Emacs clone. The Z actually stands for Svi, which in turn stands for Svi was Ina initially. And in case you're curious what Ina stood for, Ina is not Emacs.
11:04
It's all in good pun. Being an Emacs clone, we can open a file with Control X, Control F. We know that we want to look at file one, so we can click it and it opens. Earlier, we clicked file one and it printed it down below. If the active window is a ZMax window, though, we can click another file.
11:25
And instead of printing it in the list listener, it opens it. This shows that each window has an input context associated with it. And the input context controls what commands will be automatically executed when you
11:41
select or interact with some object that's on screen. I'd like to point out one more feature of the command line. I remember reading that this was widely seen as the language to implement advanced AIs, and I decided that I didn't care to actually write this talk. I wanted the system to do it for me. It's good at that.
12:01
So I made a command and it asks me what I want to give a talk on. I'm giving a talk on Genaro for now. I click that and it asks me a couple more questions. Do I want to talk about presentations?
12:21
Yes. Do I want to talk about the inspector? Yeah, I might have time. Let's see. Ooh, what do I want to inspect? I can click this and type in a function, the results of which will show me later. I'll skip that for now, because chances are, we'll have enough to talk about that I won't actually have time to get into that.
12:43
Do I want to talk about documentation? Yes. Cool. Let's do that. And as it turns out, I didn't actually have time to make an AI to write the talk for me. So, oh well. So let's take a look at what the code that created that looks like. Here's the source code. All I did is I declared a couple of variables.
13:03
I called the accepting values function and then asked a series of questions. Some of the questions, or whether some of the questions got asked depends on the answers to some of the earlier questions. You may recognize this pattern. This is exactly the same way that you'd write code for React, or IAM GUI, or any of the many modern immediate mode GUI frameworks.
13:27
What have we learned? Interesting things that you saw there that you should really keep in mind. The things that you should remember from that demo are that genera had a pervasive
13:42
command line interface that integrated very, very well with the graphical interface. And that everything that got displayed on screen represented an actual object, and you could manipulate those objects based on the things that appeared on the screen.
14:04
Let's look at an alternative implementation of the same idea, just from the West Coast. Lando? And on the West Coast, Xerox actually invented its own sort of list machine. They originally ported BDN's list for the PDP-10 as people moved over to
14:21
the East Coast, you know, used to work at BBN MIT. Then they ported to the Alto park using a bytecode virtual machine implemented in the Alto microcode. Then it got ported to the successor, the D machines, which they called because they had names right at the letter D, you know, Dandelion, Dorado, Daybreak, so on and so forth.
14:40
And since the InterLISP-D team was near the Smalltalk team, many of Smalltalk's concepts like overlapping windows made their way into InterLISP-D. And as happened with Symbolics, InterLISP was also the victim of the AI winter, and it never really thrived after Xerox sold it off in 88. But recently Xerox has open sourced it.
15:01
Now, since the D machines were actually originally meant to run Xerox's Mesa virtual machine, and they kind of just hacked InterLISP onto them, they're more or less just a simple 16-bit microcode stack machine, you know, not really that different from a lot of 70s many computers, just kind of in a workstation form factor. So they aren't as fast, there's a lot less fancy features, you know,
15:21
none of these fancy tag pointers, none of that, but it worked, and it was a lot cheaper than Symbolics. Eventually a team at Fuji Xerox actually implements this virtual machine in C on top of Sun OS, and it's actually now open source, and you can run it on your common x86 ARM whatnot system today,
15:40
just get it off GitHub. So just like East Coast LISP machines, InterLISP-D is also a complete off-rank, again, written entirely in LISP. However, there's no Emacs for the editor. It's a little bit different on InterLISP. InterLISP's SEdit text, or I'm sorry, code editor, works by editing S expressions directly in memory.
16:01
It's not a text editor. It does not touch source files on disk at all. You just merely edit your S expressions directly in memory, and then just hit done, and it automatically commits the changes in memory, but it requires a further step to save them. And also, InterLISP-D provides TEA, which is a rich text editor that was inspired by the famous Bravo editor on the Alto.
16:24
And now, let's see InterLISP-D for ourselves. Let's start with InterLISP-D. You can try this at home. Everything I'm about to show you can be done with just the materials on GitHub. As you can see, this is a bit more like small talk than genera in terms of aesthetics. We have draggable and resizable windows,
16:47
just like modern windowing systems. We also have right-click context menus. They've been around a while. Now, note that this environment looks more or less the same as InterLISP-D did in the 80s. They haven't changed a whole, whole lot. So anyway, in the exact menu, we can pull up a REPL.
17:02
We have Xerox common LISP, a strict common LISP mode, and we have InterLISP. So let's pull up an InterLISP REPL. All right, so let's customize our environment a little bit. This background's kind of plain. So we're going to use files load, star bg to load in a program called star bg,
17:22
but we don't know what the name of the function we need to call is. But we do know that there's a variable called the star bg comms, and that's kind of like a package manifest where all the variables and functions are grouped together. So what we can do is we can pull up the editor on star bg comms.
17:45
Now this is sedit. sedit's a little interesting, as I mentioned earlier. This is not a text editor. This editor is actually editing the s expressions directly in memory and formatting them as code. So the nice thing about this is that we change the size of it.
18:04
As you can see, the code automatically is formatted to fit the different sizes. Now let's look at our functions down here. See, it's in the functions section. Again, notice as I double click on things, the scope expands. I thought that was pretty cool. So see, star bg, this looks similar.
18:21
So we'll select that, see how it's underlined. And then we will middle click on the menu bar here. You can choose edit functions and take a look at that. That's the function star bg's code. Now let's run it.
18:42
And you see this nice little space themed background. Now let's do a little bit of editing. This is a little bit of a famous demo here, sort of. You see this a lot in old brochures. And why is the mouse being very laggy today? It's kind of strange.
19:03
Famous has the intralisp d logo. But I think we should change some things about. So why don't we, since we know we called coto logo w the function, we'll do df define function, which also edits coto logo w.
19:20
Now we could just simply use some of the arguments such as a string, but you know, let's just hack it. So we're going to change the intralisp d. Hi, RC3. And we're going to go to the sedit menu.
19:41
We're going to choose done. This commits the changes, but only in memory. So it has not changed the file as load from. From the logo again. Hey, look at that. Hi, RC3. Now, like I said, it doesn't save them to disk. So if we do files question mark,
20:04
it notices that we've made changes to the coto logo w function in the coto logo file. And if we do make files, we've now saved it. We can also try this. Let's see how this works with the new function. Let's try df hello, and do a little bit of the hello world function.
20:23
And do this old school intralisp style. So we're going to use lambda. See templates already filled out. We're going to highlight this argument. And then we're just going to hit backward delete, or I'm sorry, forward delete. And then see how that's cleared out.
20:41
And we'll do the same here. Notice when I type the closing parent, it just simply closes it. It doesn't insert anything. I can't just type more. This is very structured. This editor, you do done.
21:01
Now we have our hello world function. And if we do files question mark again, it's going to ask where we'd like to put it. It's beeping at me because it's a yes or no question. They do a lot of things like this in intralisp. So we'll just hit y and we'll give it a name.
21:20
Hello to create a new file. And you can see the changes are marked in there. It's already created a hello to comms. Let's take a look at that. So you can see it's already built a package with just the function hello. Which is the same hello as we see there, as we will see when I pull up edit.
21:45
Same thing. So moving on further from that, you can also do, save it, make files.
22:03
And we can also explicitly do that with make file. Again, and notice there's a version number. This is inherited from tops 20, which is what they ran this on originally before they poured it to the D machines. Now let's take a look at the tedit document editor and the file browser.
22:23
So we right click on here, we can choose the file browser. And we're going to give it medley. Notice the use of the greater than symbol for the path separator. So all right, we're going to take a look here.
22:40
Table of contents. This is the Lisp users library. This is basically a contributed programs from users. So we select it like such there with the left button. We're going to go to edit tedit. Ask us to define our window. So you take a look at this. This is a tedit rich text editor.
23:01
Kind of getting a little bit of a generic document examiner vibe here almost. And it's back to complete rich text editor. Let me see if I can get the, here we go. Expanded menu, page layout stuff.
23:26
You can also quit it. Close that window. And similarly, most of these entries, like say star bg, we were looking at just a little bit ago.
23:41
Let's find that. Similarly, it has its documentation available through here. Now, similarly, we also have a language reference manual available through dinfo. And that too also appears to be based upon tedit.
24:02
Go ahead and actually close tedit there. All right. So you can navigate through this. It's all hypertext style. And then, ah, we almost forgot about Dwim. Dwim is pretty cool. Dwim is do what I mean.
24:21
And so remember how we typed hello and that has to be in all caps because Lisp was case sensitive in this regard. But let's see what happens if I type it all lowercase. It suggests for me automatically that perhaps I meant all uppercase or I could tell that it's wrong. Undefined function.
24:40
And similarly, as you might expect from a virtual machine, virtual memory persistent setup, you can also simply log out. Just got Dwimed again to all caps. And then that will save the entire world. And we can pull it back up again just exactly where we were.
25:03
And that's it for the Interlisp D demo. And now we will go on to our next and last platform I will be demonstrating today. BTRON. Japan's attempt to design their own desktop operating system from scratch. But what is BTRON? It's an outgrowth of the Tron project, which basically was a Japanese academia industry initiative
25:24
to develop a new set of operating systems and standards for a computerized society of the 21st century. And they came up with all sorts of standards like the Tron keyboard. They even have CPU architecture. The end goal of all this was to have essentially a world in which all of the objects in your everyday life
25:42
would be based on ITRON embedded operating systems interlinked through a network of CTRON machines to your BTRON based desktop computer. And so BTRON is known as BusinessTRON. It has a desktop metaphor. It's meant for personal computers. Has a heavy emphasis on working with documents.
26:02
And one implementation of it is still sold today as a VMware image. And speaking of these futuristic systems that sound awful like the Internet of Things, I highly recommend watching this Tron Smart House video I've linked here. We couldn't fit it in here. There wasn't enough time. But you will see that the Internet of Things
26:21
is really nothing new as a concept and that these guys even thought as far as the Internet of Things toilet back in the day. So one of the unique features of BTRON is the Tron Application Data Bus, which defines real objects and virtual objects. Real objects are a type of structured container file.
26:42
They can contain any number of embedded virtual objects or links to other virtual objects within other real objects. BTRON additionally calls for a unified document editor in which various basic objects can be freely mixed and embedded. For instance, you can actually use an embedded spreadsheet object as a table and system updates actually are shipped as documents.
27:03
And speaking of system updates shipped as documents, we're going to actually show you how to install one right now in this demo right now. All right. So I fired up Chilcon GV here. This is the virtual machine, VMware version. It does not need any special hardware or anything.
27:20
So first we need to put this in English. So to do that, we're going to open up a web browser, which is actually a document editor plugin. Then get to the support page, find the Chilcon GV English kit.
27:44
We'll download it, save it as an archive file. And then we open it and we'll drag the document out. So now we've created the real object containing the English patch and we'll open it up.
28:05
It's actually a variety of virtual objects inside. See, I'm double clicking on them. It's very hypertext-like. Go into installation. If you can see right here, update is actually a blob within the document.
28:22
So we'll go ahead and go to system setup, version tab, drag it in here. Once it's reboot, we'll go ahead and do that. All right. And then we'll open the document again. Actually, before we do that, we need to switch the language to English.
28:46
Another reboot. Okay. Now we're in English. We'll open this back up again. What we can do here is if we... Actually, here's an even cooler way of doing this. You can right click on it here, go to real object, virtual object network.
29:03
Ah, you can actually see the structure of all the virtual objects within this document. So if we see this right here, we can do copy to Trey and then copy from Trey. I guess the Trey is what they called the clipboard.
29:21
And let's see, let's open up a text pad, kind of like a basic document.
29:50
So how about let's put our English hatch inside this document here, because you can see it's even been moved out of there. Let's see.
30:00
Oh, let's open up a drawing. Got some funny little shapes. You can either... I can save it to a new real object or the original.
30:23
And we can actually draw it, drop it right in here, which I thought was pretty cool. But you can also embed individual objects from within there.
30:41
So those are also embeddable because again, it's the same document editor. But here is what I thought was really strange. Let's open that web browser again. Let's take this back out. Now we can save this as a Tad file.
31:01
And we do that and look at that. There's our object right there. We can just plop it right in here. And then if we go to see here, let's save this first. If we go to the same real object, do the virtual object network,
31:20
you'll actually find that when we save the webpage as a Tad file, it actually preserved every hyperlink, but each hyperlink is actually a virtual object. I thought that was rather interesting and fascinating. I'd never really seen anything like that from the system before. So that's all for the BTRON demo.
31:41
Hope you enjoyed. Hi, it's the last system we're going to be talking about today. And I actually like BTRON, the only other one that's still sold today. Unlike many of its contemporaries, especially in the IBM mainframe world, it combines an easy to use interface with then cutting edge computer science innovations like capability security.
32:02
If you haven't heard of IBM, you've probably heard of it under one of its many former names and sold to almost exclusively average and non-technical small to medium businesses, basically designed to be treated like an appliance. It runs on IBM's normal PowerPC to server lineup. Before that, it used to run various kinds of custom PowerPC and its own even custom architecture boxes.
32:21
There are no emulators for this, unfortunately. Real steel only. The weird thing about I is that it's outlived almost all of its contemporaries, and even the ones that have survived don't tend to have the healthiest ecosystem as I. Despite this, unless you work with your average small to medium businesses, you never really know I was a thing.
32:43
I was designed to be easy to learn. It kind of looks like MVS, COS, or 370 mainframes, but that's notoriously parochial and hard to learn. A lot of the night feels like it looks similar to the MVS. The files will be for rough edges, because they actually have the luxury of starting from scratch.
33:01
The biggest change is how all the commands were made consistent. Everything is a mix of verbs and nouns and a consistent vocabulary. You can just learn these, and from there, you can guess most commands. If you don't know the arguments to a command, or even the values to pass into an argument or whatever you see on screen, you can just press the F4 key. That'll bring up a form prompt,
33:20
and where you can have all the options presented to you and even explained. It'll usually even generate the actual command to run it, so you can use it both as a learning tool as the convenience. If you see something on the screen that you're unsure of, you can just press F1, and it'll show context-sensitive help for anything under the cursor. As for how the F4 prompt works,
33:40
it's because you're not really invoking the program directly. Instead, there are commands that provide the list of arguments with names, types, and other information, in addition to the actual call to the program itself. Interestingly, the values from this get passed directly to argv. You can handle pointers, including buffers passed to your program,
34:00
we'll come to that soon, integers, and floats in the raw. The actual interface is also unlike your typical character terminal. On the right side of the presentation there, you can see Wireshark showing a breakdown of the IP version of the 5250 protocol. It's actually based on sending updates to positions of the screen and fields, so that the terminal knows where the editable parts are.
34:22
While the user submits back only the parts that changed, it sounds a lot like your HTML web form. This means you don't have ANSI-like fine-grained control, but since the machine can make sense of what's given to it, it's easy to navigate by cursor. The first thing you'll notice about the interface is it's quite menu-based by default.
34:43
For example, we can navigate this way. As you notice, the bottom commands are also all consistent. Things like F3 for exit, F12 for cancel, and F4 for prompt, for example, are also consistent. You can also, if we highlight something on the screen and press F1,
35:05
we'll get context-sensitive help. We can press F12 to exit out of that. We can also mention the command, press F1, and it'll also start explaining commands and some of our options.
35:27
So we hit F3 to exit here. And if we do an F1 here, you'll also notice that the help system is hypertext. If we press enter here when the cursor is there, we can navigate and then we can press F3 to exit.
35:43
The difference between F3 and F12 is that basically F3 exits out of the screen entirely, while F12 will only exit out of one screen. So you see here, I pressed F3 that one time, but here I can just do an F12 and get it over that way. You also notice that each link had a little triangle indicating that it was visited before.
36:06
Next, we can run Work Active Jobs, and that'll show us a little bit more interesting screen. This tends to be sort of what they call a point-and-shoot interface in the mainframe world, and these work with commands pretty much work similarly.
36:21
You get some options here. You can get F1 for an explanation of each option with the little detail view and so on. As well, you can also put in these options here, and you can fast do things like delete multiple files.
36:42
In this case, we'll enter F5 to get to the work with screen, and we'll just hit enter here and kind of cancel out of that. But as you can see there, it could do multiple things at a single time for a little bit more interesting screen. However, you might want to shut down the system,
37:02
but you don't know all the options for it. So what you can do here is you can press F4, and it'll show you an explanation of everything. And the context sensitive help here works too. You press F1 and on option, and it'll explain it for you.
37:21
And as well, you can even F4 again to get more options available. And as you also saw, the vocabulary is also consistent. If we want to work with objects in, say, the Advent 2020, this is TQ's library for his Advent to Code stuff,
37:40
and he's doing COBOL. And the all there is just kind of a special option, almost kind of like an atom, except behind the scenes, it's all handles and strings. See there, we can scroll through, and again, we get the same point-to-shoot interface. We can hit delete here.
38:02
As you can see there, when we enter something that we shouldn't, that is, it's not a marked field, it'll give us an error. We can do this, we can press the reset key in the simulator, control R, and then we can just space over anything we don't want here. So I'm probably not going to delete these things, but as you can see here, if we press enter, it would delete this stuff there.
38:23
But EVA would prompt, I'm going to be a nice person, I'm not going to do that. So that's just kind of a quick overview of what the interface is like on these systems. Part of the appliance nature is that SQL is built in the system, even implemented at the kernel level. Despite that, it's basically built to the same permanence of the rest of the system,
38:43
the same record files that source code is stored in are used for SQL tables. A variety of rich R objects that aren't bags of bytes provide the basis for more complex objects. The interesting part is how you store and work with them. There's no traditional file system in the sense that hot data in the memory becomes cold data on your disk in a separate structure.
39:02
Instead, all objects are stored in a single address space. Each object has an address that persists even on reboot. If a data isn't in RAM, it'll be paged in through page vaults, and committing it basically flushes changes back to disk, kind of like mmap on Unix. The interesting part of this is you can simply work with pointers from other programs,
39:22
like your own, and hold on to them without worrying about them disappearing when the program dies. It changes how you think about buffers, or even the difference between programs and processes. Think of the term orthogonal persistence. How is this even secure? I is probably the most popular example of a capability system in the wild.
39:43
Each pointer is actually 128 bits, 64 bits of metadata, and 64 bits of address space. Outside of the pointer is a tag, which when written to it, invalidates the pointer. Since only trusted code in the kernel can generate the tags, they function effectively as capabilities. The tags are stored in ECC. It uses some unfortunately undocumented PowerPC extensions to actually work.
40:06
Using machine-independent bytecodes is the other part of the security model. Since native programs aren't allowed, well, except outside of the naked syscall emulator, but that's a long story. All programs get compiled to native code by the trusted translator in the kernel. This enforces the security model, like, say, how a JVM would work.
40:24
This even allowed the transition from their custom sys processors to PowerPC, and even allowed them to change the kernel ABI. We're going to show you a demo of some of the behind-the-scenes tools of IBMI. Unfortunately, a lot of this isn't too well documented,
40:40
because it's usually intended for IBM technicians, but we'll show you here. The next thing we're going to take a look at is SST, the system service tools. These provide some low-level insight to what's behind the kernel in IBMI. It's usually intended for technicians, or people have to get information for technicians. So, we'll start it. It has its own separate credentials from the rest of the system,
41:03
because this is probably something you don't want to give people that don't need it. From this one, you can do things like work with disks or VMs, but you might also have common use for. In this case, we're interested in the service tools. And with service tools, you get things like being able to trace the kernel,
41:22
as they call it, like some internal code in IBM-speak. The kernel logs, kind of like a kernel syslog. You need a storage dump manager, if that's what crashes. But we're interested in particular is display ultra dump. This has a bunch of things like special commands, a hex editor, that lets you look anywhere in memory,
41:41
which is really interesting in the system with a single-level store. And then, again, you can also take a look at the structure of objects, which, since this is in the bag of bytes system, wherever, deals with structured objects. This is, again, interesting. So, we'll take a look at display ultra storage.
42:00
The printer is pretty much the same, except it'll just print out to a spool file, or an actual printer, if you have one. We'll take a look at an object, and we'll take a look at a program, which it has some special support for. For a lot of these objects, they can display the actual structure, but in addition to the structure of the program, it can also display this assembly appended to it.
42:23
So, we'll do that. We know the name and context name. As the reason why it's called the context here, it's because libraries are built on lower-level primitives called contexts. And we'll put it in one of the programs that TQ wrote for Advent to Code.
42:40
These are in COBOL, but it doesn't matter. They'll compile to the same bytecode. We'll enter the Advent 2020 library. See there, it found it. That's who wrote it. And if we take a look at disassembled code, it would have the base structure stuff. But in addition, it's also got a disassembly to it. So, a lot of this information,
43:01
you'd pretty much have to work for IBM, or at least know a lot about the system to get a lot of it. But things like hex dumps, the actual base kind of structure, that's all pretty interesting. There's things like your string table, but we're also interested here is the actual disassembly.
43:25
And see there, it looks like a normal PPC disassembly, except there's a bunch of weird instructions, like set tag and TX there. So, as you can tell here, this is probably isn't the kind of PC assembly that you're used to.
43:41
Even if you are used to power PC assembly. But that's pretty interesting. Why don't we take a look at what the actual object looks like. So, I should have probably F12 there instead of F3. But it's nice enough to remember that. And we're going to go into the hex editor. This is capable of making alterations,
44:02
but we probably don't want to do that. Here, we just kind of want to scroll and actually take a look at things. But this assembler has some interesting features, like being able to decode power PC instructions or there. If you enter I there, it can also do things like follow pointers and such.
44:22
But we're kind of done with that. Now, let's take a look at a different kind of object. That's a little bit more interesting. We're going to take a look at the system entry point table. This is just basically a big list of pointers that point to basically the entry points of programs. Nothing too crazy.
44:41
It also has tags in it, which is going to be pretty interesting to see in the hex editor. So what we're going to do here is we're going to look for the spaces kind of object. This case is this object type 19 in hex. This is number 25 in the menu. We'll take a look at the object.
45:00
We'll put in the name here. And it has a special object subtype of C3. We need to know this because it doesn't really know how to deal with it otherwise. So it's found it. And we'll take a look at base structure. It's nothing too crazy here. Again, this would make more sense if you worked for IBM.
45:26
So we'll have 12 here and we'll get into the hex editor. As you can see there, scroll down far enough. This type of T here is for tag. And those are over there, just a bunch of pointers.
45:48
So that's basically SST in a nutshell there. There's more service tools, but this kind of gets you sort of a good idea of what's behind the curtain. What's kind of not really well understood. But it would certainly help if you had to send it to IBM.
46:04
Anyways, that's it for IBM. We'd like to thank you for coming to the end of our vintage computing bullshit you can learn from. But wait, we've got more. That's right. We do have more. In fact, you can try almost everything we've shown you at home.
46:21
We've got some emulators here for genera, enter list. And it is possible to get your hands on Chokanji and run in VMware. That's an exercise up to the reader, but you can probably find if you look around. But unfortunately for IBM, there's no emulator. And if anyone wants to rise up to the challenge, go right ahead.
46:40
We would love to see it. And we also have some additional resources on intro list, BTROD, genera, and IBMI right here. And we also have an IBMI hobbyist discord. We hate discord too, but hey, it brought a bunch of enthusiasts out of the woodwork. So we can't complain. It's also bridge to an IRC channel for the traditionalists like us.
47:01
And that's it everyone. Thanks for your time. Hope you enjoyed watching our presentation. It was a quite fascinating talk. And I see why you called it what we have lost. Because yeah, it's quite a lot that got lost in the progress of the dominance of the PC.
47:24
And yeah, we got some questions actually. And yeah, I would just dive right into them if there is nothing you would like to add. Thank you. Oh, yeah, nice. We got the third one.
47:43
Yeah, okay, nice. So someone in the IRC asked, what does it mean for a computer to be a list machine? So to me, there's two main points. First of all, on a list machine, the instruction set and entire system architecture is built
48:05
around the idea of running lists. And so you had features like garbage collection in microcode that you had hardware management of list arrangement.
48:22
So for example, you could not tell from a user perspective whether a list was stored as just contiguous cells of memory or an actual linked list. Integers were all infinite precision. I think that I mentioned that this caused problems for the C compiler because size of
48:46
care was one and max care was infinity. So the other feature though, which I think is more important is that all of the software
49:03
on the machine is running lists. There's no operating system underneath it written in C or there's no assembly component. It's all just so if you want to replace the drivers for build a driver for some additional hardware that you've attached, you can do that entirely in list.
49:22
There's a tale from one of the symbolic field engineers about the fact that at one point they had a customer with a machine that was running very slowly and they couldn't figure it out. And it turned out that they had installed a patch which replaced a bunch of the drivers on the system and they never compiled that patch.
49:43
And so it was interpreting the driver code. And it was slow, but everything just worked. Yeah, I think that's really the core of it.
50:01
What about interlifts as well? I don't actually know that much about interlifts. You'd have to ask Techfury. Interlifts, it seems, doesn't really do as much in a fancy hardware microcode as genera does. And I think a lot of this is because the hardware it ran on, the D machines, was really mainly meant to run Xerox's Mesa virtual machine.
50:22
And so they kind of just hacked interlifts onto it by coming up with new microcodes. I think they kind of just had to work within the constraints of that. So for the most part, you don't really see things like hardware garbage collection or rather microcode based garbage collection. You do see the basics though, like the fact, you know, like car and cons and such
50:40
are all basically literally mapped directly to opcodes. That's probably the biggest thing I've noticed from digging into the deep machines. Yeah, my impression is it's basically West Coast versus East Coast list machine. It's a biggie in two-pack of computer science. Well put, Calvin, well put.
51:04
All right, I think we have another question. Who still uses the BTRON system and the HTML export functionality seems semi-recent? So to my understanding, it's basically mostly a legacy platform at this point. It, as far as I understand, has a contingent of academia users, mainly humanities,
51:23
who tend to use it because it has better support for, shall we say, old slash deprecated kanji characters. And I think it's just kind of stuck with some of them through inertia mainly. And I believe the HTML export stuff showed up sometime around the turn of the century, give or take, probably when the change over to BTRON3 slash BRYV
51:43
slash chocongy, which would have been about 98, 99, 2000, give or take. So I think it's about when that ended up in there. All right, and it looks like our next question is, what's the most recent advanced or interesting list machine?
52:00
What do you think, TQ? So the cheeky answer is Emacs. Because, yes, there is a C core to it. But all of the interface functionality and all of the interaction is purely Lisp.
52:22
The answer to the question that you were probably asking, though, is that there isn't really an answer. You've got the genera side and the interlisp side don't really share any... They don't share a common ancestor.
52:43
Lisp was very popular in academic and AI communities in the 80s and very early 90s. And so symbolics commercialized the first Lisp machine. But Xerox came along and developed their own starting from scratch
53:03
and came up with interlisp. And the two we've developed in parallel and didn't really cross-pollinate very much. So interlisp is still maintained and it's worth using. And in particular, interlisp can be used without any question about legality,
53:25
because it's all open source now. Yeah, a VLM source is kind of floating around, but the owner of Rites is still unclear. Interlisp is explicitly free software now. And one thing to add, I do find it amusing that both interlisp and genera share
53:40
a not really common ancestor, but a common source platform of the PDP-10. Ah, yes, the Lisp classic, the PDP-10. Ah, the PDP-10 is a beautiful machine. It could give an entire talk on its instruction set. Equal bait. So it looks like our next question.
54:01
Is it really better to run the GC and microcode instead of normal code on an additional core? And that's a really good question, I think. And I honestly wouldn't be surprised if the answer is that no, it's really not. I think that's just what made sense at the time, because you have to remember at the time they were designing all this stuff,
54:20
it was just trendy to do everything in microcode. I mean, look at the Xerox Alto. It basically bit bangs all its IO and microcode tasks. Much like a Cyrix Media GX came back. It's not just that it was trendy. At the time, in order to get decent performance running Lisp, you needed to do it in microcode because machines just weren't very fast.
54:42
We didn't have pipelining. We didn't have the fast memory buses that we do now. But technically you had to buy like a 360 Model 90 or Cray 1 or something like that. Yeah. And there's no way that you could assign one of those to a single person. Nope.
55:00
And the Cray probably wouldn't have been that great of an answer either, because the Cray is really only designed for vector calculations. So as it turns out, one of the big reasons that the Lisp machines died is that Frans Lisp ran fantastically on a VAX. And didn't need any of the special hardware support that the Lisp machines offered.
55:24
Even basically risk processes just put the final nail to coffin. Yeah, and that's why the registered machines really won, was they just got faster. And even, I think I recall reading that for Xerox, Intralisp even, I think by about 87, a Sun3 Model 60, which is a 20 megahertz Motorola 68020,
55:43
was already faster than the D machines, according to Xerox's own studies apparently. I mean, pretty much every rich environment that didn't die got reported to, basically risk or something sufficiently risk by counterfeit. Like, I got rebased on to PowerPC.
56:01
As you know, Intralisp actually sort of got a second life running on Sparks. And Intralisp, and yeah, generic random alphas. But where it don't work, we're living here in the future again. Intralisp still runs on ARM. So I thought this next question was really interesting.
56:21
What extensions would be required to a normal-ish risk design to improve LISP throughput and or latency? I guess it could add like memory tagging, like one IBM has would actually probably work well for LISP. That's a good point.
56:41
Memory tagging would be cool. Yeah, some docs did that. I think the memory tagging extensions for ARM, the ARM are only really good for security, because they're basically more pointer signing, I think. The Spark ones I don't know much about, but I think they're intended for JVM. So yeah, LISP would work. The Spark extensions, as I understand,
57:01
were actually specifically designed for LISP. They give you two additional tag bits for types and arithmetic instructions. I believe that the arithmetic instructions trap if the tag bits aren't the same for two pointers. And so you can pretend that everything's a fixed number.
57:22
And handle it if it's not. Yeah, I guess that sounds like it would work for JVM, but what works for JVM would probably work for LISP. And what's little known about the IBM extensions, all they really do is there's no hardware enforcement.
57:40
Rather, it's just like acceleration for basically software-based checks. So actually, one feature that's surprisingly good, surprising at accelerating LISP code, is I triple E floating point.
58:03
Look into NaN boxing if you haven't, because it is... I've heard about NaN boxing, yeah. Yeah, it turns out that you could store pointers and most types in the unused bits and not a number.
58:21
And they'll trap if you try to add two things that are numbers. Oh my god, NaN singling. Yeah. Oh god, that's cursed, I like it. Right. Yeah, so I'm afraid we'll have to cut it a bit here
58:41
because we're running a bit short in time. No worries. So there are two questions left, and one personal remark.
59:01
Yeah, the first one is if the B1 situation is similar to what happened to OS2's respectively ECOMP station. So I'm not sure if you can really draw an analogy there because ECOMP station is kind of a...
59:22
If I recall correctly, the whole arrangement of ECOMP station is that it's an OEM distribution of OS2, but it's a little bit different with BTRON because BTRON is an open specification that realistically only one vendor really made implementations of personal media. Imagine if basically there's only
59:40
single plastics implementation standing. That's basically it. What he said. So and I think someone asked when are you going to give a talk on the PDP-10? Maybe next year? Oh yeah, hopefully.
01:00:00
I think that was then quite easy to answer. And someone personally remarked that they have a 60 page paper on the Tron in case someone was listening on the IRC. But it's in German. So yeah, if you speak German, maybe this person can,
01:00:26
maybe this person will be, will suit your needs. Also, there was the request from the IRC to the speakers to maybe hang around a bit longer
01:00:40
in the IRC to answer any questions there because we sadly have to end the targets here, time slot. So yeah, thank you. Thank you for taking the time to prepare all this. Thank you for joining us from such remote locations. Thank you for standing up early or late.
01:01:07
Well, it's really early for us, so. Yeah, so thank you very much for that and have a nice remote chaos experience. Thank you. Thank you. Thank you for your talk. Thank you.