STL: Italian vs. French notation – take your pick

STL is an absolute notation, so, for example, 3-5 always means course 3 fret 5 where courses are numbered in the standard way i.e. course 1 is always furthest away from you when you are playing the instrument.

However, when we come to display tablature, there are two conventions:

  1. Italian convention – course 1 is shown at the bottom of the stave. This is what Sanz used.
  2. French convention – course 1 is shown at the top of the stave. This is the convention used in modern guitar tablature and in lute tablature.

In fact there is nothing to choose between the two, and most Baroque guitarists should aim to become fluent in both conventions.

STL allows you to give a compiler information about what convention to use. By default, STL assumes the Italian convention. To switch this to French, just add the following line in the STL file header (i.e. above the first page):

FRENCH

For example, here is the first line of Sanz’s Canarios in Italian tablature:

...
P-1
    TITLE Canarios
    COMPOSER Gaspar Sanz IMSGE 1.8.1
    S-1
            T-3
            Q   2-3:.
                1-0
        B-2
                1-2: 4-0
                ...

CanariosItalian 

Now in French tablature:
...
FRENCH
P-1
    TITLE Canarios
    COMPOSER Gaspar Sanz IMSGE 1.8.1
    S-1
            T-3
            Q   2-3:.
                1-0
        B-2
                1-2: 4-0
                ...


CanariosFrench
So you can see that the gaspar Postscript compiler can generate Italian or French style tablature automatically. Notice that the only change to the STL file is the addition of the keyword FRENCH.

The gaspar compiler generally tries to do the right thing (e.g. swaps slurs over), but you might find that there are a few cases that need manual tweaking. For example when an adornment is placed over a note (as in bar 4 above), there could be interference with the durations and this might need to be fixed.

Advertisements

STL: Notes, frets, adornments and fret maps

By now, you probably know that it is very simple to enter a note in STL e.g.

2-4

This is the note on course 2 fret 4.

Frets are always specified in STL by a number where 0 is the open string, 1 is fret 1, 2 is fret 2 etc.

Notes may also have an adornment. This is extra information after the fret e.g.

3-1T

This is course 3 fret 1 with a T (trill in Sanz’s notation) after it.

Of course, you can also place an adornment without a fret:

4-T

This places the T symbol on course 4.

Whilst you can only logically place a fret on a course, you can also place adornments above or below the stave.

A compiler can process an adornment, ignore it, or render it “as is” to the output file. The gaspar Postscript compiler tends to render it “as is”, giving you the ability to put completely arbitrary text on any course.

Fret maps

In many historic tablatures frets are designated by letters. For example, in Sanz’s notation, fret 10 is always designated by an X. This is because placing a 10 on the stave could be confusing e.g. fret 10 on course 2 could be misread as fret 1 on course 2 followed by fret 0 on course 2.

In order to deal with non-numeric fret notation, or numeric notation that designates the open string as 1 rather than 0, STL introduces the concept of fret mapping.

Take a look at the STL example below:

P-1
    S-1
        T-3
            Q   1-1
                1-2
                1-3
                1-4
                1-5
                1-6

As you might expect, this gives you the following Postscript output:

NoFretMap

Now let’s add a fret map to the file:

FRETMAP 1-a 2-b 3-c 4-d 5-e 6-f
P-1
    S-1
        T-3
            Q   1-1
                1-2
                1-3
                1-4
                1-5
                1-6

I think you can guess what this is going to do...

FretMapThis FRETMAP command simply tells the compiler to replace fret 1 with a2 with b3 with c etc. in the output file. The mapping is completely unconstrained, so you could, if you really wanted to, replace fret 5 with fret5 or with an emoji for example.

You can map as many or as few frets as you need. For example:

FRETMAP 10-x

will map fret 10 to a lowercase x.

In fact, the gaspar Postscript compiler has a default fret map for Sanz’s notation where fret 10 is automatically mapped to X etc.

If you don’t want the default fret mapping, then you can either replace the mapping with your own map (as above), or turn off fret mapping completely:

NOFRETMAP
P-1
    S-1
        T-3
            Q   1-1
                1-2
                1-3
                1-4
                1-5
                1-6

The above STL makes all frets numeric.

STL: Fingerings

It is very easy to add fingerings to tablature in STL.

Consider this first line of Sanz’s Canarios (book 1 page 8):

CanariosBook1Page8

Sanz shows the fingerings for a note as dots placed over, above or to the right of the note where:

1 dot = first finger

2 dots = 2nd finger

3 dots = 3rd finger

4 dots = 4th finger

Here is my typeset version:

CanariosBook1Page8TYPESET

Below is the STL for this line – can you see how the fingering is added? Also notice that I have put the fingerings quite accurately where Sanz specified they should be – sometimes to the side of a note and sometimes above or below it. To be honest, this degree of verisimilitude is probably going a bit far, because the meaning of the fingering doesn’t change depending on whether it is above, below or to the side. Sanz only used these different positions in order to get as much notation onto a stave as possible.

