Typesetting Historical Print

In today’s tutorial I will show how to reproduce a beautiful example of historical print using XeLaTeX. The inspiration for this came from my amazement with the Bible de Genève, one of the most beautiful typesetting examples with LaTeX (to be found in the LaTeX beautiful typesetting showcase:  LaTeX showcase). I thought I had to explain how a simple, non-perfect version of something like this can be done. Because, actually, something similar is not that difficult to create if you’re willing to do it less perfectly.

I tagged this post ‘beginner-friendly’ and ‘advanced’ at the same time because, frankly, I wasn’t sure which one was true. This is probably not your ‘3min to LaTeX’ beginner’s tutorial (which can be found [here]) but it looks pretty cool and is not that difficult either.

This post also serves as a teaser because this is only the base, really, for the actual tutorial (to follow soon, hopefully): Going from TEI-XML data to a PDF more or less imitating the historical print. And all that done automatically using an XSLT transformation for the whole glory of 600 pages of Michael Maier’s Symbola Aureae Mensae (1617). I’ll keep you posted, but for now, this is what the LaTeX part of the game looks like.

This is the Overleaf link to my document which you can view or reuse to your own liking.

The tutorial uses XeLaTeX. For now, suffice it to say that XeLaTeX is the way to go if you want to include your own fonts and if typesetting them is really important. I will explain why or why not and when to best use XeLaTeX in another subsequent post.

But I have also included some if-else constructs to check whether you’re compiling with XeLaTeX or just normal pdflatex because if you don’t have XeLaTeX available, the long s will not be displayed and you will get an error for every unicode character not present in the regular pdflatex font. Also, the microtyping, which I use very sparely for the letter spacing. Please be aware that I have not yet gotten to familiarize myself thouroughly with the microtype package or typographical best practises, so if in question – rather take somebody else’s advice on the specificities. But seeing as this tutorial is only meant as a teaser, I am not going to explain every detail anyway.

First things first

I got my data the Herzog August Bibliothek Wolfenbüttels alchemy portal where they have a full text of Michael Maier’s Symbola Aureae Mensae here. There I accessed the TEI data (a bit difficult to find here ) from which I subsequently extracted the first page of Liber Primus. All the typesetting used was present in the markup in the form of elements. For your information, this is the part of the TEI-XML this is based on (XML is broken and, seemingly, unrepairably so. Please check out the XML in the link from above).

 

SYMBOLA AVREÆ

MENSÆ DVODECIM NA-

TIONVM.

LIBER PRIMVS.

POſt horribiles minas & grauiſſimas debac-

Quæ cauſa
& occaſio
huius con-
uentus Phi-
loſophici.

chationes, quas Pyrgopolynices in Che-
miam Virginem, orphanam, & ab om-
nibus derelictam, iam pridem effuderat
(proclamans illam ſpuriam, meretri-
cem, adulteram, deformem, imbellem, impoten-
tem, mendacem, mendicam, inhoneſtam, imò o-
mnium ſceleſtiſſimam, ſacrilegam, relegandam
aut morte peſſima delendam) hæc præ dolore animi
impatiens Comitia indixit omnibus, quotquot ſeſe Do-
minam agnoſcerent, præſertim Senioribvs, qui ef-
frenatæ illius inſaniæ reſponderent, ſeſeq́; pro virili caſtam
& intactam defenderent. Conuentuitaque habito ex
præcipuis noſtri Orbis nationibus, duodecim in-
primis comparuerunt, ſingulæ in ſuas Tribvs
d

To sum it all up, we largely have 4 elements to account for:

A head element which uses a bigger fontsize, spacing, italic and bold. More generally, we will do hard-coded linebreaks so it will be easier to maintain the page layout of the original without having to micro-adjust the LaTeX. Then, we have the highlights, indicating where we need to adjust font styles, weights, variants like caps and also, spacing between letters and also to some degree, between words, to maintain the balance.

