Gaddisms from the thirty-second notes

Introduction

Steve Gadd is known for being one of the first to popularize the playing of fast thirty-second notes between hi-hat, snare drum and big drum, usually using a combination of rudiments such as reverse twos and paradiddles. Some people call them "pulsating strokes" (flutter lick), but it is better to use the already established term "gaddism".

One of the first mentions of Gaddism is https://www.youtube.com/watch?v=HKtHGLvVSHk [video clip], authored by Jungleritter from the popular YouTube hosting, which was also accessed by many other drum teachers, for example https://www.youtube.com/watch?v=lS3G6woh9T8 [Austin Burcham] (Austin Burcham). For clarity, you can watch the following performances by Steve Gadd:

The simplest version of gaddisms certainly looks like this.

In this lesson, I will talk about how I developed exercises for mastering these gaddisms so that I did not have to write down each combination one by one and I could easily add them to the score or remove them from it.

The final result of this tutorial looks something like this:

And so:

After rehearsals and proper practice, you can get the following version of the performance:

Creating gaddisms using Julia code

Before reading this material, be sure to read the section Drum notation to understand why it is preferable to record notes for percussion instruments in MuseScore.

First, let’s download a number of basic packages and define some values.:

using MusicManipulations # инструменты для работы с MIDI-данными
using MusicVisualizations # доступ к MuseScore

kick = "Low Floor Tom"
snare = "Acoustic Snare"
stick = "Side Stick"
hihat = "Closed Hi-Hat"

tpq = 960          # Длительность четвертной ноты в импульсах
subdiv = tpq÷8     # длительность доли (тридцать второй ноты)
patlen = 8*subdiv  # длина ритма

Next, we will define the types of notes that will make up the created rhythm of the thirty-second notes.:

A = DrumNote(snare, 0, subdiv; velocity = 100)
R = DrumNote(hihat, 0, subdiv; velocity = 70)
L = DrumNote(stick, 0, subdiv; velocity = 70)
K = DrumNote(kick,  0, subdiv; velocity = 80)

Note F2  | vel = 80  | pos = 0, dur = 120 | channel 9

The "K" note of the barrel is made here by the note of the floor volume simply because in MuseScore the notes of the big drum are not recorded in the same voice as the rest of the notes, which makes the final score difficult to read. Instead, you can use the "real" note of the big drum using `mdk["Acoustic Bass Drum"]'.

Anyway, the goal is to combine these four notes into gaddisms according to the following simple rules (which will maximize the preservation of Steve Gadd’s original style).

Each gaddism consists of sixteen thirty-second notes (two quarter notes).
The first half starts with a K barrel and cannot end with a right-handed punch.
The second half begins with a right-handed punch `A'.
R, L, K can be repeated up to two times in a row.

For example, the most "standard" rhythm is KLLRRLLK ALLRRLLK: standard 1

After defining the notes A, ... K, the easiest way to create a rhythm from them programmatically is to combine them into a vector, for example:

[K, L, L, R, R, L, L, K]

8-element Vector{Note}:
 Note F2  | vel = 80  | pos = 0, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 0, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 0, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 0, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 0, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 0, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 0, dur = 120 | channel 9
 Note F2  | vel = 80  | pos = 0, dur = 120 | channel 9

Unfortunately, there’s a problem: all of these notes start at the same moment, so if we were to add them to the score, we’d have eight thirty-second notes in the first thirty-second beat…

To convert this vector of notes into notes played sequentially, we define the following function:

"""

Combine the given notes into a notes that start sequentially.
"""

function make_pattern(v::Vector{<:AbstractNote})
    n = Notes([v[1]], 960)
    for i in 2:length(v)
        push!(n, translate(v[i], (i-1)*subdiv))
    end
    return n
end

p1 = make_pattern([K, L, L, R, R, L, L, K])
p2 = make_pattern([A, L, L, R, R, L, L, K])