TITLEFACE Zapfino
TITLESIZE 24
FRETFACE ArialMT
FRETSIZE 11
COURSES E4 B3-B3 G3-G3 D4-D4 A3-A3
SHOWCOURSES
P-1
    TITLE Canarios
    COMPOSER Gaspar Sanz IMSGE 1.8.1
    S-1
            T-3
            Q   2-3:.
                1-0
        B-2
                1-2: 4-0
                1-0
                1-2
                1-3:: 2-0

                1-2:
                1-3
        B-3
            C   1-2 2-3
            Q   4-0
                1-0
                2-3::

                2-2:
        B-4
                2-0 3-0
                2-2
                2-3
                1-0 5-0 0-T
                2-3
                2-2
    S-2
        B-5
            C   2-3
            Q   4-0

        SB-1

                1-2 4-0 2-..
                1-3
                1-2
        B-6
                1-0 5-4:.
                1-2
                1-0
                2-3 5-2. 3-::
                1-0
                2-3
        B-7
                2-2 5-0 3-..

                2-3 1-::

                2-2 3-..

                3-2 4-4 2-. 5-:.

                3-0
                3-2.
    S-3
        B-8
                2-0 3-0
                2-2 3-..
                2-3 1-::
                1-0 5-0
                1-2 0-..
                1-3 0-::

Why a textual tablature language? Why not a GUI?

I have used, or tried to use, many different GUI tablature programs over the years with varying degrees of success. I have come to the conclusion that not only is a GUI completely unnecessary for engraving historical tablature, but that it is often counter productive. I have also come to the conclusion that the inflexibility of these programs means that they are not useful for repositories of historical tablature. In the realm of software engineering, they constitute an Anti-Pattern.

Why do we have GUIs anyway? The only purpose of a GUI is to make a difficult task easier. Now consider tablature setting fret 5, course 1 of duration crotchet in a typical GUI tablature editor:

  1. Locate and select the duration from a menu/toolbar that may have many possible entries (good eyesight required!)
  2. Drag the selected duration to the stave
  3. Select the course (steady hand required!)
  4. Type the fret number/symbol on to the course (optional – it’s not accepting my text entry – why? – read the manual)
  5. (Optional) go back to 1, because the tablature I am engraving is in Italian format and the tablature program is working in French format and I have got myself confused.

OK – I exaggerate a bit for comedic purposes, but we have all been at 4. and 5. at some point…

Now consider the same action in STL:

  1. Type C 1-5

Actually, that’s quicker than saying, “fret 5, course 1 of duration crotchet”.

You wouldn’t dream of writing text using an editor where you had to select a character from a palette and then drag it on to the page, so why would you choose to do this for historic tablature? A GUI is great for a drawing program, but historical tablature, although it looks like a drawing, logically has more in common with text.

So I would argue that GUI based tablature engraving programs don’t really make things easier at all. In fact, they can be an infuriating waste of time. OK – with text based engravers you need to learn a language to use them, but I can assure you that it takes much less time to learn the few keywords in STL than it does to lean to use the leading historical tablature program.

Another big problem I have with GUI tablature programs is that they invariably use a proprietary (usually binary) file format. This means that once you have spent however many hours painstakingly entering your tablature into one of these programs, you are completely locked in. There may be some sort of “Export to format X” facility, but this is generally limited and unsatisfactory. So you can’t repurpose your work outside of the program that created it. Worse, if the file format of the tablature program is not open source, then you also face the risk that the developer will no longer actively develop the program and that, like so many other binary files, your tablature will no longer be accessible. This is why these program should not be used for repositories of tablature.

There is also a question of workflow to be considered. If you are engraving a lot of historical tablature, WYSIWYG GUIs are not necessarily your friend. A better workflow is to first capture the music (the logical domain – see below) and only then work out the details of its presentation (the visual domain). This separates the two concerns of capturing the music and engraving it. The logical music can be engraved in different forms without changing it. This is exactly how STL works.

However, the real crux of my objection  is really the conflation of logical vs. visual musical domains. According to the MEI website:

Maxwell (1981) outlined three separate domains for encoding music notation in a computer: physicallogical, and graphical.

In this model, the logical domain includes the musical content or structure including pitches, time values, articulations, dynamics, and all other elements—defined as the symbols that communicate the composer’s intentions.

The visual domain describes the contributions of an editor, engraver, or typesetter, and encodes information about the physical appearance of the score, such as symbol locations, page layout, or font. Finally, the analytical domain covers commentary and analysis of the music document in any of the three previous domains.

Now this is actually a very, very important issue. GUI tablature editors conflate the logical and visual domains in such a way that the logical structure of the music is completely lost in its visual syntax and is buried in a proprietary (often binary) file format. The advantage of STL is that it is a literal implementation of the logical domain in text. The visual domain is generated from this by the action of the various STL compilers.

Lilypond compiler

According to http://www.lilypond.org Lilypond is:

LilyPond is a music engraving program, devoted to producing the highest-quality sheet music possible. It brings the aesthetics of traditionally engraved music to computer printouts. LilyPond is free software and part of the GNU Project.

