So we are starting now with a small panelist discussion, so as I mentioned at the beginning
of the session, but not everyone was there, so we had normally a talk by Mark Mayer, but
unfortunately he's sick, he could not join, so we just hope that he recovers very soon,
and then we have a small discussion with some panelists, not all of them, it's impossible
to invite 15 person, especially that we have only one microphone, I didn't know that also in advance.
So I just introduced the topic, and then we can pass the mic and people can express, let's say,
the opinion, so one of the first things that comes to my mind, and it's a bit follow up
of what the metry has been presenting, so when I see what's being done today,
in vitro computing, there's a hardware part, software part, I would suggest that we start with the hardware,
so it's a little bit, what I see very much is that either there are new systems or new
new boards being built to adapt existing like old miles or old joystick to make them work with
modern computer, or we see the opposite as well, we see like adapters from USB to have the
the PlayStation controller being able to work on a Commodore 64 or something else, Atari,
these are the kind of things also adapters for the video display, for example, so we see
new boards being created, sometimes it's this little, like ESP or whatever, or Raspberry PICO,
PICO or something like that. Maybe one reflection is that something that you see as well,
secondly, do you see something that that is missing so far that that could have been done,
but that has not been done yet, and that would be like a nice challenge.
So I suggest that I just pass to you and then we go to the full line.
Yeah, I mean, I want to add to that that it's not only about the I only devices, but also about
the computers, so building new extension hardware for old computers is also something that is
very popular, I think, there is this preservation aspect of it, and some people like the
preservation more than they like extending existing systems with modern stuff and think of that as
being not true to the history of things and others do other stuff, so I like, I like these like
cross, cross centuries systems, but others try to find all the original parts and all of that is good,
I think, I mean, it's part of history preservation project if you are.
Yeah, I will say, these two directions, two opposite directions you have mentioned,
probably have, well, when you add a modern IO devices or something similar to an old computer,
it's, you know, a way to get work with it with despite some apps and parts, so it's a sort
of digital prosthetics, maybe. And it's definitely important and very practical task,
because, well, sometimes some devices, I audio devices, were so indruble that
impossible to find them, especially in an operational state. The opposite task is, yes, it's mostly
a preserving of a digital heritage, and while you can run software like operating systems or similar
stuff in emulators on modern computer, because you may have a problem to feed these IBM mainframe
in your home, even if you find it, but the emulator can, but, you know, the user experience,
sometimes demands, sometimes it's different when you use modern pointing device, well,
I'm speaking about mice, as you may guess, so you can preserve running software, but the
user experience will be a little bit different, because, well, you can simulate a display,
but how to simulate input hardware, okay, it presses good keyboard on screen, it's definitely
better than anything, but from the ergonomics point of view, it still leaves place for questions.
So connecting all peripheral devices to modern computer and to simulators, I would say,
play this important role of preserving the user experience.
Yeah, you may not emulate us, I think that it's also a very important
area of which we're computing, because there are many systems that are so rare nowadays,
that you can't have one, so in order to experience the system emulation is your only way,
and there are actually still a lot of systems that can be emulated today.
I will be describing one of them today in my presentation, so I would say it's important,
because otherwise, it's just not possible to use this machine at all and it gets to be forgotten.
Yeah, we are basically dealing with a very old machine from the 60s, and it's a mine frame.
Some components are literally unusable, because they're full of little mud,
little mud, because they were stored for decades in the wrong place, so it's impossible to
recover them. In some cases, we also had the problem that we can restore most of it, but the
mechanical parts are so delicate that we don't want to use that, so we just replace that with a
microcontroller that does the same thing, but we try to keep it as visually close as the original,
and you'll see more about this in our talk, but sometimes it's also me and my old PSX controller,
I love, and I have that for 20 years, and I just want to use it on my Xbox Cloud gaming machine,
and I just made a converter to USB, that's this big, and I have open source, so it's maybe
replaced the PSX one. It's actually very easy to make an embedded device that converts an old bus
to a USB modern device, so you can even restore, I don't know, your old steering wheel,
I added to reproduce the same experience you had as a teenager or something, and you want to add
something. For me, it's extremely important, the discussions about emulators, because for me,
emulators are not a way to reproduce the original experience of using certain machines,
mostly because you don't want the original experience of running machines, you don't want
two rooms full of iron, just to have half a mega of computing power. For me,
what's most important is that emulators are running documentation, which means that you know
that the documentation you have is correct, and you can probe it, you can compare it to the original
hardware, if you're so lucky to have it, so yeah, it's a very important thing, so even for a
younger people, like in the programming scene, that they are this kind of factions between,
you know, or real emulator, or real if GA is, I should have used the main,
doesn't matter, that's not the thing, the thing is that we have that, we have the machine description,
we can recreate it, so we have the FPGA, we have the emulator, we can, and also something very
important is like, don't be ashamed or don't be scared to mix and match the technologies,
centuries, and whatever, my personal, let's say religion, fixed point is that your modifications
should, in my opinion, should be irreversible, some people don't agree to that, but yeah,
like interface, the old machines to the new one, the gods of your computing will not be against you
for that, actually quite the opposite, you will breathe new life into new machines, and that's very
important. Thank you. So the problem with being last is everything's been said, so
so I'm going to have to rely on false personality and jokes, well that's certainly not going to work,
so my thing with the IO thing is not limiting it to pieces of what I would call simple hardware,
mice, I can power to be simple hardware, potentially omiters, yeah, I understand them,
their specs are out there, but there's also IO that talks to things like processes,
back in the good old days, when I was actually young, don't laugh at that one, I'll tell you
when I'm doing the funnies, back when I was young, BBC Micro had a tube port that would allow you
to put other processes to connect to your BBC. That's fine, you can emulate that stuff and that
works, but then fast forward another 20 years, and you can't do it anymore, because you can't do it,
any IO to the processor, because someone's put some gunk in there that says, oh, unless you're
running on the hardware, you can't work out what's going on, Northbridge, Southbridge, Xbox,
chips, they have special things in, we're not going to be able to ever emulate them until we
crack what's going on under the hood. So the IO from the olden days, versus what we're going to have
as a problem coming up in 20 years, are different problems, and it's solvable to say, yeah,
I can see a transistor, I know how that works, but you get a chip from 20 years ago, you can't,
most people can't just take the top off, scan the silicon inside and work out how to emulate that
or provide any sort of modern version of it. Thank you. I don't know if you wanted to
ask something. Okay, like Steve and I said, probably everything has been said already,
being last so that's why I will switch to software, and I think Michal, you're the first
emulated, actually, the, sorry, who mentioned the emulation, emulation part,
think when we look about software, again, I also mentioned at the beginning of the session that
there is mostly game, new games that are still being released, operating system, all these,
most probably would not happen if we would not have, like, modern emulation today, because people
are not working anymore or not that much, and I don't think that many people are still working,
we don't the real old hardware, hardware, they're working on emulated, emulated systems.
So there may be same kind of reflection, we can go quickly, we still have, like, seven minutes,
around the room, you want to sound off? Ah, yes, okay, okay, yeah, just about emulation,
our things, still missing, or yeah, a bit to your perception on this topic.
So the point will be, be going first,
if you're going to find something really quick to say, when everyone's looking at you,
I've written a few emulators, and they're really quite good fun to do up to a point.
The problem is after you get to the point where the first thing works, like, the basic pump
comes up from the ROM, it's like, how do I prove it works? How do I know that this ROM is emulated
correctly for everything that will ever run on it? And it's one of those problems of,
it's very easy to get bored with it, it's very easy to get frustrated with it, and unless you're doing
a full spoiler simulation rather than emulation of a platform with all the timing,
idios and crassities that the original had that your software emulator might not have,
how are we ever going to know that we have actually preserved the thing we were trying to preserve
in our software emulator simulation?
Yeah, like, I have as well only a small thing to add to this is that you can also not care, in the sense
that adding an emulator, that only emulates five instructions out of 10, it's good than having
no emulators, and adding an emulator that like, implement 35 instructions, but in three instructions,
like the fifth cycle is slightly wrong, yeah, we can find it later, like as soon as we have
something to start to can jump off of everything should be fine, and so it's a complicated task,
it's a very involved task, it's very time consuming and a brain power consuming, but also
nobody's forcing you to go to completion, this is a hobby for some foremost, at least for now,
so enjoy it, because it's great to be part of history and to be in connection with this story,
also because it can not have new a lot more of what's going on right now.
So yeah, it's great that you're ready to question about the difference between simulators and emulators,
it's also perfectly okay to read the simulator if your purpose is not using what the machine
was doing, but for instance, verify that the software you've dumped from a very old media
is doing what's supposed to do, so and you know, you can double check that, but of course an emulator
gets closer to what the machine was doing and that's a right approach for instance to verify
that the machine that you restoring is doing what it's doing, and the gap between there is documentation,
how much the documentation you can find, we were so lucky to have a machine from the
60s as you will see, but with a lot of documentation with it, so we could start attacking the
problem from both sides, and one thing is restoring the hardware, as you said, the beginning,
and the thing is restoring the software, and those things go in parallel, and of course the software
until the machine is done is probably taking us a few years, so in the meanwhile, we want to be able
to verify the software that we dumped, it's corresponding to what it was supposed to do.
I think it's also worth mentioning hardware emulation, so today you have several FPGA platforms
that can reprogram to recreate a machine very close to the original hardware, so this is maybe a
closer to what you said, trying to get the original hardware XPS and not just a window in the computer,
and I think that's also an interesting area here.
Well, if speaking about emulators and simulators, I would mention that starting from some years,
we have got official SDKs with emulator included for some old platform or something like this,
and it's not obviously true for 60s, but somewhere in 80s, when these software development
kit with emulators do appear, it became a little bit easier to preserve. You just use nested
virtualization to run this simulator in some virtual machine, which itself may sit inside of
some virtual machine. Unfortunately, the difference in all resources, computational resources
helps to drive this without much pain. Obviously, that's not true for, well, prep 80s systems,
maybe a present is for sure, so I would say that the biggest challenge here is
yeah, to run something which was invented before virtualization exists in heads of some engineers,
late days just in all, and it's a task sometimes.
To me, it is quite fascinating that for a single person, it is now possible to
with the modern tooling to recreate software simulators or emulators of systems that have been
created by dozens or hundreds of engineers, and that really is also speaking to the progress that we've
made, so of course, fundamentally there is not a big difference between these old systems
and what we have today. There's quite some architectural similarities in how they work,
but from the perspective of how much of that we can now move with the tooling that we have,
that's really fascinating to me, so my recreation of a system that
had dozens and hundreds of people working on that. I mean, it's not complete, but still,
it's just the tools that made me do it, not something else.
It thinks that would be the final words because we are done reaching the time, so many things
I have Hans Dimitri, Michal, Daniele, Antonio, and Steven. Steven, you're staying?
I mean, it feels what now, so many things again to all.