Ah, and of course, don’t forget to LaTeX-ify the ampersands! (XMLs & entity ( & has to be changed to LaTeX’s \& )

Setting up the document

In the code examples to follow, I only pasted the things I explain in here. For the full document see the Overleaf link. I suspect, however, that I included some packages which wouldn’t be needed. So probably don’t take this as an example from which to learn good LaTeX style… Here goes:


\documentclass[paper=a6,11pt]{scrbook}

\usepackage{iftex}

%---------------------------- font settings
\usepackage[utf8]{inputenc}
\usepackage[english,latin.classic]{babel}

\usepackage[T1]{fontenc}

\usepackage{lmodern}
\usepackage{ebgaramond}
\usepackage{lettrine}

First, I decided to use the scrbook documentclass with a6 paper and and 11pt font, so I didn’t have to do too much rescaling from the historical book to a4 for this quick tutorial. The iftex package allows me to check if the user is using XeLaTeX or pdflatex like I explained in the intro. The next improtant step is the ebgaramond font which provides the beautiful historical font style ( Georg Duffners EB Garamond). This font is the reason we primarily need XeLaTeX for. It the PDF also turns out nicely with pdflatex but is more beautiful in detail if using XeLaTeX.  Also, I wanted to include this to show to DH people how you can include unicode characters which aren’t readily found in other fonts but might be needed for setting historical print.


\usepackage[protrusion=false,final,letterspace=-100]{microtype}
\newcommand{\spacedtext}[1]{\ifXeTeX{\addfontfeature{LetterSpace=20}\scshape #1} \else \textls[170]{\scshape #1}\fi}
\newcommand{\longs}{\ifXeTeX ſ\else s\fi}

\input Zallman.fd

This piece is where the microtype package comes in. I researched this just enough to achieve the effect shown in the example. I am by no means an expert on this and hope I’m not teaching you something hugely incorrect. The settings here are an approximation to get as close as possible to the historical example by just eyeballing it. If this were done more exactly, you probably wouldn’t need to hard-code the linebreaks like I did. But I thought it was easier and safe with the knowledge in mind that I intend to automate this and am not willing to check for every single one of the 600+ pages of the historical print if the output is correct.

Also, below this I defined the \spacedtext and \longs commands where I check how LaTeX is being compiled. If XeLaTeX is used, the spaced text will be done differently from the pdflatex option because it will throw errors otherwise. The \longs command is something you might want to create for every unusual unicode character in another document. Using pdflatex the long s unicode character, for example (the most frequent among others) will be undefined, thus throwing an error and simply not displaying that s. This is why I want it replaced with our ‘normal s’ if using pdflatex, so I don’t end up with half of the characters missing and having to check manually for missing characters. For this one page example also, this saves you a lot of work with Maier’s text.

Lastly, the \input Zallman.fd imports the initials.

\phantom{ }

\begin{figure}[H]
\begin{tikzpicture}[fill opacity=0.5]
\hspace*{-0.5cm}\includegraphics[width=1.15\textwidth]{decoration-vector.png}
\end{tikzpicture}
\end{figure}

The heading and some unusual line breaking

So this is where the actual document starts. I use \phantom{ } to get some spacing at the top (yes, I am one for dirty solutions). Then I add a picture of the decorative element at the top of the original print. This was done using that part of the facsimile (from the same source at HAB Wolfenbüttel, indicated above). I did some image manipulation and vectorized it. Then I place it as a tikzpicture with a 50% opacity. Notice the meaninful   naming as decoration-vector.png. 😀


\Centering
{\bfseries \textsc{{\Huge SYMBOLA AVREÆ} \linebreak {\Large MENSÆ DVODECIM NA-}\linebreak {\large TIONVM.}}}

{\large\textit{LIBER PRIMVS.}}

\medskip

Here comes the header. It is centered using ragged2e s \Centering, then I switch to boldface for the upper part of the heading, use small caps and select different sizes for the different lines. Notice how they are separated by \linebreak, not the \\ I would usually use to force linebreak. Try replacing all ‘linebreak’s with ‘newline’ and see how the inter-word spacing doesn’t work anymore. The different options for producing forced linebreaks have some subtle differences (see also the Overleaf tutorial here ).

\\, \newline and \hfill \break give more or less similar results for most use cases. Note however that \\ is redefined by some commands (like \centering) to achieve the desired behaviour whereas \newline won’t (resulting in undesired results, see explanation here ).

Usually, you don’t want to use \linebreak as it is considered somewhat of a ‘last resort command’ which usually produces ugly unwanted results (see Stackoverflow ). In our case however, ironically, this is exactly what we want: It will ensure that we get an even right margin by saying ‘break the line here and make the line end at the right margin’. This is totally what we want in this case. Usually, it probably wouldn’t be needed, but as mentioned above, I did not micro-correct all the word spacing options, etc. But we still want the result to look as much as the historical print as possible, so the ‘last resort command’ does the trick here.

The typesetting of the main text area

This is our last snippet here, explaining the rest of the principles at work in our mini-example of Michael Maier’s monumental Symbola Aureae Menase. If we wanted to typeset the whole book, we would need some more settings, of course, as he also has some more textual and typographical elements going on in these 600 pages of alchemical historiography. But let’s nor worry about that just yet:


\justify
\fontsize{9.5pt}{11pt}\selectfont

\renewcommand{\LettrineFontHook}{\usefont{U}{Zallman}{xl}{n}\color{red!50!black}}
\lettrine[lines=5,,loversize=-0.05, lraise=.05]{P}{}
\emph{O\longs t horribiles minas \& graui\longs \longs imas debac-}
\marginnote{\fontsize{6.5pt}{7pt}\selectfont\emph{Quæ cau\longs a} \linebreak \emph{occa\longs io} \linebreak \emph{huius con-} \linebreak \emph{uentus Phi-} \linebreak \emph{lo\longs ophici.} } \linebreak
\emph{chationes, quas Pyrgopolynices in} \spacedtext{Che-} \linebreak \spacedtext{miam} \emph{Virginem, orphanam, \& ab om- \linebreak nibus derelictam, iam pridem effuderat} \linebreak
(proclamans illam \longs puriam, meretri- \linebreak cem, adulteram, deformem, imbellem, impoten-

I use \justify to get the justification and set the font size manually using \fontsize{9.5pt}{11pt}\selectfont which again, could probably done more elegantly if I had taken the time to properly adjust the page, font and spacing settings. For this quick and dirty solution, however, this works just fine. The command sets the the font size with the first argument and the \baselineskip with the second one. Note that it is usually better to use the symbolic font sizes LaTeX provides (such as \large, see Stackoverflow ). But in this case, we want to be able to hard-code this the way we need it and don’t want LaTeX to exert its magical typesetting powers. Sorry LaTeX.

Usually the smybolic font size commands would guarantee a balance between font size and \baselineskip. Again, the ratio I inserted here is based on eyeballing only. But I think it works quite nicely here.

The initial

\renewcommand{\LettrineFontHook}{\usefont{U}{Zallman}{xl}{n}\color{red!50!black}}
\lettrine[lines=5,,loversize=-0.05, lraise=.05]{P}{} sets and displays the initial. You probably shouldn’t renew the command inside begin{document}. Well…

Lettrine uses the Zallman initials (see the LaTeX font catalogue initials section (at the bottom)). It sets the color to red!50!black, so it mixes red and black in a 1:1 ratio. Just red was too bright, I found. Note how I added this and there is no color in the original print. The \lettrine command sets the size of the initial to spanning 5 lines, downsizing it by 5% ( loversize=-0.05 ) and also raising it a little bit. Behind the raise is the ‘P’ the actual input the command takes, so the letter to be displayed as an initial.

The text

There follows some \emphed text to achieve an italic effect (maybe in this case, it would have been better to hard-code it as \textit seeing as the correct font style is also ‘hard-coded’ as the elements of the TEI-XML. Then, also note the frequent use of our \longs command. Already in the first line, this was totally worth the trouble. The \spacedtext{} macro created the spaced small caps using the microtype package which I didn’t explain in detail above. An explanation of this will follow in some subsequent post. For now, content yourself with playing around with it as provided.

That’s basically it, the only thing I didn’t explain yet is the margin note.

The margin note


\marginnote{\fontsize{6.5pt}{7pt}\selectfont\emph{Quæ cau\longs a} \linebreak \emph{occa\longs io} \linebreak \emph{huius con-} \linebreak \emph{uentus Phi-} \linebreak \emph{lo\longs ophici.} }

This basically creates a margin note. I manually redefines the fontsize like explained above. If we wanted to go beyond this example first page, we would probably include this resizing option as our default into the \marginnote command and also reset it so it always places the note on the respective outer margin of the page (in this example we only have this one note on the right side which is the standard option anyway, if we had a doublepage layout, we might want to reset some options). Note how you can use the \linebreaks inside the marginnote as well. Seeing as we have the information exactly where the lines should be broken from the TEI-XML, we might want to respect that.

comparison-symbola

So, that’s it for now and here’s what it looks like again.

Cheers!

 

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00

Advertisements

Why most “learn programming” classes, books and attempts fail

This seems to be a bold claim. Let me explain… There are two reasons why I think most introductory programming classes fail ant that is a) because they never actually teach prorgramming (i.e. “algorithmic thinking”, not the syntax of one concrete language / “your first language”)) and b) because they bombard students with tons of complicated subjects which are not necessary at the beginning, so nobody remembers or understands them anyway. But they confuse the students and distract them from what they really should learn like how to interact with the machine and basic flow control. Use a visual language (like Scratch for PC or Catrobat for mobile devices) and thank me later.

Algorithmic thinking

When we want to learn or teach how to program, we first need to define what programming is. Like in a human language, knowing the words and the grammar is not enough – knowing a language means “knowing how to communicate using that language”. For programming languages, this means what we might call “algorithmic thinking”.

Sadly, in most beginner’s programming classes, this is not taught. And this is also why in many classes on learning how to program, only those students succeed who already kind of knew how to program beforehand. Why is that, you ask? Because those classes  that have failed their students have never actually taught programming. The class listed some of the “vocabulary” of an example programming language. It maybe explained about data types, gave you information you didn’t know what to do with and forgot almost instantly.

You were fed all sorts of facts of “knowledge” but never got around “operationalizing” them.

John Sonmez thinks the same way when it comes to learning a new programming language when you already know how to program. Most people ( = learners) and, sadly, also most teachers, don’t get that in order to really teach programming,  they would have to teach algorithmic thinking on the example of one programming language. Not “show around” the programming language and wonder why nobody had learned anything.

Why you don’t need to learn about data types just yet and should start with a visual language

This is also why I would recommand a visual language to start out, like I explained in the [cheatsheet post](LINK) of this blog’s “learning effectively” series. Even more than high-level programming languages, visual languages allow you to ignore the low-level stuff for the beginning. (Data types being a high-level “symptom” of what I have just called “low-level stuff”. – Don’t kill me please.)

You can say whatever you want, but at this early stage you just don’t need to know about these concepts. Not when you’re barely starting out and have never programmed before. These concepts scare people away. These concepts make things complicated when they need not (yet) be.

If you want to learn effectively (this is valid for any kind of learning), you need to focus on one thing at a time. When starting out on your programming journey, learn algorithmic thinking first.

Programming essentially is “problem solving using a computer”

 So a class on starting programming should not teach “the vocabulary” of a language (not the grammer either). It should focus on giving you strategies for digital problem solving which is more or less the same thing as effectively communicating with the machine (if we want to use the human-language analogy). In learning a human language you would never expect to master the language just by learning some vocabulary and grammar by heart. You know that you have to be able to use it first. That means, you need to find out how to communicate effectively in that language.

Also we shouldn’t fall victim to the fallacy that starting to learn programming is synonymous to learning your first programming language. You could theoretically learn algorithmic thinking in pseudo-code without ever seeing a concrete example (which is not anything I would advise, however).

So when you teach an introductory class to programming (to people who might never have programmed before), maybe think of me and keep this in mind.

I myself have fallen victim to this and endured many boring and ineffective “start programming” classes. If you want to start programming, would like to follow my advice but don’t know how to start, I suggest my [post on how to find a “starting out” project](LINK).

 

 

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00

On Didactical Reduction (especially in the DH)

Didactical reduction means abstracting complexity to facilitate learning. It is the act of reducing and simplifying teaching material as to promote student learning. Sadly, I feel that didactical reduction doesn’t accomplish its ends most of the time. Here is why and how I think we could do better.

The road to hell is paved with good intentions

I have seen many classes where the content to be taught was reduced so drastically that is became simple and clear – but maybe **too simple and clear. It became meaningless.** The material became so easy to understand (or, even worse, a complex topic was made to seem like a banality), so that students stopped paying attention. “I already know this” or “I get this” are not necessarily thoughts a teacher wants to provoke. We use didactical reduction so that the complexity of a topic is hidden and we don’t scare our pupils. But fear isn’t always a bad thing. Fear means respect. And if a student never starts respecting a topic in its complexity, the student will never actually learn it.

Often, topics end up being reduced to banalities due to overly motivated didactical reduction.

There is no more incentive for students to learn them. I see this a lot with the more technical aspects of the Digital Humanities. Programming can seem scary to Humanists, so we reduce it to a bare minimum and then complain about how we can’t program. It’s either hack or yack with the DH, isn’t it?

Well, I don’t think so. I think that the DH have not yet reached the point where they have enough self-confidence to dare and face their dear students with a difficult class. Would anyone question the maths exams in a Computer Science degree even after they’d failed five times? They would complain, but they would not question why they  were necessary. (At least not at the back of their hearts where they know they are.)

It’s all just introductions in the DH?

In the DH, we are so afraid of the supposed lack of technical aptitude of our students that we basically just stop teaching them real skills. We do some theory, but not too much – it could scare away the students. We do some programming or other technical work but remain so much on the surface that no student could leave the class and actually feel that they master the topic. And maybe achieving mastery of a topic in just one class would be too much to ask. But then again, why do we even bother teaching a class if we don’t expect our students to have any actual skills after they have sucessfully completed it? Is it part of the nature of the DH that we are ‘Jacks of all trades’, we collect introductions to everything and master nothing? (Sorry to be provocative here, mabye this is exaggerated but also, maybe it makes my point more obvious.)

Challenging students means taking them seriously

I personally feel that teachers tend to not take students seriously enough. And by that, I don’t mean to insult or point fingers, but I think it is inherent in the nature of teaching that teachers deem themselves superior to their students. And this might be the case, of course. But this assumption brings with it a lot of presuppositions like the possible lack of aptitude or talent in the students. We mean well when we use didactic reduction but implicitly, it also often means that we don’t dare to challenge them because we’re afraid they might not be up for it. And that is a lack of respect.

Safe places, respect and challenge

I personally feel that trusting someone to be able to face a real challenge is a form of respect a teacher owes to its student. Showing respect by challenging people to learn and trusting them to be up for the challenge is something I apparently do unknowingly all the time when I teach. No matter if I teach Latin at school, teach university students or explain programming to 10 year olds. I trust students to be up for the challenge so that they can trust themselves. At first, they can be reluctant but once they realize how empowering it feels to learn an actionable skill, they love it.

I was very surprised to get very good feedback after teaching children during a sort of summer school this year. After all, my ski instructing years (the last time I actively worked with pre-adolescent children) were long past. But I think the reason why children I teach tend to idolize me is because I am one of the few people who treat them like adults. Who trust them to be able to handle responsibility and who take them just as seriously as I would a professor. Who doesn’t treat them like they’re dumb. Apparently, hardly anybody else does that or else it wouldn’t be so special.

But not treating a person as though they were dumb also means that I have expectations. I think them to be able to master a challenge but this also comes with the obligation to take the challenge. Adolescents tend to show more reluctance and resistance here. Challenging yourself is hard work and it might transform you. Change is feared and supposed to be painful. But it’s what makes learning worthwhile.

What I’m really trying to say with this is: You can only see your students’ potential once you dare to challenge them. Real learning can’t happen within the boundaries of absolute safety. Yes, it’s safe in your comfort zone, but there is this popular quote from the internet:

A comfort zone is a beautiful place but nothing ever grows there.

You can’t learn without leaving your comfort zone. Didactic reduction often leads teachers to make everything safe for their students. So safe that they actually prevent them from learning. And mind you, teachers: Students have a natural instinct to dumb themselves down hoping they will get less challenging work. Challenging work promotes personal growth, personal growth is change and people fear change. Also they avoid hard work. They will not appear compentent for a big challenge because they don’t want to be challenged. This is why you need to believe in their ability to tackle a challenge. Because they won’t do it if you don’t make them. Laziness kills, believe me.

Learning = Commitment to personal transformation

When I – as a student – take a class, on the one hand I want to obtain some quick and easy ECTS. But on the other hand, I don’t really want a class where I don’t ever learn anything. In the long term, the class will have been a waste of time if it doesn’t transform the way I think, at least in some aspect. A mere introduction, a listing or overview of the topic is nothing I need to take a class for. I can find this on Wikipedia. It doesn’t require any commitment. But if you want to learn, you won’t get very far without commitment.

A definition of learning in the field of Knowledge Technologies / Machine Learning / Artificial Intelligence is that it is a processes by which we achieve long-term changes in knowledge, perception and behaviour through experience. This results in in changes in brain structure in human learning and in changes in parameters of computationally represented knowledge and reasoning algorithms in machines.

This is a helpful working definition for the blog post at hand because according to this definition, no learning can happen without change. Which means it is a teacher’s job to induce change. This cannot be done by feeding students information they already know or making it appear like they already understand something because it is so drastically simplified. Students need to be made aware that there are things they don’t already know but at the same time assured that with the teacher’s help, they will be able to fill the void, one gap at a time.

Winging it

This all sounds great in theory but how do I make this work in practice, you might ask. Well, I’m not an expert and this sure isn’t the theory of the century but I have some ideas. Indulge me for a moment.

First of all, I obviously see that there is a difference between adolescents being forced to attend school and university students who, at least somewhere deep down, signed up for it freewillingly and came of their own accord. My tips work best for people who want to learn, at least somehow. But I don’t see why one shouldn’t be able to make it work for enslaved adolescents as well. It will probably be more difficult, but still.

Always make it actionable

If you have to do tons of theory, don’t forget to always make it actionable at some point. Theory can always be put into an actionable skill or “practised” on an example. This will be the one thing students will remember a year after your class is over. So make sure there is an actionable skill or general take-away or they might just remember nothing from the class in a year’s time.

Here, I would suggest you treat less topics but make room for some in-depth practical example for every topic covered where students can take action themselves. They should feel like they have mastered a task big enough that they can acutally use the skill they are supposed to have learned. Of course they still won’t be good. But I think they should end up feeling confident enough to do some paid work using the skill (taking into account that you go on learning as you work and usually can pull off, say a first week of slower, less good work, where you work yourself up to get a little more confident).

The size of the tasks I’m talking about could be doing XML annotation in a project, not “full mastery of Python” or something this big. If the class is, say, an introduction to Python, a student should be able to take a (not well paid) job where they do some small tasks with Python, in my opinion. So I would expect the student to have been taught some basic problem solving skills, some “algorithmic thinking”, Python basics and the knowledge of where to find what he or she doesn’t know yet. Or for another topic, the student should be confident enough to give supplementary classes or tutoring for someone who is new to the topic.

Do less but do it better.

I would go as far as to say that, for example, leave out the data types theory and just show that there are different data types with the examples of string and integer and how they work. Make the student understand what a data type is fairly clearly using these two examples and make sure he or she is able to practically apply that knowledge. They can learn about the other data types as they go.

Dare to do didactical reduction in the way that you leave things out so you can go into detail with the most important, most actionable basics. Cut the last topic you had planned for the semester, if you have to. It will be worth it if you really achieved good results on the basics.

A student with a sound understanding of the basics and the ability to apply this understanding to small (but not too small / banally small) tasks will be able to teach him- or herself the more advanced stuff somehow. Your job as a teacher is to provide the information the student couldn’t easily get on their own (like insider tips, thing you only learn with tons of experience, the understanding why XY is important or why attention to detail is important with a particular task, etc.).

But I don’t teach topics which can be made ‘actionable’

I don’t believe you. Anything can be made actionable. And if the action is just passing your exam. Think about what you will let the students do for the exam and practise it. Students often have difficulty applying something they were supposedly taught. Because applying it is part of what you (yes, I’m pointing fingers) would have been supposed to teach them. Teachers often expect students to have the so-called “transfer” skill of applying knowledge but most often: they don’t. Just assume they don’t. Teaching this is part of your job! Also, let them do it with help first but be sure to include an example where they have to apply the skill completely on their own. Students usually don’t think for themselves as long as you help them with everything and so, neither you nor the student ever realize they actually haven’t learnt the skill yet. Do check if they have actually learnt the skill you were trying to teach.

What gets measured, gets managed. (Peter Drucker)

If the desired output is to write a seminar paper, think about what real life application that skill could have. Write a well-researched article in a (non-scientific) journal? If you get your students to be ready to publish for a scientific journal, all the better. Don’t be content with some half-baked output. (unless it’s Ben & Jerry’s). Also think about potential fields your students might work in once they’re done with their studies. Come up with a real life output. Don’t stop until you have found at least one. Then hold yourself  (and your students) accountable to really achieve this.

Information is certain to be lost, skills remain

But remember, if your class doesn’t teach anything students would be able to put down in their CV as a skill, they might just look back to the class afterwards and wonder what the hell they’d even learned there. At least that’s how I think back to classes where I feel I didn’t really learn anything. These classes all had topics, but only some of them had actual outputs. Digital Humanities teacher’s have absolutely no excuses here but I do see that this is easier said than done for some other Humanities topics. But nevertheless, you should always be able to come up with some real desired output of the class. If you can’t try harder. Revise your class. Challenge your students, but also challenge yourself.

I insist so much on teaching skills alongside “information” because information is certain to get lost over time. If you don’t teach any skill, your class will have no lasting impact on your students whatsoever. All the “good classes” I myself have ever attended have taught me a new skill in one way or another. The only classes I remember now are the ones where I actually learned a new skill.

Undergraduate level vs. Master’s level: Knowing about a topic vs. knowing a topic

For undergraduate, so Bachelor’s level classes, I reckon some drastically reduced content and even the ominous “listings” of information might be ok if they can’t be avoided. You have to start somewhere. Though I firmly believe that there is always a way to include at least some actionable skill where you can go into detail. If it’s just doing a mini hands-on tutorial online where they get to do something they might, at least theoretically, use in real life.

Teach the class so well that your students can confidently write that skill in their CV

But for the graduate level, so anything Master’s curriculum or above, you absolutely have to make it actionable. Merely absorbing information is not enough anymore. A students needs to walk out of your study programme with a specialization and enough skills to get a first job. So this means either specializing on some topics with the result that the student is able to “make sound decisions”, “think for him- or herself” in this topic. Or enough applied knowledge which translates to a skill students can put into their CVs. If you teach a “practical” class, what is the skill you would trust your students to put into their CVs once they have completed your class? If you can’t come up with one, maybe you should rethink your class. Having heard about the topic and knowing it exists is enough for a Bachelor’s level introduction at best. At the master’s level, it is my firm belief that you should teach an actual skill for the student to master, a specialization where they feel “firm” and confident enough to do paid work in.

 

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00

 

The Name of the Game: How to pronounce LaTeX correctly (once and for all – or not)

In this post, I want to address the question of how to pronounce “LaTeX”. And explain to you, why this question cannot be answered if you want to take the investigation seriously. It turns out to be a classical Humanities’ style thinking kind of logical dilemma.  Unlike other explanations, I dont’ want to provide an answer (because there isn’t one) but rather explain why this question is not just a matter of “knowing how it’s pronounced” and thereby, show why we need the Humanities.

Description of the current situation

There are multiple pronounciations currently in use which are all considered to be more or less valid. But it can sometimes come to holy wars if you refuse to adopt the accepted pronounciation at large in your social or work environment. This is why I want to prove in this article that the question of how to pronounce “LaTeX” is actually a logical dilemma we can’t solve. I thus invite everyone not to be aggressive about the pronounciation convention of your choosing.

The most important pronounciations are:

  1. either “Lay” or “lah” for the first syllable (no holy wars involved)
  2. and, here’s where it gets complicated: “tec”, “tech” or “teks”.

As I said above, it is ok to use any pronounciation of your liking as there is no unified pronounciation anyway and probably won’t ever be. In the following, however, I’d like to deconstruct some of the prescriptive texts indicating there was one “correct” pronounciation. I do this to show that

a) we don’t have the solution for every problem,

b) for some problems, there probably won’t ever be a solution

