Dear viewer, these subtitles were generated by a machine via the service Trint and therefore are (very) buggy. If you are capable, please help us to create good quality subtitles: https://c3subtitles.de/talk/1766 Thanks!
You.
Our next talk will
be by
GQ, Calvin and Tick Theory,
which would have been far
more difficult actually if
we would have met in Leipzig
because
TCU is originally from the US.
Now he lives in Belgium.
Calvin is from Canada.
Antique theory is from the U.S.
So this would be it would have been far
more difficult
to do in person.
TCU
It has been enter into retro computing
for around 20 years,
starting with the tears 80 moving over
two minute computers.
And yeah, he's especially
interested in the features that date
with that market segment.
Calvin, from Canada
started to retro computing
also as an 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
modern iterations of
the systems he started out with
as a hobby and took
Furey
as a daytime shipment
tracking software developer
and a night time
necromancer 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 or Calvin Buckley.
Hi, abase.
My day job, I just basically do a whole
bunch of hacking on IBM.
I spoil it.
We're going to be talking about that, and
neither basically enjoy preserving
software for future generations.
Apparently, there's also this guy called
you.
Hi, I'm Pi Day.
I build distributed.
All right. Oracle distributed trust
system for 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 and house iOS
app, and at night I'm a curator
and I think I see an order of bygone
Japanese and British computer systems,
you know, like any 88s, ACORN,
Archimedes, et cetera.
And with that being said, let's hand off
to Hugh with his
presentation on the symbolic list
machine.
So in the early 80s,
MIT spun off part of its research
group into a firm that produced
less machines
that from Wisconsin ballocks.
They built a machine called the symbolic
study 600 that ran an operating system
called Janiero.
What exactly was this?
Well, obviously based on the name,
it's on this machine.
It's a it's got hardware that runs
less directly.
Everything that ran on the machine was
written in Lisp, from the microcode to
the operating system.
All of the drivers, everything.
Oh, it included
all of your development tools that you'd
expect.
So the editors,
your editor, your compiler, you're the
buggers inspectors to be able to
look at data structures
on LISP.
And it was for a very long time
considered to be one of the best
development environments around.
It ended up dying is sort of ignoble,
Beth, because for a combination
of reasons.
First of all, the company made some
absolutely terrible decisions.
They pointed their platform
to run on New Boss on Macintosh shortly
before Apple switched to
PowerPC and PCI
and PCI.
And then they went from there to
the architecture
of the future alpha.
And then they died.
Well, here to talk about the death of
smallpox, we're here to talk about the
life of.
Let's talk about their first machine.
Thirty six hundred shipped in 1983.
Oh, it had a thirty six bit work
for bits of which were set aside
for Tag, but 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 prices are microcode had
thirty six.
The are microcode heads up
to 16 hard work tasks to be able
to handle things like interfacing with
the desks, driving the display,
scanning the keyboard, accessing the
network, etc..
That microcode also provided a
high level instruction set that had
instructions like courts to allocate
memory in garbage collect if necessary.
All.
It also had your usual compliment
of arithmetic instructions had subtract,
etc. But unlike most architectures,
even modern architectures,
the arithmetic instructions operated
on an arbitrary precision.
Words, even possibly
rational numbers.
At one point, they pointed a C compiler
to it. It just used the native machine
integers. Because why not
add somebody tried to
write a program that?
Determine 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.
So.
Oh.
I could explain the injury.
I could explain the interface,
but it's probably easiest to start with a
demo.
When you start up generic, you're greeted
by a pretty high resolution graphics
display. The original machines ship with
an 11 100 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
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,
las, 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 parameters
are. Ask you looking them up in a man
page. Janeiro, on the other hand,
generic hold your hand a bit more
and prompts you you need to
enter username.
OK, I'll do that.
OK, so what can we do here?
As any Unix user knows,
the first thing that you do in any
terminal, whether or not
or whether you've just changed the
directory or whatever first thing you
do is listen.
This is duals generic
spelled sort of bit differently.
And I'm going to list my home directory,
which hopefully is already selected.
The still looks very much like
a traditional Unix directory listing.
But you'll notice that
as a 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.
Well, I'll type in
show directory.
You'll notice actually, that I just typed
in the first couple characters and it
autocomplete it.
I watch lists, list the list
directory
and I could type it, but it's
already on screen.
I should be able to just click it.
And when I do it, paste it
into the prompt and I can hit after to
accept that just lists lists
the directory itself, which is not quite
ideal.
Wonder what else we can do about this if
you just click it directly,
that actually lists the contents, you
know, notice that.
It actually filled in a command for me.
It says show directory, generic
veal home to the list
star, what has actually
happened here is very subtle.
Each of these two objects that is shown
on screen has a set of handlers
attached to them.
And when I click on them,
it specified 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, but back
to the bottom of the screen here.
You can see I can't actually
point it out, but you can see
that if I press two hours button, it will
execute, show, file.
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 list directory, let's say that I
want to actually show
what is in a file step
in show
file and
to get to these files later.
For now, let's just look at this file one
file to.
Based file one.
And it shows the contents
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.
I have other options, too.
I can open up an
editor.
Winter besides the current window.
Open letter and
set aside so that I can see the window
underneath. This is Emacs, as
you can probably guess from the name,
it's just an Emacs clone.
The C actually stands for Phi,
which stands out, which in turn stands
for PSI.
Was it initially?
And in case you're curious what I
understood for, I know it's not Emacs,
so I'm good. But being in Emacs Club,
you can open a file with control access
control. If we know that we want to look
at each file one
so we can click it, and it opens
earlier when we click File one
and it printed it down below.
If the active window is in is this Emacs
window, though?
We can click another file and
instead of printing it in in
the Lisp listener, it opens
up. This shows that each
window has an input context associated
with it, and the input context controls.
What commands will will be automatically
executed when you select or
interact with some object that's on
screen. Quick to point out one more
feature the command line.
I remember reading that this was
widely seen as the language to implement
advanced ize it, and I decided that
I didn't care to actually write this
talk.
I wanted the system to do it for me,
so it's good at that.
So I made a grant.
And it ActionScript I want to give a talk
on.
I'm giving a talk on generic or now
I could that, and it asks me a couple
more questions.
Do I want to talk about presentations?
Yes.
Do I want to talk about the inspector?
Yeah, might have time.
Let's see.
Oh, what do I want to inspect?
I can click this and type
in a function the results of a little
simulator.
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.
We want to talk about documentation.
Yes.
Cool. Let's do that.
And as it turns out, I didn't actually
have time to make it easy to write the
talk for me, so 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.
I called the exception
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 do.
I am. I am gooey or
any of the many modern, immediate
mode gooey frameworks
put forward.
Interesting things that you saw there
that you should really keep.
Keep in mind that.
The things that you should remember from
that demo are that
John Kerry had a pervasive command
line interface that.
Integrated very, very well
with a graphical interface.
And for 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.
Let's look at an alternative
implementation of the same idea
just from the West Coast.
Land up on the West Coast,
Xerox actually invented its own
surrealist machine, they
originally imported billions less from
the PDP 10 as people
moved over the park from the East Coast.
You, I used to work in Vietnam.
Then they pour it into the Alt-A park
using a bike, a virtual machine
implemented and the Alta microcode.
Then it got ported to the success of the
RD machines, which they call because they
had names. The letter The Dandelion
Dorado DAYBREAK.
So on. So forth.
And since the entry list, the team was
near the small tiger team.
Many of smallpox concepts, like
overlapping windows,
made their way into their lives.
And as happened, a symbolic analyst
was also the victim of the Iowa venture,
and it never really thrived after Xerox
sold it off in 88.
But recently, Xerox is open sourced
it now since the
machines were actually originally meant
to run. Xerox is massive virtual machine,
and they have just hacked into respond to
them. They're more or less just a simple
16 bit microcode stack machine
and not really that different from a lot
70's many computers, just kind
of at workstation form factor,
so they aren't as fast.
There's a lot less fancy features.
You know, none of these fancy tag
pointers. None of that.
But it worked, and it was a lot cheaper
than some bogs.
And eventually a team at Fuji Xerox
actually implements this virtual machine
and see on top of.
And it's actually now open source,
and you can ride on your common x86
arm what-not system.
So they just get off GitHub.
So just like East Coast List Machines,
Analyst USB is also a complete operating
system, again written entirely and list.
However, there's no Emacs for the editor.
It's a little bit different on ENTRO List
analyst aside of text or I'm
sorry, occurred at or works by adding
s expression is directly a memory.
It's not a tax.
It does not touch source files on disk
at all. You just merely edit your
expressions directly in memory and then
just get done, and it automatically
commits the changes in memory.
But it requires a further step to save
them and also ensure LSB provides
T0, which is a rich tax or that was
inspired by the famous Bravo ad or on
the Alto.
And now, let's see, was WASPy
for ourselves.
Let's start analyst B.
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. The engineer, in terms of the
stacks, we have Dragonball.
And resizable windows,
just like Ma windowing systems.
We also have right click context menus.
They've been around a while now know that
this environment looks more or less the
same as it did in the 80s.
They haven't changed a whole whole lot.
So anyway, in the exact meaning we can
pull up our apple.
We have Xerox Common Lisp,
a strict common lisp mode, and we have
entire list. So let's pull up an entire
list for Apple.
All right. So let's customize our
environmental or best backgrounds kind
of planetary styles load.
Star Big Load in a program
called Star Big, 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 Bergkamp's,
and it'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 error.
OnStar becomes.
Now, this is I set it aside, it's a
little interesting, as I mentioned
earlier, this is not a tax
or this area is actually adding
the s expressions directly at memory
and formatting them as code.
So the nice thing about this is that the
we change the size of it.
As you can see, the occur automatically
is formatted to fit the different sizes.
Now, let's look at other functions down
here, see, it's on the function section
again, nurses, I double click on things,
the scope expands.
I thought that was pretty cool.
So see Star B Bee Gees look similar.
So we'll select that, see how it's
underlined. And then we will now click
on the menu bar here.
You can choose Edit.
Functions.
Take a look at that, that's the function
star vs code now.
Let's run it.
And you see a nice little space themed
background.
Now it's all adding.
This is a little bit of a famous demo
here. Sort of you see this
in white and old brochures and why
is the mouse being very laggy today?
Strange.
Famous as the list B logo,
but things changed and things about, so
why aren't we since we know we called
curtail a logo w, the function will do
the f define function also
at its.
Hotel W.
Now we could just simply use some
of the arguments, such as a string,
but let's just hack it.
So we're going to change the Ingelsby.
Hi, are you three?
And we're going to go to the SRT menu.
She's done those 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, RC three.
Now, so, like I say, it doesn't seem
desk, so if we do have files, question
mark.
It nurses that we've made changes to
the coach, our logo W function
and the Carter logo file and if we do
make files.
We've now saved it.
We can also try this and see how this
works of the new fonctionnements idea.
Hello and do a little bit of hello
world function.
It is old school centralist style, so
we're going to use lambda.
So you templates already filled out.
We're going to highlight this argument.
I was going to hit back or delete or I'm
sorry for delete.
And then see how that's cleared out.
And we'll do the same here.
Listen, I taped the closing pair and
it just simply closes, it doesn't insert
anything, I can't just type more.
This is very structured inside or.
You're done.
Now we have our Hello World function, and
if we do files question mark again,
it's going to ask where we would like to
put.
So screaming at me, because
that's a yes or no question, they do a
lot of things like this and also we all
just hit why?
And we'll give you the name hello to
create a new file.
And you can see the changes are marked
in their sorry, create a Halo two
calms.
So people look at that.
He has already built a package with just
the function, hello.
Which is the same hollow as we see there,
as we will see when I pull apart it.
Same thing.
So moving on further from that.
You can also do.
Save it, make files,
and we can also explicitly do that with
make file.
And there's there's a version, no, this
is inherently from Types 20,
which is what they ran the song
originally before they ported to the
machines.
Now she's looking at a document at her
and the file browser, so
we right click on here, we could choose
file browser.
And we're going to give it madly.
Nurses to the greater than symbol for
the path separator.
All right, we're going to take a look
here, table of contents of the list by
users libraries who basically
contributed programs
from users. So we select it
like such there with the left button
going to edit to edit.
Ask us to define our window.
So you take a look at this, this is a
rich taxpayer kind of being a little bit
of a generic document examiners
vibe here, almost, and it's in fact
a complete.
Rich text and I can get the
expanded menu.
Age, lounge stuff.
And also quit it.
What was that window?
And similarly, most of these entries
like, say, Star e.g., we were looking at
just a little bit ago, it's fine that.
Similarly, it has its documentation
available through here.
Similarly, we also have a
language reference manual available
through Danfo, and that too
also appears to be based upon that.
Well, actually close to that.
All right.
See and navigate through the cell
hypertext style.
And we almost forgot about him.
It's pretty cool, Dwayne, is do
or I mean.
And so remember how he told hello
and that has to be in all caps because
this was case sensitive in this regard.
But let's see what happens if they type
it all lowercase.
It suggests for me automatically that
perhaps I met all uppercase
or I could tell it it's wrong.
Undefined function.
And similarly, as you might expect
from a virtual machine, virtual memory,
persistent setup, you can also
simply log out,
it's just got to end to end all caps.
And then that will save the entire world.
And we can pull it back up again, just
exactly where we were.
And that's it for the entire this demo,
and now we will go on to our next and
last platform, I will be demonstrating
today be Tron Japan's attempt
to design their own desktop operating
system from scratch.
But what is being Tron?
It's an outgrowth of the Tron project,
which basically was a Japanese academic
academia industry initiative
to develop a new set of operating systems
and standards for a computerized society
of the 21st century.
They came up with all sorts of standards,
like the Tron keyboard.
They even have CPU architecture.
The end goal of all this is to have
essentially a world in which all of the
objects in your everyday life
would be based on AI Tron embedded
operating systems interlinked
through a network of Tron machines
to be Tron based desktop
computer and so be Tron
is no business Tron.
It has desktop map.
It's meant for personal computers, has a
heavy emphasis on working with documents,
and one implementation of it is still
sold today as a VMware image.
And speaking of these futuristic
systems, it sounds awfully like the
Internet of Things.
I highly recommend watching this Tron
Smart House video I've linked here.
We kind of knew there wasn't enough time,
but you will see that
the Internet of Things is really nothing
new as a concept and that these guys even
thought as far as that Internet of Things
toilet back in the day.
So one of the unique features of Bistrot
is the Trott application database, which
defines real objects and virtual
objects.
Real objects are a type of structured
container file. They can contain any
number of embedded virtual objects or
links to other virtual objects within
other real objects.
The e-tron additionally calls for a
unified document in which
various basic objects can be freely
makes in bed.
For instance, you can actually use an
embedded spreadsheet object as a table
and system updates actually are shipped
as documents.
And speaking of system updates shipped as
documents, we're going to actually show
you how to install one right now
on this demo right now.
All right, so I fired up to
here. Here is the virtual machine
VMware version does not
need any special hardware or anything.
So first, we need to put this into
English. So do that.
We're going to open up our web browser.
It's actually a document plug in.
And get the support page,
finally, choke on the English
kid.
I'll download it.
Let's save it as an archive file.
OK, and then we open it.
I'll drag the document
out.
So now we've created the real object
containing the English patch
and will open it up, it's actually a
variety of virtual objects and sites,
you know, double clicking on them.
It's very hypertext like go to
installation.
If you can see right here, update
is actually a blob within
the document.
So go ahead and go to a system
set up.
Version tab, drag it in here.
Wants us to reboot.
We'll go ahead and do that.
All right. I'll open the document again,
actually, before we do that, we need to
switch language the English.
Another reboot.
OK, now or in English
opens back up again.
And what we can do here is if we
actually here's an even cooler way of
doing this and right click on
here, go to a real object virtual
object network.
You can actually see the structure of
all the.
Virtual objects within this documents
that we see this right here, we can do
copy to tray.
And then coffee from Trey.
Yes, the tray is what they called the
clipboard.
And let's see, also opened up a tax pad,
kind of like a basic document.
All right, so.
How about let's put her English
patch inside this document here,
because you can see it's even been moved
out of there?
Let's see.
Oh.
So kind of a drawing.
Lots of funny little shapes
is in either.
And.
I can save it to a new
real object or the original.
Now we can actually draw it.
Drop it right in here,
which I thought was pretty cool.
So you can also.
You also embed individual objects
from within there.
So those are also embeddable because,
again, it's the same document.
But here is what I thought was really
strange. So open that web browser again.
Let's take this back now.
Now we can save
is a tad file.
I 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
sit here, let's save this first.
If we go to the same real object
is a virtual object network, you'll
actually find that
when we save the web pages, it had file,
it actually preserved.
Every hyperlink for each hyperlink
is actually a virtual object.
I thought that was rather interesting and
fascinating. I had never really seen
anything like that from the system
before.
So that's all for the Tron
demo. Hope you enjoyed.
Hi.
This last system we're going to be
talking about today and actually like
BitTorrent, the only ever one that's
still sold today.
Like many of his contemporaries,
especially in the mainframe world, it
combines an easy to use interface with
then cutting edge computer science
innovations like capability security.
If you haven't heard of Obama, you've
probably heard of his underwear as many
former names and sold to almost
exclusively average non-technical, small
to medium businesses basically designed
to be treated like an appliance.
Ronson IBM's all purposes server line
up for Easter and various kinds of custom
PowerPC, its own even custom architecture
boxes verano emulators
for us, unfortunately, real skill.
Only a few years, hemodialysis
lived almost all his contemporaries and
even ones that have survived on tend to
have the healthiest ecosystem lie.
Despite this illicit work with your
average of small to medium businesses,
he never, ever really know I was the
thing
I was designed to be easy to learn.
It's kind of looks like MVS S.O.S.
Surface of the mainframes.
Best Atari Slippery Hurts Learn
a lot, and I feels like looks similar to
the MVS who file so of rough
edges because they actually had the
luxury of start scratch.
The biggest change it has, all the
commands were consistent.
Everything is a mix of verbs, nouns, the
consistent vocabulary you
can just learn vs and from where you can
guess most commands.
If you don't know if you're giving it to
a command or even the values that pass
into an Arkema to order you see on
screen, you can just press the four key.
They'll bring up a form prompt and where
you can have all the options presented to
you and even explained
it'll usually even generate the actual
command so you can use it.
Both has learned it was the convenience.
If you see something on a screen that
you're sure if you can just press off
one, it'll show context sensitive help
for anything under precursor.
As for heavy air, for prompt works,
because you're not really invoking the
program directly,
instead for commands that provide
lists of arguments or names, types and
other information, in addition to the
actual cost of the program itself.
Interestingly, for values from this get
passed directly to RTV, you can
pair handle pointers, including buffers
passed to your program will come about
soon. Integers and floats
Overall, the actual
interface is also unlike your typical
character terminal on the right side
of the presentation, where you can see
Wireshark showing a breakdown of the IP
version of the 50 protocol.
It's actually based on setting up
dispositions of a screen in fields
of terminal nodes or visible parts of
her, while the
user submits back only for parts that
changed. It sounds a lot like curiosity
about web form.
This means you don't have any like fine
grained control, but since she can make
sense of what's given to it, it's easy to
navigate by by cursor.
The first thing you'll notice about the
interface is the squid menu based by
default.
For example, we can navigate this way
as he knows the bottom commands are also
consistent things like every
four exit F12 for cancer.
Enough for prompt, for example, are also
consistent.
You can also,
if we highlight something on the screen
and press F1, we'll get context
sensitive help.
We can press 12 to exit the fat.
We can also mention the command.
Press of one is also start explaining
commands and some of your options.
So we had a free text here.
If we do enough one here, he also knows
that the help system was hypertext
free press. Enter here when cursors,
they're fair.
We can navigate and we press a free to
exit.
The difference between a free and F12 is
that basically our free exit service
screen, the entire F12 will
only exit of one screen.
So you see here, I press to free that one
time, but here I can just do
an F12 in
that way. It also does that each link
had the little triangle indicating that
was visited before.
Next, we can run more
character jobs and show
a little bit more interesting screen.
This tends to be sort of a what they call
a point and shoot interface and the
mainframe world ITV's work with
commands pretty much work similarly.
You get some options here.
You can get that one for an explanation.
Of each option with the full
detail view and so on
as well, you can also put in these
options here and you can do
things like the leader multiple files.
This case will enter five to get to work
with screen.
And we'll just say that you're hearing
kind of cancel about these, you can see
there it could do multiple
things at a single time
for a little bit more interesting screen.
However you might, you might want to
shut down the system, but you don't know
all the options for it.
So what you can do here is you can press
for it will show you in
an explanation of everything in
context sensitive help here works to
you. Press F1 and hopes it will
explain it for you
in this. Well, you can even that for
again to get more options available.
And as he's also off, the vocabulary is
also consistent if we want to work with
objects in, say, the Advent
2020, this is to use
library for us that code stuff historian
COBOL in the hall.
There is just kind of a special option,
almost kind kind of like it had them,
except a behind the scenes
for handles and strings
scenes where we can scroll through and
again we get the same point to shoot
interface.
We can hit delete here.
It is in severe when we enter something
where we shouldn't.
That is, it's not a marked field.
It'll give us an air.
We can do it so we can press, reset the
simulator, control our
space over anything we don't want here.
So I'm not I'm not going to believe these
things. But as you see here, if we press
enter, it would delete this stuff there.
But if I would prompt that can
be a nice person and not going to do
that.
So this is kind of a quick overview of
what the interface is like on these
systems, Pravi
Appliance Nature said.
You will spot of a system even
implemented have a kernel level.
Despite that, it's basically built on the
same premise of rest of a system, the
same record files. That source code is
stored and they're used for school
tables.
A variety of rich objects that aren't
bags. The provides the basis for more
complex objects purchasing
power. That's how you stored work of
Fresno Traditional File System in the
sense that high dose of memory becomes
called data on your desk.
Since a separate structure
said all objects are stored in a single
address space.
Each object has an address that persists
even on reboot.
If it isn't in RAM, it'll be patched
in for page vaults.
Examining it basically flushes changes
back to this kind of like IMAP on Unix.
The interesting part of this is he can
simply work with pointers from other
programs like corrode and hold onto them
without worrying about them disappearing
with the program buys.
It changes how you think about buffers or
even the difference between programs and
processes.
Think of the term or functional
persistence.
How is this even secure?
It's probably the most popular example of
the capability system in the wild.
Each pointer is actually 128 bits,
64 bits of metadata, 64 bits
of address space, etc.
pointers the tag, which, when written to
invalid, is a pointer.
Since only trusted code kernel can
generate the tags, they function
effectively as capabilities.
The tags are stored in SCC
is the sum, unfortunately, in documented
PowerPC extensions to actually work
using machine independent because the
other part of security model since native
programs aren't allowed will accept
outside of an exascale emulator.
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.
It's even allowed the transition from a
custom cis processors to PowerPC,
and even the of the teams are currently
by.
We're going to show you a demo of some of
the behind the scenes tools of IBM.
Unfortunately, a lot of this isn't too
well documented 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 this assistive a system service tools.
These provide some low level insight to
what's behind the current IBM AI.
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 and
Presto system 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 discs or free, but you
might also have common use for
this case. We're interested in the
service tools and the service
tools, so you get things like being able
to trace the kernel as they call
it Internal Code and IBM speak.
The kernel logs kind of like a kernel
syslog means storage that manager
Vatsa crashes.
But we're interested in particular, is
display ultra dump.
This has a bunch of things
like special commands, a
hex editor, bouncy look anywhere
in memory, which is really interesting in
the system with a single level store.
And then again, it can also take a look
at some the structure of objects,
which since this is in the bag of bytes
system forever feels sort of structured
objects.
It's again interesting.
So we'll take a look display in ultra
storage.
Some two printers pretty much the same,
except they'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 approach, which
has some special support for for
a lot of these objects display for the
actual structure, but in addition to the
structure of program, can also display
this assembly appended to it.
So we'll do that.
We know of a name and context name,
as Frizzle has called the context here,
because libraries are built on lower
level primitives called contexts,
and we'll put
in one of the programs that he wrote for
added into code.
These are in COBOL, but it doesn't matter
if they'll compile to the same bytecode
we'll interview at the 2020 library.
Steve, I found it.
Let's see. Wrote it.
And if we take a look of this, a simple
code, it would have a base structure
stuff.
But in addition, it's also got.
The disassembly to it, so a lot of this
information, you would pretty much have
to work for IBM or
least know a lot of the system
to get a lot of it.
But things like hack dumps
to the actual best
kind of structure.
That's all pretty interesting.
It seems like a string table, but we're
also interested here is
the actual disassembly
in severe it looks like a normal
PVC disassembly, except for suspension
weird instructions like set tag and
texture.
So is the intel here?
This probably isn't for purposes some
believe it used to.
Even if you are used to power U.S.
assembly.
But that's pretty interesting.
When we take a look at what the actual
object looks like.
So I should probably have welfare instead
of a freed.
But it's nice enough to remember that.
And we're going to go into the exit or
this is capable of making alterations,
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 assembly has some interesting
features, like being able to decode
PowerPC instructions server
if you enter either.
It can also do things like follow
pointers and such, but
we're kind of done with that.
Now let's take a look at the different
kinds of object.
That's a little bit more interesting.
We're going to take a look of a system
entry point table.
This is just basically a big list of
pointers that point to basically
be entry points of programs.
Nothing too crazy, but it also
has tags in it, which
is going to be pretty interesting to see
in Exeter.
So we're going to do here is we're going
to look for a space kind of object
in this case is this object type 19
and Hex Number 25.
Menu.
We'll take a look at the object
we'll put in the name here,
and it has a special object subtype
of C free.
We need to know this because it doesn't
really not deal with that voice,
so it's found it.
And we'll take a look at base structure.
It's nothing too crazy
here. Again, this is make more sense
if you worked for IBM.
So we'll have 12 here,
and we'll get into Brexit or
see severe scroll
down far enough.
But the key here is for tag
and those over there, just the bucket
bunch of pointers.
So that's basically assessed in a
nutshell, there is more service tools,
but this kind of gets the to because idea
of what's behind the curtain.
Let's kind of not really well understood,
but it would certainly help if you had
the sense IBM
it was. That's it for IBM.
I would like to thank you for
coming to the end of our offices.
Competing bullshit you can learn from.
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.
We've got some emulators here for to
Naira intro list.
And it is possible to get your hands on
show cards and then VMware.
That's an exercise to the reader, but
you can probably find if you look around.
But unfortunately for IBM AI,
there's no emulator, and if anyone wants
to rise up to the challenge, go right
ahead. We would love to see it.
And we also have some additional
resources on interest, be Atron
Junior at IBM AI right here,
and we also have an IBM AI hobbyist
discord. We hate this for too.
But Hey brought a bunch of enthusiasts
out of the woodwork, so we can't
complain. It's also a bridge to an Irish
channel for the traditionalists like us.
And that's it, everyone.
Thanks for your time.
Hope you enjoy 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.
And yeah, we got to we
got some questions, actually.
And I would just dove
right into them if.
There is nothing you would like to add.
Do you? Oh, yeah.
Last week, we got the
third one.
Yeah. OK. Nice.
So someone in DRC
asked, What does it mean for
a computer to be a machine?
So it's
really to me, there's a couple of
there's two main points.
First of all, on
this machine, the instruction set and
the entire system architecture is
built around the idea of running less.
And so.
You had features like garbage collection
in microcode that.
Oh, you had.
Are you had hardware management of
this arrangement or list arrangement?
So for example,
you could not tell from a
user perspective whether it list was
stored as just contiguous
cells of memory or an actual
linked list of.
Integers were all infinite
precision. I think that I mentioned to
a.
That this caused problems for the C
compiler, because size of Kerr was
one and Max Kerr was
infinity.
So.
Oh.
The other feature, though, which I think
is more important, is that
all of the software on the machine is
running list. There's no operating system
underneath it written and see there's
or there's no assembly component
component.
It's all just so if you want to
replace the drivers or build
a driver for some additional hardware
that you've attached, you can do that
entirely unless
there's a tail from
one of these 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
turned out that they had to install
a patch which replaced a bunch
of the drivers on the system.
And they never compiled that patch.
And so it was interpreting the driver
code.
And it was slow,
but everything just was operated on.
I mean, I think that's really the core of
it. Words.
I.
What about the initial as well?
I don't actually know that much about
India. You'd have to ask Dr.
Centralist, it seems, doesn't really do
as much in fancy hardware
or microcode as Genaro does.
And I think a lot of this is because the
hardware around the machines was really
mainly meant to run Xerox as
a virtual machine.
And so they kind of just hacked into onto
it by coming up with new micro codes.
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
car and cons and such are all basically
literally directly to barcodes.
That's probably the biggest thing I've
noticed from digging into the machines.
Yeah, my impression is it's basically
West Coasters as this list machine.
It's the beginning to pack of computer
science.
Well, Paul Galvin, well put.
All right. I think we have another
question who still uses
the veteran 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, 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 changeover to be
Tron three Flash Bright v
flash tokens, which were been about 98
99, 2000 give or take.
So I think it's about one 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? What do you think you?
So the cheeky answer is Emacs.
Oh,
because it?
Yes, there is a sea core to it, but.
All of the interface, functionality
and all of the interaction
is purely lisp.
The answer to the question that you
probably asking, though, is
that there
isn't really an answer.
You've got the
de Janeiro side and the interest
side who don't really share
any.
They don't share a common ancestor.
Oh, this was very
popular in academic
and I communities in the eighties
and very early 90s
and so symbolic,
commercialized.
The first list machine, but
Xerox came along and developed
their own starting from scratch
and came up with it or less.
And the two were developed in parallel
and didn't really cross-pollinate very
much so
into Lisp is still maintained
and it's worth.
Using and in particular, interlaced
can be used
without any question about legality
because it's all open now.
Yeah, yeah,
a violence source. This kind of floating
around an area for ice is still unclear
if as explicitly free software
now.
And into one thing to add, I do find
it amusing that both centralized
engineers shirk that really common
ancestor by that common sort of source
platform of the PDP Ted.
Yes, the list classic, the PDP 10,
the PDP 10. It's a beautiful machine.
Give an entire talk on its construction
site, right?
Eight.
So it looks like our next question.
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 won'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, it was just
trendy to do everything in.
I mean, look at the Xerox, all of it.
Basically Bit brings all its i o and
microcode tasks
by psychotherapies X
came back. It's not.
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, right?
We didn't have pipe lining.
We didn't have the fast memory
busses that we do now.
But thankfully they have that you had to
buy like
every 60 90 or create
one or something like that.
Yeah.
And there's no way that you can assign
one of those to a single person.
No. And the cray probably won't have been
that great of an answer, either, because
the craze really only designed for vector
calculations.
Exactly.
So.
As it turns out, one of the big reasons
that the machines died is that Francis
ran fantastically on the backs
and tip.
Pulled over and
didn't need any of the special hardware
support, the machines offered
event event basically risk processes
just to nail the coffin.
Yeah, and that's why the register
machines really won was they just got
faster.
And even I think I recall reading that
for Xerox and for less even,
I think by about eighty seven,
the Sun three Model 60, which is a 20
megahertz Motorola six 20,
was already faster than the machines,
according to Xerox, is on.
I mean, this is apparently
a napkin match. Every rich environment
that I got reported basically
risk or something sufficiently
like that.
I get that based on the PowerPC
I have, as you know, entire list actually
sort of got a second life
running on specs.
And an engineer in
ran an office.
But where he lived, don't worry, we're
living here in future again.
It's your grandson.
I'm.
So I thought this next question was
really interesting, what extensions would
be required to a normal ish risk
designed to improve list throughput and
or latency?
Huh.
I guess he could. Right.
I guess you could add like memory taking
like a one IBM
house would actually probably work well
for Lisp.
That's a good point.
Memory tagging would be cool.
Point to that,
I think by tagging, I think the memory
tagging extension service, the
army really, really good for security
because they're basically like, you're
signing, I think the right
ones they don't know much about, but I
think they're intended to. Even so, yeah,
this would work.
The Spark construction set or the spark
extension, as I understand, were actually
specifically designed for list.
They give you two additional type.
It's four types and arithmetic
instructions.
Well, I I
believe that the arithmetic instructions
trap if the tag bits
aren't the same for two pointers.
And so you can just do this.
You can pretend that everything's fixed
and.
Handle it, if it's not.
Yeah, if
that sounds like it, work for Xavien, but
what works for him would probably work
for a less.
How?
Yeah.
And what's little known about the IBM
extensions, all we really do is
there's no hardware enforcement is just
like acceleration for
basically software based checks.
So actually one features that
are.
Surprisingly good, it
is surprising at accelerating
less. This code is.
Floating eye, Tripoli floating point.
Oh, look into Nan
Boxing if you haven't, because it is
of, turns out, man boxing.
Yeah, yeah, it turns out that you could
store pointers and
most types in the
unused bits in a number,
and
they'll trap if you try to add to things
that are numbers.
Oh my God. And singling.
Dangerous.
Oh, God.
It's. I like it, right?
Yes, yes.
So I'm afraid we'll
have to cut
it a bit here because
we're running a bit short on time.
No worries.
Um, so
there are
two questions left.
And one personal remark.
Yeah, the one the first one
is if the beach
one such situation
is similar to what happened to us
two, respectively,
station.
So I'm not sure if you can really draw
an analogy there, because AECOM Station
is kind of a recall correctly,
the whole arrangement of AECOM stations
that they OEM distribution
of us to.
But it's a little bit different with the
e-tron, because the e-tron is an open
specification that realistically
only one vendor really bad
implementations of Postmedia.
Imagine if basically there's only single
plastics implementation standing.
That's basically 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.
That's I think that was then quite
easy to answer.
And someone personally remarked
that they
have a 60 page
paper on the on the Tron
in case in case someone
was listening on the IOC.
Um, but it's in German.
So yeah, if
you still read it, maybe this person
can.
Oh.
Maybe this person will be
with suit your needs.
Also, there was the request
from the IOC to come
to the speakers to maybe hang around
a bit longer in the IOC too.
But to answer any air, where is
there because we sadly
have to and the targets your timeslot?
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
for our late
pass 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.
Thank you.
All.