Braiding Rainbows







A Brief Description

PNDL stands for Place Notation Description Language.

PNDL is in essence a scripting language, designed to be read by a computer and translated into Place Notation. The requirement of not knowing the number of bells in advance was crucial, so it was decided that the quantity "n", meaning the number of "bells" being used should be set externally before converting PNDL to place notation. So, apart from "n", each script should contain everything required to generate place notation for any stage allowed for that particular method. That means that the limits or otherwise for the stages allowed for that method should be contained within the PNDL itself.

It was decided to make PNDL a "command based" language, in other words that it should consist of a list of commands to be executed in sequence, each command having a set of parameters associated with it. Each command should be as simple as possible, so it was also decided to use a single symbol for each command rather than a word. Another early decision was to use brackets to contain the list of parameters to a command, and further that brackets should be omitted where possible, that is to say when there were either one or no parameters, or in other words that brackets would be used only to surround a parameter list.

Some of the requirements for PNDL were:

The final specification included all of the above, and a few other refinements

Here is some PNDL that describes the method known as Cambridge Surprise:

             @("Cambridge Surprise", 6,~,2)
\(
    'x 3 x 4 x'
    !(8,n,2,'[i-6] [i-3] x [i-5] [i-2] x')
    '[n-4] x [n-3] x [n-2] x'
)
'[n-1]'
/
'.12'
;

Notes:

@("Cambridge Surprise", 6,~,2)

\( and /

'x 3 x 4 x' and '[n-4] x [n-3] x [n-2] x'

!(8,n,2,'[i-6] [i-3] x [i-5] [i-2] x')

'[n-1]'

'12'

The Implications of PNDL

PNDL works well in specifying methods that extend easily and naturally, although it can sometimes be a little tricky working out exactly how to do it. It is not so good when dealing with more complicated methods than the example given of Cambridge Surprise. For that purpose, a Method Description Language would be required, one that could actually describe the defining features of a method, together with how it should extend if extensions are required. Such a language (MDL perhaps?) has not yet been developed but is certainly possible to create.

Being able to specify a method on any number of bells raises some potentially controversial issues too. PNDL insists on methods being given a name, and this implies that the name stays the same at all stages to which the method extends. For methods like Plain Bob, Grandsire, Cambridge Surprise, and so on, this is not a problem, but at present there is a convention that a method cannot be named at any stage until it has been rung in the real world on real bells. This means that, theoretically at least, Cambridge Surprise 32 cannot be so named until it has been rung on 32 actual bells. PNDL allows a method to be specified without regard to the number of bells, and indeed, for the method named Cambridge Surprise, if someone were to ring the exact same method on 32 bells and call it, say, Granchester Surprise, that name would almost certainly be struck down for the reason that the method was self-evidently Cambridge. It would seem that the issue is far from clear, and also quite far from being settled.

Using PNDL, it is also possible to define a method such that at certain stages the Place Notation can potentially be the same as another method. In conventional bell ringing terms this is considered not to be possible, but PNDL allows it. For example, the PNDL for Double Bob is as follows:

             @("Double Bob",4,~,2)
\(
    ' x'
    !(4,n,2,'1[n]x')
)
'[n-1][n]'
/
'.12'
;

which produces the following Place Notation at stages 4, 6, 8, and 10:

x14x34x14x12

x16x16x56x16x16x12

x18x18x18x78x18x18x18x12

x10x10x10x10x90x10x10x10x10x12

Now consider the PNDL for Double Oxford Bob:

             @("Double Oxford Bob",4,~,2)
\(
    ' x'
    !(4,n,2,'[i-3][i]x')
)
'[n-1][n]'
/
'.12'
;

If we allow this to start at stage 4 (and there is no particular reason why this should not be allowed), the following Place Notation is generated at stages 4, 6, 8, and 10:

x14x34x14x12

x14x36x56x36x14x12

x14x36x58x78x58x36x14x12

x14x36x58x70x90x70x58x36x14x12

At stage 4, the identical Place Notation is generated for both Double Bob and Double Oxford. I can see no reason why both methods cannot be allowed to coexist. Many other similar pairs of methods can undoubtedly be found that pose a similar conundrum.