widely and easily accessible pieces of software
is a highly interoperable WYSIWYG XML editor.
Sorry?
A highly
accessible WYSIWYG, what you see is what you get, XML editor,
which uses very complex XML markup,
but the user does not have to understand it.
This is one of the most widely accessible chunks of software
available today.
Yes, exactly.
So we don't have to play the game to prove that.
But why I wanted to start with that
is that I wanted to point out that actually coding
schemes like XML may not be just as important as you consider
them, but they should actually be seen as parts in a slightly
more complex category.
That slightly more complex category
might start with something like this.
These are the four approaches with which Dino has mentioned.
And I would like to categorize them slightly,
so we arrive at the jump-off point I would like to use for my own presentation.
About liminal, what it does, if I would want to describe it,
one of the statements of audit which I would make,
it's coding language, which is completely independent of XML.
As such, it has a couple of features which are unusual.
For example, that actually the attribute of a tag, in that case,
the speaker who is assigned to a particular utterance,
is encoded in exactly the same way as what roughly stands for a tag.
Tags contained within the specification of a tag, not in the content.
And it provides a relatively elaborate tool for
continuing tags across intervening tags.
So that's an in-built feature of the surface language,
the encoding language, which for most people defines liminal.
What liminal does is, it has its own data object model,
which has been designed to support specific features,
which make up what you usually call an object model.
That is not a model which in itself is provable, like for
example, the relation model, but which provides a consistent interface,
which defines what you can do with it.
Somehow, one important item has been dropped, but
if I would have to characterize liminal, I would use the following
four characteristics.
It's a coding language.
Internally, it actually uses XML when it wants to process something.
So liminal is translated into XML before processing.
It's actually not a good example for the front line between embedded and
stand-off markup, because it allows both.
And it has a specified data model on the object level.
Now, if we try to generalize that, we could say each and
every attempt to process text in a more than peripheral way needs these four
generalized characteristics, an external representation,
how you enter information into it.
An internal representation, which actually has not necessarily very much
to do with the external one, for it is much more formal.
Actually, the front line between embedded and
stand-off is not as strict as one might believe.
And there has to be an abstract model, which makes the implementation possible.
If you don't have a formal model, you can't predict what the system will do,
which is usually leading to results you wouldn't like.
That, again, was liminal.
Now, just to show that some systems which are out there
can lead to considerably different decisions.
What I proposed a very long time ago and where parts of it have in the meantime
been implemented by master's thesis is something like this.
That simply represents the idea that text,
as we have it in the humanities, is a different animal than text elsewhere.
So, for example, versioning should be built into the lowest possible level.
And it's actually part of the interface of a programmer.
Chris Kattner may be the opposite extreme,
because where the external representation as such is a GUI, it's an interface,
it's not a language at all, the internal representation is,
if I understood correctly, XML and TI, which means that it uses embedded markup,
but it stand off in as far as it allows to apply more than one of these to the same text.
And the abstract model simply says we believe in XML hierarchies,
but not in one, but in many, which can be applied to the same underlying text.
And to get back to Desmond, he is using a self-contained markup language.
The internal representation seems to be XML, if I have understood him correctly.
It's definitely standoff only.
And it's an abstract model which is very interesting because it's formal.
It is based on a variant graph on which Dino will say something later.
It's very interesting because that means that of these four systems,
it's the only ones where you actually can formally prove that something is wrong in the overall system.
Okay, so much as a kind of introduction to what I intend to talk about,
I will try to prove or at least introduce the notion
that there are abstract capacities of texts, or actually I'm not speaking about text,
I'm speaking about information, that there are abstract capacities of information as the humanities handle them,
which require different approaches than data from other knowledge domains.
And, incidentally, some of these requirements very, very, very strongly point to standoff.
Is there anything I can immediately answer to that, or should I switch to the part just announced?
Looks like I should continue.
Now, I said the guiding assumption which I'm trying to follow is that there are deep differences
between what some of the humanities, which ones there are, you'll notice in a few minutes,
that some of the humanities are processing.
So let me go very, very back to something like the first page of a classical textbook on computer science or information science.
Probably most of you have heard about when you tried to understand what computers do with information.
It's one of the three founding fathers of the field.
That's the basic assumption.
To communicate, you have to reproduce a message which has been transmitted from a sender to a recipient.
Looks something like this.
This, of course, is what we understand communication to be,
because some information is transmitted and somebody draws conclusions from them.
That's as it should be.
Unfortunately, that's not covered by Shannon.
Because the sentence following immediately after the one which we just pointed to points out that this is actually not covered by him.
That is, this does not work.
It's really roughly only this.
And this means that if you have to ask back, if something goes wrong,
you have to know what the intention of the sender has been to understand whether the recipient actually gets what he wants or he.
Now, this difference between something called data like this and something called information
is usually in information science described by something known as the ladder of knowledge,
ladder because it's something like this, which assumes that there's a level of data out of which information is derived,
which can grow into knowledge, and we will leave this level out because it's a bit esoteric.
So information theory, people actually talk about that quite a lot.
Now, the two lower layers are the ones which we are most frequently confronted with it.
So let me show you an example of information in a historical source.
That's information.
Do we have a pointer here?
OK, this is information.
The keys you see on the second row from the bottom stand for numbers and tell people how many barrels of beer.
One merchant owed another one in the harbor of Bergen, sometimes in the Middle Ages.
It's information because on the sticks you have a context which says we are dealing with barrels of beer.
This is data because the stitches are still there.
You know it's 25 somethings, but as there is no content, it can't be interpreted, so it's not information.
The traditional way to handle this is to say data are stored, like for example a temperature,
and information starts existing as soon as you interpret it within a context.
If you know that the 22 centigrade supplied to this lecture hall, we know what could be done about it.
And this eventually arrives into knowledge if somebody is able to draw conclusions from it.
If you say that somebody is able to draw conclusions from it, you may notice that we are here again.
Well, so we said the relationship between data and information is this.
However, leaving the humanities aside, that's actually a very interesting thing because you might find another textbook
which tells you that that's actually the difference between data and information,
explaining that we are not talking about the number 22, but about a temperature.
Some people might even say that transmission occurs at this stage because we apply one possible interpretation to a chain of bits and not another one.
That's interesting in as far because it starts indicating that information is not there, but is some kind of a process.
And there actually exists a model which tries to realize that.
That's the so-called infological equation of information.
Scientists are very well known in Scandinavia and for some reasons less well known in the rest of the world.
Who created this approach which simply claims that information is not a stage, but the outcome of a process which relates to the data available,
the knowledge also described as context in these other models which somebody has, and the time available to let that process run.
Okay, that's the basic reference we want. It's very difficult to get hold of it.
Now, what we try to do in the context of a project which I will point to later is actually try to generalize that.
And to make it more clear that we are talking about different possible outcomes of a process, different possible outcomes because of this.
Let's look at our example again.
That's a classical kind of conclusion that a historian believes what some text he gets implies.
He might also draw secondary conclusions, but unfortunately the whole image is totally distorted.
Because the sender, the intentions of the sender, what the sender wanted to communicate is simply a big question mark.
And this big question mark has produced something, and that's the text with which we are working, which then is transmitted not usually over a line,
but about terrible dangers which a manuscript cares to go through if it wants to survive a couple of centuries unchanged, undamaged and unfragmented.
If we would want to generalize things to map such a process, this means that we have to avoid the previous knowledge because when that process starts we do not have any previous knowledge.
Previous knowledge assumes that you know the intention of the sender.
And at least in those parts of the humanities which are not able to interview their subjects, which if you look closer at it is actually the maturity of the humanities.
Therefore this basic assumption that you always can go back and learn what the sender wanted to tell you by other means is not applicable.
Now this means that we would have to get rid of the S somehow.
Well, one step might be to make it more formal to say that information is the result of a process deriving something from information on a lower level of abstraction by knowledge available at the time of interpretation.
And the whole thing is still dependent on a temporal process.
So what I am trying to model here is the following.
If you look sufficiently long at the spelling you might get the notion that your original interpretation has been wrong because it simply might be another time.
So this means that you are actually not reading the text but when you are perceiving it the information which it transmits changes.
We can generalize this in that form saying that information and knowledge grow at the same time.
And when it is a rather small step to say that not only does such a thing like information not exist but it is a process deriving a better understanding of what the data mean from previous stages of interpretation.
But the same thing is true for a sender and if you insert it into the original one you arrive at something like this which we will not look at too long just to point out that it can actually have some implications for how you could construct computer systems.
No sorry yes that was the final step.
We remember that this is a process so actually things can change based on the basic data actually transmitted.
The programming tools which we have currently available are lousy at allowing for that because if you want to say I have an integer I have a character and I have a temperature these three things don't belong to each other at all.
That means if we would want to map that into computer science we would actually need something like this the understanding of information made up of objects which can have different interpretations which represent what we call a data type nowadays and might allow to add other interpretations.
If this is so and that's the point where computer scientists occasionally get a bit excited it might mean that we have to process humanities information as it is truly represented not under the current assumption that structures represent information and algorithms work upon it.
But that's such a thing like information is actually a transient state of a process which runs all of the time which could be applied back to human communication but we want to dig deeply into that.
I'm just quite sure that there's one big question on everybody's mind right now something like this.
Now I'll spare you some of the details but I would like to point out that during the last years we had a relatively large research project by the European Union which had nothing at all to do with the humanities.
Remember practical meaning which has absolutely nothing to do with humanities but was sufficiently dear to the heart of the European Commission to be worth a bit more than a million euros and take four years which I will represent in five slides now so forgive me if I cut out some of the details.
The basic problem is simply this.
In long term preservation it may be necessary to convert object, a digital object from one representation into another one.
If you use the obscure tool to do that and try to convert this PNT from the official test suite of PNTs to a TIF you get the somewhat unconvincing result on the right hand.
If you apply the same software to another specimen from this test suite you get this.
The problem is that the only known way to humanity so far to discover that is when you look at the two images.
Because the way in which the data are represented is so absolutely different that it's absolutely totally and completely impossible to compare them.
If you have say ten million such images which you convert every ten years you have a problem.
Now what we tried to do was realize the following notion.
It would be nice to have some software which is able to extract from two formats the essence of an image and represent it on the right hand side in something which presents this essence.
The essence of an image in such a way that you actually can compare it by software.
I think I need five more but okay.
And this is supposed to be generalized so given the fact that the PDF specification takes 2600 printed pages and micro software specification which we make available is about 4000 you will not be surprised that we didn't work it out completely.
But in principle this also supposes to work with textual formats.
This is done by creating representation languages.
One to describe what's actually in a format specification and one which tries to represent what is actually in an information object independent of format or something.
And there are two more which we can ignore for the time being.
How are they represented? That's a text.
Because two different parts of a text you can apply many many many different properties.
Well PDF for example is able to map quite a few properties to text which don't follow any rules.
That's interestingly enough an image because at the end of the day the image is also just a series of parts and to keep things simple I've done it here on the most simplistic case simply assigning a title to the image.
But it could easily be the case that you applied only to parts of an image.
Now if we try to generalize that practical solution keeping in mind the abstract model we used before which influences this.
I should first talk a bit about what we call dimensions. Now these are traditional dimensions in geometry.
You can describe the interpretation of a specific character by saying that it has dimensions or coordinates in a conceptual space where each of the three categories which you have here type of font language type of text.
Define one dimension which is completely independent of each other.
And the nice thing is of course if you don't have to visualize them too clearly there's absolutely no problem for a computer to use say five thousand dimensions if necessary.
So this is a rather easily generalizable model.
And these dimensions can have they have to be independent of each other but otherwise you can use completely different things you can for example also say a specific chunk of text has a position on a dimension but being related to a specific form of letter.
The bottom most.
Now let's look at something which is very very simple. These are four pieces of text.
There is an airfield called the beginning airfield in London or it used to be I think. Yes it used to be. It's closed down in the meantime.
The question is simply can anybody say which of these four strings are more similar to each other than the other two.
It's of course a nonsense question because the dimensions are independent of each other.
This should explain what we talk about when we talk about dimensions in such a space because if you look at the whole thing from the Y axis you see a big difference in visualization.
If you look at it from the X axis you see a big difference in concept in the conceptual meaning but they are independent of each other.
Let's go through this and go to the most frightening thing trying to generalize that.
So what we propose is that we imagine that a string of characters or tokens has a position in some dimensional space where different properties are applied to part of a chain of tokens.
That's the more generalized form. You have a series of atomic tokens which can be transferred to different dimensions which can be described in different dimensions.
Which leads to a nice generalization which we can skip except leading to the following assumption what a text actually is.
It's a series of content carrying atomic tokens. I apologize this is not being somebody with a computer science leaning being intentionally obtuse but the assumption that a text is made up of characters is so childish that we probably don't have to discuss it here.
Because all of us are aware that at least humanity's texts don't consist of characters. They consist of characters, visual symbols we don't know the meaning of, tricks of a layout which carry as much information as the characters, abbreviations which we don't understand except that we always consist of the same series of characters etc etc.
Therefore texts are not any assembles of characters but of many things including some characters.
And the second part of the text model is that each of these tokens has a position on n dimensions of interpretation which are independent of each other and of course can be added at Libitem later.
Cutting something else short, you remember what we did to the image, the nice thing is that you can generalize such a description very simply.
There is texts and images when you handle them on this model are not totally different, animals of different categories but they simply have a slightly different way in which the tokens which carry the meaning are assembled.
And this may seem very exotic, it's totally exotic because not all of you but quite a few of you have probably encountered the problem.
How do you meaningfully describe the content of a three dimensional object being a sequence of frames within a video which would be the three dimensional case and the other ones will skip.
Now another interlude pointing to another project.
I don't know whether any of you have encountered one of these things.
The top one is a relatively large European not European Commission but European because run by Europeans project which presents a quarter million medieval charters from 10 countries and
something like 70 or 80 archives where you have the images and people have the possibility to add information to them.
Now we are currently generalizing that and for that we use an assumption what historical research actually is.
According to our model when you transfer historical research into the digital world at least in some situations you start with digitizing the thing, the thing being a document or a piece of art.
You play around with the symbols, try to draw conclusions from paleography, try to make it more legible and do similar things.
Which leads to some knowledge about the original image which of course can change in any time.
You add a layer of a transcription into character based text, add some assumptions about textual criticism, do some research with this work on the semantic layer what that actually means, publish it and use it in teaching.
What we are currently trying to do is create or extend, much of it is created a working environment in which these things can be handled.
It has a very nice relationship to what I talked about just a few minutes ago because you can very simply say that if you are not looking at the process but at the way in which the different layers of information are connected you reach such an image.
You have a base image and when you work on symbols they of course have to be connected to the base image, changeable all of the time because humans make mistakes and software occasionally does so too.
Obviously if you transcribe it as a text you should be able to relate it to an image, if you create editorial knowledge you have to create it to the text and occasionally you should create it connected to the image and you are probably not surprised that other connections are also sensible.
So this would be a classical example where the formalization of a research process or an understanding on how a research process can be formalized would ask for a common base of data which are connected to various and completely independent representations of interpretations.
Now what I wanted to arrive at, it may be that there are some parts of the humanities where people who look at a manuscript understand it so they can say definite things about it.
As a historian I was never able to do so, so we should keep the representation of the tokens and the representation of the interpretation as clearly separate as possible.
Now such representations that's the reason why I plagued you with the stuff at the beginning can actually be grounded in information theory, that is they would make systems which are based upon it not less safe but safer because you can make statements about what can be done and what not.
And while it's not only theoretically sound we have at least some examples where this concept can be used in areas which are different from humanities but make at least as large demands on reliability and performance of the software derived from such abstractions.
Thanks a lot.