Monday, September 5, 2016

A System for Coding Handshapes

Sign languages are cool, and conlangs are cool, but there is a serious dearth of constructed sign languages. Or at least, there is a dearth of accessible documentation on constructed sign languages, and for all practical purposes that's the same thing. The only one I know of off-hand is KNSL. Thus, I want to create one.

Part of the problem is that it's just so hard to write sign languages. I, for one, cannot work on a language without having a way to type it first. Not all conlangers work the same way, but even if you can create an unwritten language, the complexity of documenting it (via illustration or video recording) would make it much more difficult to tell other conlangers that you have done so. The advantages of being able to type the language on a standard English keyboard are such that, if I am going to work on a constructed sign language, developing a good romanization system is absolutely critical. If necessary, it is even worth bending the language itself in order to make it easier to write.


There are quite a few existing systems for writing sign, like SLIPA, but just as you don't write English in IPA, it seems important in a developing a new language to come up with a writing system that is well adapted to the phonology/cherology of that specific language.

It occurred to me that binary finger counting makes use of a whole lot of interesting handshapes, and conveniently maps them onto numbers.* Diacritics or multigraphs can then be added to indicate things like whether fingers are relaxed or extended, or whether an unextended thumb is inside or outside any "down" fingers, which don't make any difference to the counting system.

So, I can write down basic handshapes just by using numbers from 0-31, or 0-15, depending on whether or not the thumb is included. There are reasons for and against that decision; including the thumb means the numbers would correspond directly to traditional finger-counting values, which is nice; but, it also results in a lot of potential diacritics / multigraphs not making sense with certain numbers, which has some aesthetic disappeal. On the other hand, lots of potential diacritics wouldn't make sense with certain numbers anyway, so maybe that doesn't matter. On the gripping hand, only using 0-15 and relegating all thumb information to diacritics / multigraphs means I can get away with using single-digit hexadecimal numerals (0-F), which is really convenient.


This page describing an orthography for ASL provides a convenient list of ASL handshapes with pictures and names that we can use for examples. Using hexadecimal numbering for the finger positions, and ignoring the thumb, the basic ASL handshapes end up getting coded as follows:


1: 1
3: 3
4: F
5: F
8: D
A: 0
B: F
C: F
D: 1
E: 0
F: E
G: 1
I: 8
          K: 3
L: 1
M: 0
N: 0
O: 0
R: 3
S: 0
T: 0
U: 3
V: 3
W: 7
X: 1
Y: 8

You'll notice that a lot of ASL signs end up coded the same way; e.g., A, M, N, S, and T all come out as 0 in finger-counting notation. Some of that is going to be eliminated when we add a way to indicate thumb positions; if we counted 0-V (32 symbols) instead of 0-F (16), including the thumb as a binary digit, the initial ambiguity would be much smaller. Some of that is expected, and will remain- it just means that ASL makes some cheremic distinctions that don't matter in this new system. That's fine, because this isn't for ASL; we're just using pictures of ASL as examples because they are convenient. However, si5s, another writing system for ASL, got me thinking of using diacritics to indicate additional handshape distinctions beyond just what the finger-counting notation can handle. Typing diacritics on numbers is difficult, but I can easily add multigraphs to provide more information about finger arrangement in addition to thumb positioning.

First off, there are thumb position diacritics. Since one of the thumb positions is "extended", indicating an odd number, these are only applicable to even numbers, where the thumb position is something else (this would change if I went to 0-F notation instead, excluding the thumb). For these, we've got:


p- thumb touching the tips (or 'p'oints) of the "up" fingers
d- thumb touching the tips of the "down" fingers (as in ASL 8, D, F, and O)
s- thumb held along the side of the hand (as in ASL A)
u- thumb under any "down" fingers, or along the palm (as in ASL 4)
b- thumb between any "down" fingers (as in ASL N, M, and T)
e- thumb extended to the side (as in ASL 3, 5, C, G, L, and Y)


The default is thumb on top of any "down" fingers, as in ASL 1, I, R, S, U, V, W, and X, or across the palm.
The hand position of ASL E is ambiguous between thumb under and thumb over- diacritic 'u' or the default, unmarked state.

Note that 'u' and 'b' are indistinguishable from the default for position F, since there aren't any 'down 'fingers. Position 'b' can be interpreted as "next to the down finger" in cases where there is only one finger down (positions 7, B, D, and E).

Next, the "up" fingers can be curled or not, and spread or not, indicated respectively by a 'c' and a 'v'. Position 'v' of course does not make sense for positions without two adjacent fingers up (0, 1, 2, 4, 5, 8, 9, and A- half of the total!), and 'c' doesn't make sense for 0.

This still does not capture all of the variation present in ASL signs, but it does capture a lot, and, as previously noted, the bits that are missed don't really matter since this is not supposed to be a system for coding ASL!

The ASL mapping list with multigraphs added looks like this:

1: 1
3: 3ve
4: Fv
5: Fve
8: Dd
A: 0s
B: Fu
C: Fce
D: 1d
E: -
F: Evd
G: 1e
I: 8
         K: -
L: 1e
M: 0b
N: 0b
O: 0d or Fp
R: 3
S: 0
T: 0b
U: 3
V: 3v
W: 7v
X: 1c
Y: 8e

And we can code some additional handshapes from the "blended" list:

3C: 3vce
4C: Fvc
5C: Fvce
78: 9
AG: 1p
AL: 0e

etc.

The crossed fingers of the ASL R are not representable in this compositional system, but I like that handshape, so we can add an extra basic symbol X to the finger-counting 0-F, to which all of the thumb position multigraphs or diacritic can be added.

To complete a notation system for a full sign language, I'd need to add a way of encoding place, orientation, and two kinds of motion- gross motion, and fine motion, where fine motion is stuff from the wrist down. I'll address those in later posts, but this feels like a pretty darn good start which already provides hundreds of basic "syllable nucleii" to start building sign words from.

* Of course, other finger-counting systems (like chisanbop, perhaps) could also be used to come up with cheremic inventories and coding systems for them as well.