All right. Let's get started. My name is Hans. I'm a programmer, a hotber tanker, if you will,
and the retro computing enthusiast. And recently, someone gave me this beautiful 1980s
Rafi terminal, which is a lithium-text terminal. It didn't have a keyboard, but the alternative
would have been scrappy art, so I kind of saved it from that. And motivated by having that,
I came up with a plan on the idea to recreate the whole built-in text experience using the
web browser, if you will. So what is built-in text? Many of you will not know. It is kind of a public
data system, a predecessor of the internet, which was launched in Germany in 1983. It was run by the
German, or the predecessor of German telecom called Dr. Bundespost. And back then, everything was totally
regulated. So of course, you had to have a permission to connect your software to the public network.
So everything was very tightly controlled. He also didn't really own the decoder, the modem hardware
that you used to enter the system. It was rented by the state to you. The modem even included the
user ID that you would use in the video text system. It was meant for like normal people,
sitting on their couches, browsing information, booking, travel, maybe buying stuff online,
and also sending messages. So it was kind of a end-user system. And just to set the stage where we
are in history, I mean, we are like at the beginning of the home computer illusion. So there was
Apple II IBM, C64 that was kind of what we had at that point in time. So I mean, it wasn't without
predecessor. So some of you may know plateau, but there was also computer in the U.S. which was
kind of a similar system, not state run, but similar. And Richard text directly is directly related
to Prestler, which is a UK system, a similar kind of technical nature. So your terminal, as I said,
was the TV, that time the TV was the only screen in your home typically. So you wouldn't have
normally have a computer, and then we have a telephone, of course, the symbolizing the phone line
and the remote control would be your input. And then you would rent this beautiful little modem
from the Deutsche Bundespost, which could do 1200 to 75 pods. So it would receive at 1200
and send at 75, the idea being that you would really just be a consumer and not a producer of
content. So you didn't need a big upstream 1200 was pretty slow. 75 really was just for typing
and stuff. And then the server side of things was based on mainframe technology. It is
difficult at this point in time to figure out what exactly constituted the the built-in text
system. So this is a similar vintage, Z-Men's mainframe. Some say the software was written
in the UK and then ported to to Z-Men's machines, others say, well, it was all home-grown.
Actually, we don't really know. So my plan is to reproduce all of that. So instead of this,
of course we have a web browser, we have a web socket for this, and we have some software written
in common list for that. So my first step, and I mentioned it briefly, was I needed to recreate
the keyboard. And this was really, I didn't have a keyboard at first, so I found someone who could
borrow me one. And what you see here is a creator's keyboard, which is for people who create
pigeon text pages. So it has a special keys, for example, for selecting a color of selecting a
character set. It also has this neat little cheat sheet that tells you what graphic characters
are on what letters here, and so on and forth. So a typical and user terminal would be much smaller,
but this is really the full thing. So what I did is I wrote an XML description of this keyboard.
I mean, you know, Jason, so XML is pretty similar, if you don't know it. And then,
and then I went full XML. So XSLT is my favorite programming language, I would say.
I mean, it's really good. It's really good, not just because it serves this purpose well,
but also because it is really homo-economic, which is something that the list guys always tell you
well, it's homo-economic, but it's not true, because they don't use this as the surface syntax
and XSLT does. So we can, and this is why this program, this is a part of an XSLT program,
is XML, because it follows all the rules of XML. And, well, this is really just the header,
and a new feature in XSLT is accumulators that allow you to stream without really relating to
using mutation for that. So what I did is I met from this description file that I showed in the
beginning, which has a key entry for like the lock on the top left and the key codes and something
like spaces here to rules that match these elements. Like here, we have a space with a
has built busy let attribute this one, and that would create this piece of SVG. And likewise,
we have a key with an LED. I would create that, that piece of SVG code. And, well, of course,
you can, you can access variables or attributes from your input elements and the accumulators
that are defined here. So it's a very good mapping language, and I can recommend it to everybody.
And that's how it looks like. So this is the SVG that at this piece of art creates.
The next thing that I needed to do was to extract the font from the terminal, because, of course,
they have fancy special characters, and I wanted the emulation of that to be as faithful as possible.
I pondered whether I wanted to look at the ROMs and then try to decode how the characters
are represented in the ROM, but then went for this very straightforward scan converter, HMI,
USB solution so that I have an image of my character set like this, and then write a bit of,
well, this is actually the code that generates these pages. And then, well, then what?
So I kind of thought it shouldn't be too hard to make this into individual images for each
character for each glyph, but I didn't really know how, so I asked chatchipiti.
You know, I asked it, and it's suggested I need to do this, yes, okay,
but how can I somehow avoid dealing with the details of that, and it's suggested this
kind of specialized font creating programs. I said, well, there was gimp on the bottom, so I tried
gimp, I cannot use it, I don't know why, I just don't manage to, and then I asked it to,
to write me a script, to help me do that. And it was really, I mean, all of you know,
that is kind of scary, and fascinating to work with LLMs. This was scary, and fascinating,
because I told it, well, what me through the script, and then there was a dialogue of how,
what I wanted to do, I wanted a grid, so that I can select my glyphs, and then write that to files.
And it created something for me, which I tuned a little bit, so like parameters here and there,
and make this happen, but as you can see, I have these lines here, and then I can just close the
window and it saves all the other things to individual files that was just a fun experience.
So, Act 3, the emulator, the actual, like, display of the data stream on the channel screen.
And that was, I mean, this specification, I wanted to carry it here, I couldn't because it's to heavy,
it's a book that specifies how the encoding for this channel works, and most of you are many of
you will know ANSI terminals or other terminals, so you have control codes, and you can position your
cursor. This is on a different level of crazy. The craziness is not just that it is very,
like, a detailed oriented, and you need to save all the bits, and you don't have a lot of bandwidth,
so you need to be very, very efficient with you, and coding it is also from the perspective of
the language that they use, it is really annoying, because with your standard computer knowledge,
it is difficult to understand. The LSet is involved in two columns two to seven of the eight
bit code, yes, well, everything is in pages and columns and rows, it's really, I think it's
madness. So, yes, but it is, in the end, it is just straightforward, if then, if then, if then,
case, case, case, case, case, case, and then a little bit of drawing, and a little bit of copying,
and that was just, I mean, that was not difficult, and the kind of striking thing for me was,
I didn't really need to optimize anything, the browser is, or the V8 engine, or the browser's
JavaScript engine is so fast that I can just take my bits and put them there, color them, and it's
done. So, actually, I have a good subset of the standard implemented, so this is really, of course,
something that you need to implement the user-defined characters, where you can say, okay,
this character has these bits and that, and this is, well, one of the pages that I have. Now,
at four, the mainframe side of things, I happen to know one of the people that
that author these pages, the CCC pages back in the 80s, so I had these Victor,
serious disks, which are difficult to read, but I managed, and I found the form of specification
for the files that are used to upload files to the central system. So, what I did is I took that
specification, I copied and pasted those definitions into a text file, then wrote a little bit of
communist code to parse that text file into field definition instances, and then this becomes a
macro defined BTL class, BTL is this upload format that defines a class based on the file that we read here,
and also an initializer that receives an input buffer with the data, and that sets all the fields
to the respective data values, with the goal that, or, and so this is, of course, this, some of
you know come in those who don't, here's some pattern matching and come in on the code level,
so generic functions can specialize on any of the arguments, so I'm specializing on the second argument
here, and if that is a, a symbol called bin, then this code is executed, if, if that second argument
is the symbol bit, then this will be called, so bit manipulation and all kind of all kind of
crazy stuff, so with the result that now in my code that parses the file, I can use these identifiers,
which are directly from the documentation, and I, I happen to like that, so I can look at the
documentation, okay, this field means that, and then kind of, kind of write some code to to do that,
so a little bit of a demo, I hope this, the demo gods are in my favor, but it doesn't look too bad,
so I'm, I'm going to reload the page, if I can, so I'm going to reload the page, and you will notice
that there is a little bit of a time gap here, so this is displayed, and then the whole
pages displayed, this is because the page is assembled from components, and one of the things that
you had to do as a content creator is create these components, like pages that are referenced,
so that the user defined characters would be loaded only once, and then you, then you loaded the page,
and, and it would be faster, so now this is one of the, one of the, or this is the home page of
the Chaos Computer Club in the, in 1987, and here's our keyboard, let's, let's go here, so this is
a page with the local units of the Chaos Computer Club in the, in the 1980s, and that was my,
my home base, across from my school back then, so there's a little bit of history for me in there,
so yeah, thank you to my companies, bundling this, this talk, and thank you for listening.
I don't know, yeah, so, so is this similar to Dutch teletix, I don't know, there,
there also has been video text, which is a broadcast only way of sending, sending program information
in the TV stream, but this is phone base, I don't know whether teletix is phone base, I don't know.
Just as a supplement to that, teletix is the name main grid, as well, and it was a broadcast.
It's the broadcast, so yeah, so yeah, yeah, you were first.
Yeah, you said that you could make some orders on this system, so is it possible that you can
harass applications on the main thing that you're seeing, that process the orders and do stuff like that?
So is it, yeah, so the question is, could you, I said you could all
stuff on there, so the question is, could you connect external systems to the, to the built-in text system?
Yes, you could, so you could have what was called an external, external computer that was
connected to the central system through dot xp, which is x25, and then there would be a hand over
page where you basically your terminal, your user terminal would be given to that external machine,
they would do the user interface processing and return back to the built-in text system as well.
The one thing that I wanted to mention that I failed to mention is that there was also a payment
system, so you could have paid pages, you could have a page that displayed some information,
it attached a price to that, and that would be deduced from your phone bill, which was what then
enabled the CME famous hack when the CCC called its own page for 10 marks
13,000 times and had a creative big phone bill for a bank.
Hmm? I believe they are pretty separate, but, so is built-in text related to many
tell, I believe they are kind of the same vintage and prestal was very influential, the UK
predecessor of these systems, but I think there was no direct connection between the two.
Thank you very much.