It is a fantastic program capable of creating exceptionally beautiful scores. I wholeheartedly recommend it!

I have created a new STL to Lilypond compiler. This was a bit tricky, because Lilypond is quite particular about time signatures and barlines, and Gaspar Sanz (and early music in general) is not. However, with a bit of fiddling I have been able to get acceptable results.

Here is Rujero in tablature created by the STL to Postscript compiler:

Rujero

And here is Rujero in conventional notation generated by Lilypond:

RujeroLilypond

As you can see, the results are pretty good! I have still to add some font management to the compiler, and I have not yet implemented ornamentation, but the basic functionality is now in place. The Lilypond compiler isn’t really one of my priorities, but I expect I will add at least some of the notation (the trills and mordents) when I get a chance. Another addition will be the option to write a note for each string in a course. At the moment, I just write one note (the top one) for each course.

Sanz’s tablature translated directly to modern notation doesn’t always work very well, but in this case the result is OK and is quite playable.

The STL to Lilypond compiler is largely for musicological purposes – so that I can compare Sanz’s tablature directly with modern notation.

Here is the Rujero STL from which both of the above scores were generated:

P-1
    TITLE Rujero
    COMPOSER Gaspar Sanz IMSGE 2.4.1
    S-1
            T-C
            Q 2-3 4-0 5-T
            2-2
            2-3
            1-0
        B-2
            Q 1-2 4-0
            1-3
            1-2
            1-0
            C 2-3
            1-0
        B-3
            1-2 4-0 1-{
            2-3
            1-5 4-4
            1-3 4-2
        B-4
            Q 1-2 4-0
            1-3
            1-2
            1-0
            M 2-3 1-#

        SB-1
    S-2

            C. 2-3 4-0 5-T
            Q 2-2
            C 2-3
            1-0
        B-5
            Q 1-2 4-0
            1-3
            1-2
            1-0
            C 2-3
            1-0
        B-6
            C. 1-2 4-0
            Q 4-2
            C 4-4
            3-1
        B-7
            M 1-0 2-2 3-2

            5-0
        B-8
            SECTION
            C. 3-2
            Q 3-1
            C 3-2
            2-0
    S-3
        B-9
            Q 2-2 5-0
            2-3
            2-2
            2-0
            C 3-2
            2-0
        B-10
            2-2 5-0
            3-2
            1-0 2-0 4-2
            2-3
        B-11
            Q 1-0 2-2 5-0
            2-3
            2-2
            2-0
            M 3-2

        B-12
            C 1-5 2-3 4-4
            1-5
            1-3 2-0 4-2
            2-2
    S-4
        B-13
            Q 1-2 2-3 4-0
            1-3
            1-2
            1-0
            C 2-3
            1-0
        B-14
            C. 2-2 5-0 3-T
            Q 2-3
            C 1-0
            1-2
        B-15
            SECTION
            M 2-3 4-0

            2-3

        EB-1

Tablature layout: Justification

STL now has the ability to justify tablature. This means that instead of notes being placed in fixed slots on the stave, the notes are spread out to  fill the stave.

Enable justification by adding JUSTIFIED to the start of the sanz file e.g.

JUSTIFIED
P-1
    TITLE Chacona
    COMPOSER Gaspar Sans IMSGE 2.4.6
    S-1
            T-3
            C.  2-2T 5-0

            Q   3-1
                5-0
                2-0

The spacing algorithm is pretty simple:

  1. Calculate how many slots remain unused at the end of the stave.
  2. Calculate the padding to add to the position of each note to fill up the vacant slots.

Note: Justification can look terrible if there are too few notes on the stave, so the justification algorithm only kicks in if the stave is more than 3/4 full.

Rujero – modern stringing vs. original stringing

It is very easy to specify different stringing in STL – just put it at the start of the file. For example, here is the beginning of a version of Rujero that specifies modern guitar stringing:

COURSES E4 B3 G3 D3 A2
P-1
    TITLE Rujero
    COMPOSER Gaspar Sanz IMSGE 2.4.1
    S-1
            T-C
            Q 2-3 4-0 5-T
            2-2
            2-3
            1-0

Here is the art of Rujero with the (default) re-entrant tuning used by Sanz:

COURSES E4 B3-B3 G3-G3 D4-D4 A3-A3
P-1
TITLE Rujero
COMPOSER Gaspar Sanz IMSGE 2.4.1
S-1
T-C
Q 2-3 4-0 5-T
2-2
2-3
1-0
As you can see the COURSES syntax is very straightforward:

E4 the single E string
B3-B3 a course of two strings, each tuned to B3

In fact, you can have as many strings in a course as you like.

Here is an MP3 that begins with Rujero in modern guitar tuning, and then repeats it in Sanz’s original re-entrant tuning.

https://soundcloud.com/jim-arlow/rujeromodernthensanz

It’s a matter of taste, but personally, I prefer Sanz! The piece has a much lighter and joyful texture.