8 Notes with tpq=960
 Note D2  | vel = 100 | pos = 0, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 120, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 240, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 360, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 480, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 600, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 720, dur = 120 | channel 9
 Note F2  | vel = 80  | pos = 840, dur = 120 | channel 9

Now you can easily combine them, transfer them to MuseScore and see the result.:

x = combine([p1, translate(p2, patlen)])

16 Notes with tpq=960
 Note F2  | vel = 80  | pos = 0, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 120, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 240, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 360, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 480, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 600, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 720, dur = 120 | channel 9
  ⋮
 Note C♯2 | vel = 70  | pos = 1080, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 1200, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 1320, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 1440, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 1560, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 1680, dur = 120 | channel 9
 Note F2  | vel = 80  | pos = 1800, dur = 120 | channel 9

musescore("standard.png", x)

Pay attention to the use of the function translate, which ensures that the second part of p2 does not start at the same time as `p1'.

So now it remains to record all the gaddisms that we want to rehearse.:

first_half = make_pattern.([
    [K, L, L, R, R, L, L, K],
    [K, L, L, K, R, L, L, K],
    [K, R, L, K, R, L, L, K],
    [K, R, L, K, R, L, K, L],
    [K, L, R, R, L, L, R, L],
    [K, L, R, R, L, R, R, L],
    [K, L, L, R, R, L, K, K],
    [K, R, L, R, R, L, L, K],
    [K, L, L, R, K, L, K, L],
    [K, L, R, R, L, R, L, L],
    [K, L, L, K, A, L, L, K],
])

second_half = make_pattern.([
    [A, L, L, R, R, L, L, K],
    [A, L, L, K, R, L, L, K],
    [A, L, K, L, R, L, L, K],
    [A, L, L, R, K, R, L, L],
    [A, L, R, R, L, R, L, L],
    [A, L, R, R, L, R, R, L],
    [A, L, L, R, R, K, L, L],
    [A, L, K, R, L, K, R, L],
    [A, L, R, L, L, R, L, L],
    [A, L, R, L, L, R, L, K],
    [A, K, R, L, K, R, L, K],
    [A, K, R, L, L, R, R, K],
    [A, L, A, L, L, R, L, K],
])

second_half[3]

8 Notes with tpq=960
 Note D2  | vel = 100 | pos = 0, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 120, dur = 120 | channel 9
 Note F2  | vel = 80  | pos = 240, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 360, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 480, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 600, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 720, dur = 120 | channel 9
 Note F2  | vel = 80  | pos = 840, dur = 120 | channel 9

Combining Gaddisms into a sequence

At the moment, all the necessary components are ready, and we can use any gaddisms to create a sequence, for example:

x = combine([first_half[5], translate(second_half[8], patlen)])

16 Notes with tpq=960
 Note F2  | vel = 80  | pos = 0, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 120, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 240, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 360, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 480, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 600, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 720, dur = 120 | channel 9
  ⋮
 Note C♯2 | vel = 70  | pos = 1080, dur = 120 | channel 9
 Note F2  | vel = 80  | pos = 1200, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 1320, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 1440, dur = 120 | channel 9
 Note F2  | vel = 80  | pos = 1560, dur = 120 | channel 9
 Note F♯2 | vel = 70  | pos = 1680, dur = 120 | channel 9
 Note C♯2 | vel = 70  | pos = 1800, dur = 120 | channel 9

musescore("another.png", x)

The scheme is quite simple, so we define a function that creates a sequence of an arbitrary number of gaddisms.:

function random_gaddisms(n = 1)
    @assert n ≤ min(length(first_half), length(second_half))
    r1, r2 = randperm(length(first_half)), randperm(length(second_half))
    final = Vector{Notes}()
    c = 0
    for i in 1:n
        push!(final, translate(first_half[r1[i]],  c*patlen))
        push!(final, translate(second_half[r2[i]], (c+1)*patlen))
        c += 8 # добавляем пустой такт, чтобы ноты было удобнее читать
    end
    return combine(final)
end

random_gaddisms (generic function with 2 methods)

musescore("random1.png", random_gaddisms(4))

musescore("random2.png", random_gaddisms(8))

This command can be executed any number of times to create any number of random combinations, for example, [musescore("randgadd_$i.pdf", random_gaddisms(8)) for i in 1:4].

The Gaddism matrix

If you print out and try to master some of these combinations, such as those shown in the last section on this page, you will quickly realize that there must be a more effective way to present this information. The correct answer is matrix. The matrix looks something like this:

How to create such a matrix? Using the following function:

using PyPlot

function gaddism_matrix(first, second; dx = 2.6, dy = 1.2) # дюймов на ритм
    patternimg(path) = matplotlib.image.imread(path)[:, 640:2880, :]
    Lf, Ls = length.((first, second))
    fig, axs = subplots(Lf+1, Ls+1, figsize = ((Ls+1)*dx, (Lf+1)*dy))

    for (fi, f) in enumerate(first)
        musescore("f$(f).png", first_half[f], display = false)
        fimg = patternimg("f$(f)-1.png")
        axs[fi+1, 1].imshow(fimg)
        rm("f$(f)-1.png")
        for y in ((1 - fi/(Lf+1)), (1 - (fi+1)/(Lf+1)))
            line = matplotlib.lines.Line2D([0, 1], [y, y], color="k", transform=fig.transFigure)
            fig.add_artist(line)
        end
    end
    for (si, s) in enumerate(second)
        musescore("s$(s).png", second_half[s], display = false)
        simg = patternimg("s$(s)-1.png")
        axs[1, si+1].imshow(simg)
        rm("s$(s)-1.png")
        for x in (si/(Ls+1), (si+1)/(Ls+1))
            line = matplotlib.lines.Line2D([x, x], [0, 1], color="k", transform=fig.transFigure)
            fig.add_artist(line)
        end
    end
    axs[1,1].text(0.5,0.5, "Gaddism Matrix\n(flutter licks)\n"*
                  "by George Datseris\nusing JuliaMusic", va="center", ha="center", size=12)
    for ax in axs; ax.axis("off"); end
    fig.tight_layout()
    fig.savefig("gaddmatrix_$(join(first))x$(join(second)).png", dpi = 1200)
end

gaddism_matrix (generic function with 1 method)

Two vectors of integer indexes are passed to this function, each of which indicates which rhythms from the first and second half should be included in the matrix.:

gaddism_matrix([1, 2, 4, 5, 7], [1, 8, 5])

For example, the standard rhythm presented in the introduction was created using the following code:

gaddism_matrix(1:4, 1:3)

You shouldn’t go into too much detail about gaddism_matrix, as most of the code is related to plotting. In fact, the function saves each rhythm separately using MuseScore, and then loads the image as numerical data (see patternimg) and builds a graph based on this image using PyPlot. The rest of the code is for formatting and adding lines.

This is a remarkable feature, as it can be scaled to any number of rhythms. Example:

gaddism_matrix([6, 8], 1:6)

You can create 3x3 matrices for your rehearsals and focus on working out individual rhythms to the point where they can be freely combined.

Saving all possible gaddism combinations in a PDF file

It is very easy to save all possible gaddism combinations in a PDF file using the following function:

function allgaddisms(first_half, second_half)
    final = Vector{Notes}()
    c = 0
    for i in 1:length(first_half)
        for j in 1:length(second_half)
            push!(final, translate(first_half[i], c*patlen))
            push!(final, translate(second_half[j], (c+1)*patlen))
            c += 8
        end
    end
    return combine(final)
end

allgaddisms (generic function with 1 method)

musescore("all.pdf", allgaddisms(first_half, second_half));

Keep in mind that this is a huge PDF file. Of course, you can do the following to combine only the first combination with all the others:

musescore("all_from_1.pdf", allgaddisms([first_half[1]], second_half));