c) if you’re an asshole to someone because they don’t use your favourite pronounciation, you do this because you’re an asshole and not because you’re right.

Collection of some prescriptive texts available to us

We learn from the LaTeX project’s about site:

LaTeX, which is pronounced «Lah-tech» or «Lay-tech» (to rhyme with «blech» or «Bertolt Brecht»), is a document preparation system for high-quality typesetting. It is most often used for medium-to-large technical or scientific documents but it can be used for almost any form of publishing.

LaTeX is not a word processor! Instead, LaTeX encourages authors not to worry too much about the appearance of their documents but to concentrate on getting the right content.

According to the [Wikipedia article](https://en.wikipedia.org/wiki/LaTeX#Pronouncing_and_writing_%22LaTeX%22) ), Donald Knuth wanted the word to be pronounced like the Ancient Greek techné which is why the “German” pronounciation with “ch” is recommended by the [LaTeX project site](https://www.latex-project.org/about/). They also don’t mention one very common mistake present in many other explanations:

Just asking for a pronounciaiton like ch, in fact, is super unclear because the pronounciation of “ch” varies a lot in different languages and even in German, there are two slightly different versions of it (Ach-Laut & Ich-Laut). In “Blech” or “Brecht”, like the example suggests, it’s the Ich-Laut, but what Knuth really meant, was definititely more on the side of the Ach-Laut. Why I think that is will be explained in the section about Problem II / the conclusion.

Also, when they write “Brecht”, we don’t even know if they mean the ‘correct’ German pronounciation or the very common English mispronounciation which is more like “kh”. This holds true for most examples where the explanation is written in English but uses German words as examples. How the hell are we supposed to know which one they mean? This is is where engineers who find general education to be superfluous err in the dark and aren’t even aware that they might have overlooked a problem. (I hope to convince all the engineers out there that the Humanities are imporant, valuable to everyone and not a superfluous thing because they don’t seem to have pratical, real-life uses if you don’t bother taking a close look. Not unlike computer science, the Humanities promise to teach you ‘how to think clearly’ – a skill which is definitely high in demand and useful, even necessary, for programming.)

Problem 1: Ach- and Ich-Laut

Now check out this Wikipedia section:

The final consonant of TeX (on which LaTeX is based) is intended by its developer to be pronounced similar to ‘loch’ or ‘Bach’. However, English speakers often pronounce it /ˈtɛk/, like the first syllable of technical.

The characters T, E, X in the name come from the Greek capital letters tauepsilon, and chi, as the name of TeX derives from the Greekτέχνη (skill, art, technique); for this reason, TeX’s creator Donald Knuth promotes a pronunciation of /tɛx/ (tekh)[15] (that is, with a voiceless velar fricative as in Modern Greek, similar to the ch in loch). Lamport writes “TeX is usually pronounced tech, making lah-teck, lah-teck, and lay-teck the logical choices; but language is not always logical, so lay-tecks is also possible.”

First thing: I had to Google to find out that ‘loch’ and ‘Bach’ are actually pronounced more or less the same way. However, I suspect that the correct Scottish ‘loch’ should be deeper down the throat than (correct) German ‘Bach’ (no ks involved). Seeing as English speakers usually pronounce it “lock” and “Back”, I assumed “lock” was the correct pronounciation but the correct Scottisch one is really “loch”, more or less like the correctly pronounced German “Ach-Laut” (both being produced in the back of the throat).

Getting back to the actual problem (the pronounciation of “LaTeX”), this information is misleading and Knuth also explicitly calls for the pronounciation as “kH” (what we think the sound in Greek techné was supposed to be pronounced like). “kH”, however, is not what ‘loch’ and ‘Bach’ are pronounced like. So confusing…

Now see the following quote from the TeX Book, Chapter 1, page 1 (highlighting added to make some points):

Chapter 1: The Name of the Game

English words like ‘technology’ stem from a Greek root beginning with the letters τ χ; and this same Greek word means art as well as technology. Hence the name TEX, which is an uppercase form of τ χ. Insiders pronounce the χ of TEX as a Greek chi, not as an ‘x’, so that TEX rhymes with the word blecchhh.

It’s the ‘ch’ sound in Scottish words like loch or German words like ach; it’s a Spanish ‘j’ and a Russian ‘kh’. When you say it correctly to your computer, the terminal may become slightly moist.

The purpose of this pronunciation exercise is to remind you that TEX is primarily concerned with high-quality technical manuscripts: Its emphasis is on art and technology, as in the underlying Greek word.

If you merely want to produce a passably good document—something acceptable and basically readable but not really beautiful—a simpler system will usually suffice. With TEX the goal is to produce the finest quality; this requires more attention to detail, but you will not find it much harder to go the extra distance, and you’ll be able to take special pride in the finished product.

On the other hand, it’s important to notice another thing about TEX’s name: The ‘E’ is out of kilter. This displaced ‘E’ is a reminder that TEX is about typesetting, and it distinguishes TEX from other system names. In fact, TEX (pronounced tecks) is the admirable Text EXecutive processor developed by Honeywell Information Systems. Since these two system names are pronounced quite differently, they should also be spelled differently.

The correct way to refer to TEX in a computer file, or when using some other medium that doesn’t allow lowering of the ‘E’, is to type ‘TeX’.

The [German Wikipedia](https://de.wikipedia.org/wiki/LaTeX#Aussprache_und_Schreibweise_von_%E2%80%9ELaTeX%E2%80%9C) confusingly explains it differently (why??):

Die Zeichen T, E, X im Namen kommen von den griechischen Großbuchstaben TauEpsilon und Chi, so wie sich auch der Name von TeX aus dem griechischen τέχνη (Geschicklichkeit, Kunst, Technik) ableitet. Aus diesem Grund bestimmte TeX-Erfinder Donald E. Knuth die Aussprache als [ˈlaːtɛx], das heißt mit einem stimmlosen velaren Frikativ („Ach-Laut“) wie im Neugriechischen. Dagegen äußerte Leslie Lamport, er schreibe keine bestimmte Aussprache für LaTeX vor.[19]

Die von Knuth bestimmte Aussprache bereitet nichtgriechischen Muttersprachlern oft Schwierigkeiten. Daher herrscht im Deutschen die Aussprache [ˈlaːtɛç] mit einem stimmlosen palatalen Frikativ vor („Ich-Laut“), im Englischen die Aussprachen [ˈlɑːtɛk] oder [ˈleɪtɛk]. Die Aussprache mit x [ks] ist unüblich.

In this, at least to the truly attentive reader, there is some general awareness to the fact that Ich- (after i,äöü and e) and Ach-Laut (after a,o,u) are not the same thing. And, instead of “prescribing” a correct solution, the article merely states how the word currently is being pronounced in different regions.

The Ich-Laut is produced by “pushing air between your teeth” (sorry for this bad and slightly ridiculous , but nevertheless useful, explanation) while the Ach-Laut is produced in the back of the throat. The Ich-Laut is a fricative (stimmloser palataler Frikativ, to be exact) and is actually related to the ‘h’ from ‘huge’.

Ich-Laut: The phoneme /ç/ of the German language, the sound of the letters ch in German coming immediately after ä, e, i, ö and ü, also found in other languages. https://en.wiktionary.org/wiki/ich-laut

Ach-Laut: The guttural phoneme /x/ (the voiceless velar fricative) of the German language, the sound of the letters ch in German coming immediately after a, o and u (central and back vowels), also found in other languages. https://en.wiktionary.org/wiki/ach-laut#English

The Ach-Laut is the version of “ch” after a, o or u and called stimmloser velarer bzw. uvularer FrikativAlso, linguist’s please don’t kill me, neither of the ‘ach’ nor ‘ich’ sounds are like ‘technical’ which is “kH”. Please correct me if I’m wrong about that. I think it’s likely Ancient Greek techné should have something created in the back of the throat like an Ach-Laut. The German Ach-Laut, however, is not compatible with e, like in TeX. Also, the Ich-Laut is very far away from containing something like a k which is being asked for, even if it’s aspirated and barely audible. 

Another example definition, for illustration purposes. The point, however, is already clear, I expect.

The name TeX is intended by its developer to be /’tɛx/, /x/ being the velar fricative, the final consonant of loch and Bach. (Donald E. Knuth, The TeXbook) The letters of the name are meant to represent the capital Greek letters tau, epsilon, and chi, as TeX is an abbreviation of τέχνη (ΤΕΧΝΗ – technē), Greek for both “art” and “craft”, which is also the root word of technical. English speakers often pronounce it /’tɛk/, like the first syllable of technical. ( [LaTeX Wikibook](https://en.wikibooks.org/wiki/LaTeX/Introduction) )

And the same thing from Overleaf:

LATEX (pronounced LAY-tek or LAH-tek) is a tool used to create professional-looking documents. It is based on the WYSIWYM (what you see is what you mean) idea, meaning you only have focus on the contents of your document and the computer will take care of the formatting. Instead of spacing out text on a page to control formatting, as with Microsoft Word or LibreOffice Writer, users can enter plain text and let LATEX take care of the rest. ( [Overleaf’s Learn LaTeX in 30 minutes](https://www.overleaf.com/learn/latex/Learn_LaTeX_in_30_minutes) )

These definitions, while they don’t really clear things up, show that there is a logical problem with the explanation provided by our master Knuth himself! Bach and Blech certainly don’t use the same ch sound. While the explanation that TeX chi should be pronounced somewhat like in loch or Bach is technically correct, the German sound in Bach cannot be used with after an e. So the Bach example is void and null if we wanted to use it to explain the pronounciation of TeX. Computer Science people from the TeX scene probably weren’t aware until now that they would need help from the Humanities to solve this question. Sadly, a lot of people generally seem to think the work Humanities people do is useless. But it is not. If we ignore it, a lot of our “arguments” are just void and null because we’re not aware of the flaws inherent in them. Language is complicated. They definitely got that right in the Wikipedia definition!

Back to the starting points for the investigation

To sum it all up, we know two things:

  1. First, Donald Knuth wanted TeX to be pronounced like Ancient Greek techné.
  2. Some hints suggest it should be pronounced like Scottisch loch, German Bach or Brecht. But we already learned how they were bad examples.

We encounter a plethora of problems here, if we look closely and ask what exactly is meant by those two statements. This is a good example to show why we need the Digital Humanities: In Computer Science, we usually take big complicated problems and break them down into small, simple ones. In the Humanities, most of the time, the closer we look the more complicated seemingly trivial problems become.

Problem 2: We actually have not much of a clue about how exactly Ancient Greek techné was or is to be pronounced

If we wanted to go the trouble and find out, in a scientifically correct way, how Ancient Greek chi was pronounced, we would do best to trace from which Phoenician sounds chi came and how it transformed when Ancient Greek words were introduced into Latin because we know a lot more about how to pronounce Latin than Ancient Greek.

And then, we would have to consider that Ancient Greek had many very different sounding dialects and was by no means a uniform language. This might have been done in Allen 1987’s  Vox Graeca (in the Resources section) which I didn’t bother to consult in preparation for this post. But, as we can see from the explanations above, this seemingly simple problem quickly leads us to a truly Socratic aporia.

Also, another thing is: It is likely that Knuth was a learned man but still probably not fully aware of the subtleties of Classics / Ancient Greek scholarship. So when he prescriptively said, TeX should be pronounced like Ancient Greek techné, he didn’t know (or didn’t take into account or didn’t care) that we can’t tell for sure how techné really was pronounced in Ancient Greek. This means, he probably had a specific modern restitution of the sound in mind but we can’t be sure which one.

Also, it would most certainly defy what he wanted if we just picked one we think he likely wanted used because – if this “staying true to the Classics” thing” was important to him and it’s certainly seems so – , I assume, he would have considered it more important that we pronounce it correctly according to Ancient Greek.

This however, requires information we don’t have. Logical dilemma. This is why we need the Digital Humanities. A Humanist probably finds it fascinating to think about this problem while a Computer Science kind of person probably is more than fed up with it by now already. They will probably just want a prescriptive “right answer”. In fact, I kept multiple students, researchers and professors of Ancient Greek busy for a few hours in total, discussing the question of how to pronounce Chi. The conclusion is that we know it phonetically is a “velar fricative”, so not pronounced between the teeth, like a German pronounciation like “Technik” would suggest. And we also know, the sound is considered something like “kh”, so there has to be some k sound involved, even if it’s very slight. Quite in accord with Karl Popper’s idea of falsificationism, we were not able to provide a correct solution but we were, in fact, able to falsify the German “ich-Laut”.

This is the beauty of the Humanities. A right answer would stop you from becoming a philosopher. The ability to cope with uncertainty is what makes you different from a machine (at least for a few more years to come, hopefully). So I invite you to reflect about this some more 😉

With this, I leave you for today.

Best,

the Ninja

And thanks, by the way, to my Humanist friends who happily discussed the linguistic problem with me (and helped a lot, of course!).

 

Resources

W. Sidney Allen, Vox Graeca: A Guide to the Pronounciation of Classical Greek, Cambridge 1987.

Donald E. Knuth, The TeXbook, Boston 1986.

 

 

Aporia (Ancient Greekᾰ̓πορῐ́ᾱtranslit. aporíālit. ‘impasse, difficulty in passage, lack of resources, puzzlement’) denotes in philosophy a philosophical puzzle or state of puzzlement and in rhetoric a rhetorically useful expression of doubt. (Wikipedia).

Socrates was known to humiliate “experts” by asking them seemingly trivial questions about their area of expertise which would end in a philosophical dilemma where they ended up having to admit they didn’t have the answer. A very useful method which, in fact, you can still use today, in order to elegantly unmask incompetency around you. Please, use with caution though.

 

 

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00

LaTeX Code of conduct

Dear friends,

today I would like to talk to you about one very serious topic: becoming a good LaTeX user. I say this as someone who definitely had to go through a painful conversion process. I now shall confess my sins: I used to ignore LaTeX errors when they didn’t seem to affect the output (meaning there would be PDF output, no fatal error stopping LaTeX from compiling, plus maybe no overly visible problems). I shudder to confess it now but: Nonstopmode was my best friend.

To spare you, my friends, from following me down this path of vice and misery, I want to bring up the subject of good LaTeX conduct today.

Read error messages, then ACT ON THEM

At least try to figure out what’s going on. If you make this a habit, you will not only learn a lot and actively get better at LaTeX with all the (hopefully not totally fruitless) online research you’ll be doing. But also, you will notice that it’s basically always the same misbehaviours you keep repeating document after document. Once you have reached this insight, you are in a position to better yourself.

Don’t let your standards down only because nobody’s looking or nobody ever looks at your source files anyway

At least when you’re not currently deadline-driven (and so understandably) have absolutely no patience for this), try to make your documents compile error-free. These will be some of the rare occasions you will notice the warnings and think, now that you have pruned your document from the errors, maybe the warnings might actually benefit you. I used to have so many error messages that I didn’t even notice the warnings, most of the time.

Why is bad conduct a thing with advanced LaTeX?

One thing you should know is that I am not one of those LaTeX gurus (at least not yet, muahahahaha… 😉 ). LaTeX ninja’ing, to me, means feeling empowered to do some cool fancy things with LaTeX, going beyond what most casual users do with it, but also, there is this aspect of getting what you want in unconventional ways – or, let’s be honest – in a messy way where the result counts, not who beautifully or elegantly it was done. Here, today, I want to also give credit to those hidden heroes who do things elegantly without ever telling anyone or bragging about it. Who just do what they do well because that’s the right thing to do.

I came to wonder why I wasn’t someone like that. And, while one of the answers definitely is laziness, the other is that LaTeX is seldom taught, or at least not at an advanced level. Beginner’s introductions usually content themselves with, well, introducing the basics, which is more like, listing them. And everything else, you probably learn on your own, sifting through Stackoverflow. And of course, some very knowledgeable people are on Stackoverflow and give some very helpful tips. But like this, you never learn in a systematic way (which is a big problem with learning to program in general, in my opinion).

You end up with a lot of actionable half-knowledge without ever understanding what’s really going on. And that was ok for me for a long time because LaTeX was just a tool. But once I had decided to really learn LaTeX and get good at it, I realized this was a problem. Sometimes, people make some general comments on Stackoverflow as to why you should or shouldn’t do XY. Sometimes they even explain in an understandable way why that is. Still, this is no way to learn advanced skills and while many advocate learning by tutorials or trial-and-error, especially when it comes to computer things, I don’t think that’s the way. There is some good to systematic teaching and a well thought-through class will quickly give you an understanding you wouldn’t get in thousands of hours of trial-and-error coding. Also, since there are no tutorials to learn advanced LaTeX (a situation I’m trying to aid with this blog, see this post), this approach doesn’t really apply here.

To remedy the problem, I have started to read books on LaTeX. The actionable insights you gain by this are, mostly, minimal: They are too theory-driven and complicated for absolute beginner’s but still, a good part of their content is made up of listings of basic commands which won’t bring a lot of benefit to the non-beginner, unless you are specifically interested in the theory or there is a book treating the specific problem you want to solve. So I established for myself that, apart from general laziness, a big problem about my incompetent use of LaTeX came from the fact that I just wasn’t even aware there was a ‘good style’ in the first place. And if I had a hunch that something like this must exist somehow, I just didn’t know where to look for that kind of information (apart from on demand trial-and-error problem-solving whenever the need for such a thing arises).

What is good conduct in LaTeX anyway, apart from not ignoring error warnings?

Let’s not get extensive here and stay with the basics. Good conduct is writing readable code. And, most importantly, avoid some LaTeX sins, i.e. deprecated elements (which you probably don’t use anyway if you didn’t start LaTeX 20 years ago already).

LaTeX sins to avoid (aka deprecated elements)

A list of LaTeX taboos can be found here. I’ll quickly sum up the most important ones now.

1.) Don’t use \sloppy (especially not globally)

Ok, I have to admit I sometimes totally do this. Sorry. In case you’re not familiar with \sloppy, you can use it to get rid of line overflows (which are common in LaTeX in case you didn’t notice). They happen because LaTeX doesn’t want to sacrifice the overall typesetting quality for one line where it doesn’t work. You should use \sloppy in a limited scope only or even rather change sentences so the problem doesn’t appear. It happens to me a lot with uncommon German composite words. You can also offer LaTeX information where to break a word if it doesn’t fit in the line instead of using \sloppy which will compromise the overall layout. But if the whole paragraph is made up of German nominalized complicated shit, just using \sloppy might be easier. Also, it will still work if you change the document while offering preferred hypenation might cause mistakes if your current document is not the final version.

For a vague overview of how \sloppy works: LaTeX internally has “penalties for certain behaviours, like widow lines and orphans (Hurenkinder and Schusterjungen). By defining a huge penality value for those, you tell LaTeX to avoid them in any case (also at the expense of other features of balanced typesetting). \sloppy basically ignores all sorts of “code of conduct” to ensure there are no line overflows. That’s a very imprecise explanation but gives you an overview of what’s going on more or less.

TeX’s first attempt at breaking lines is performed without even trying hyphenation: TeX sets its “tolerance” of line breaking oddities to the internal value \pretolerance, and sees what happens. If it can’t get an acceptable break, TeX adds the hyphenation points allowed by the current patterns, and tries again using the internal \tolerance value. If this pass also fails, and the internal \emergencystretch value is positive, TeX will try a pass that allows \emergencystretch worth of extra stretchability to the spaces in each line. […] \tolerance is often a good method for adjusting spacing; Plain TeX and LaTeX both set its value to 200. LaTeX’s \sloppy command sets it to 9999, as does the sloppypar environment. This value is the largest available, this side of infinity, and can allow pretty poor-looking breaks (from the TeX FAQ).

Check if you just forgot to choose all the necessary languages using the babel package. Sometimes the problem is that LaTeX just doesn’t know your languages’ hyphen rules if you didn’t explicitly declare them using babel. It sounds weird that you could forget to add babel but really, it happens to me a lot. LaTeX uses hyphenation only when necessary, meaning that it often doesn’t do any hyphenation in short documents or ‘accidentally’ gets them right even if you didn’t declare the language. So be sure to check for missing babel first.

2.) Deprecated macros

In older versions of LaTeX, you would have used {\bf ...} in curly brackets (to limit the scope) for bold face. This shouldn’t be used anymore. For a local change,  use \textbf{bold text}; for global changes in, say, a whole paragraph use: { \bfseries ... }. Analogous for all the other font faces. Locally, use  \text plus the 2 letter short name, for global scope, find out the correct “name”.

rm = roman (=serif font family \rmfamily), sf = sans serif font family (\sffamily), tt = monospaced (= “typewriter” font family \ttfamily). md = regular (\mdseries), bf = bold (\bfseries). up = upright (\upshape), sl = slanted (\slshape), sc = small caps (\scshape).

3.) Find out which packages are deprecated.

For example, font encoding should be done using \usepackage[T1]{fontenc}. A listing can be found in the taboo document (in German and in English).

You will still have documents which compile despite the errors. This is still ok when the PDF output is all that counts right now. But once you commit to better yourself, you will also be a better person overall and, from now on, have this little voice of conscience in the back of your head remining you that one should never ignore LaTeX’s warnings.

Cheers, the Ninja!

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00