Struggling with the Rule of Least Restriction...

Two posts have me thinking about the construction of assignments.

First, Tom Hoffman wrote a nice post excoriating an assignment shockingly chosen as a "model" of good standards-based work:



Given that, for good reasons, we're normally much more polite when we talk about other teacher's work, it was nice to hear Tom let loose. How often do we really get a chance to take apart the tasks we assign to kids? How often to English teachers really define what rigor or analysis means and what it can reasonably mean to a student?

The assignment has me thinking about this post on "the rule of least power". What Dan calls the "rule of least power" I would rather call "The rule of least restriction" (oddly, for once, I'm turning town a computer science metaphor for a special education metaphor). The idea is that when you create an assignment, you should always impose the lease powerful (restrictive) frame on a problem possible. This allows as much re-use/re-interpretation as possible, including students taking things in directions you never dreamed of (just as web developers can take easily-scraped data in directions you'd never dream of).

Thinking back to the assignment Tom was attacking (which makes the standard five paragraph essay assignment look open-ended), I admit that it is more likely to get the kind of predictable essays on Anne Frank that some teachers (or some tests) seem to like getting. But, crucially, it doesn't invite the students to ask any questions themselves or to discover why they might be interested in doing so.

On the other hand, the kinds of open-ended tasks I would rather give students are much more open to failure. And that catch -- the fact that assignments that ask students to do real-world tasks or that ask students to think in an open-ended way are far more likely to end in messy, hard-to-grade work or in outright hands-in-the-air I-don't-know-what-to-do failure... well, that's the problem I've been unsuccessfully struggling with my whole teaching career.

Dan finishes his post by formulating his rule of least power in this way:

1. Tell no student to care.
2. Tell no student how to care.
3. Apply increasingly powerful frameworks to mathematical objects only as the class cares about them.

Please don't confuse this with hardcore, Waldorfian constructivism. I have an agenda, a standard to meet, a lesson objective. But I don't fence my students onto a narrow path to my objective. I instead pave the ground beneath them so that the path to my objective is the easiest and the most satisfying to walk.

It's a high bar he sets. It's hard to figure out how to "pave the ground" so that the path you want students to walk is "the most satisfying to walk". It also strikes me that the more authentic your task, the less control you have about how students approach it, ergo, the harder it is to make sure students reach a standard or meet an objective while carrying it out.

Nonetheless, I'll definitely be challenging myself to think about presenting grammar at least (the most mathy thing I do) in the terms he describes (i.e. set up a problem + least restrictive framework and let it lead the class to the learning I want). Meanwhile, I'll try to think about how this problem-solving framework can map onto the stickier world of open-ended humanities-type assignments.

Using data to remediate, teach, improve

I just found this inspiring math teaching blog, which has me somewhat down about my own teaching and classes. Dan's posts on keeping data in particular have me thinking quite a bit.

I've long maintained that traditional language programs simply ignore the fact that most students are learning virtually no conversational skills. You march the kids through a set of tests and drills designed to teach the language and assume it's worked (or it hasn't), but you don't measure whether they can converse. So what do I do -- I measure whether kids can converse. But that's costly in terms of classroom time and teacher resources, and so I can't actually do it nearly as frequently as I'd need to for it to be really effective.

Looking at the math blog has me thinking about the discrete skills that go into language -- whether that be recalling a piece of vocabulary of conjugating a verb or understanding how enclitic pronouns work. And I'm wondering whether it wouldn't be worth charting student's abilities with respect to these skills much as Dan does for his math students.

Of course, working toward that chart could start to look like that textbook march I was lambasting a paragraph ago... after all, having all the grammatical puzzle pieces that go into language is not the same thing as using language. However, if used with a linguistically informed approach to teaching the skills, and used alongside authentic assessments of actual linguistic skill (could answer comprehension questions on article / could converse for 2 minutes / etc), maybe just maybe something like what Dan's describing would be transformative in a language classroom (maybe, just maybe, in mine).

Does anyone know of any language teachers doing anything like this -- graphing student achievement, remediating quickly, making sure students have actually learned the concepts we think we're teaching... I'd like to think it would be commonplace.

"Yo estoy" or "Estoy yo": word order, subject pronouns, and the sticky question of whether all text books take the wrong approach?

In my lovely grammar-book-in-progress, I make a point to put the subject pronouns after the verbs in all verb charts: hablo (yo) / hablas (tú) / habla (él), etc.

I do this for several reasons:

• To break the speaker's habit (from English) of looking for subject pronouns before the verb


• Because it is perfectly common in Spanish, as evidenced by the y-terminal "yo" forms (doy/estoy/voy/soy) which originated from "do yo / esto yo / vo yo / so yo/ etc.


• To help avoid confusion when enclitic object pronouns are introduced, since "me quieres tú" is easier to parse if you're used to "quieres (tú)" than if you're used to "(tú) quieres"


• Presenting "estoy yo" suggests, unconsciously, that the verb form ("estoy") determines the pronoun ("yo"), rather than that the pronoun comes first and the verb form second. I think this subtly helps prepare students for the fact that Spanish usually omits the subject pronouns, meaning that the verb form is the only source of subject information.

I consider these reasons sound. The only reason I can see for doing it the other way ("yo hablo / tú hablas / etc.") is that it will allow transfer from English. However, I see this as an anti-reason, and I wonder if teaching that focuses on drilling "yo amo / tú amas / etc" encourages other, incorrect transfer, such as "*ella hablas español" (there, the student has transfered both word order and the conjugation from English).

Given this, I'm sad to say I've never seen a Spanish text book that presented the subject pronouns as I do. Has anyone else? If not, are there reasons I'm not thinking of why teaching beginners to say "tú quieres" is a good idea?

Spanish spelling errors in English, and viceversa!

One of the things I focus on in my Spanish teaching is phonetics -- I focus there partly because understanding the phonetics of Spanish will allow my students to have a better accent, but largely because I believe a better grasp of the Spanish phonetic system enables students to understand authentic Spanish much better.

I'm often excited when I see students make the very errors I try to warn them off of in their interpretation assessments, because it lets me reinforce that the phonetic patterns I'm teaching are real (they often seem to only half-believe me). For example, when a student transcribes a Spanish "r" as a "t", "d" or "l", and when they transcribe an intervocalic Spanish "d" as a "v", it's a great opportunity for me to talk about what the Spanish "r" and "d" actually sound like (the "d" being transcribed as "v" is particularly interesting -- the English phoneme that matches the sound is spelled "th", of course, but students know "th" is unavailable as a Spanish phoneme so they hear another voiced fricative -- "v" -- in its place, until, that is, they've internalized the pattern that intervocalic "d"s are like our voiced thorns).

Anyway, today in my geek blog reading, I read the following in a Spanish-speaking hacker's blog:

Benchmarking software is not an easy thing to do. It may look trivial, but it requires a bast amount of time and effort when you want to do it right.

Notice the "b" for a "v" there. What that tells me is that Alvaro almost certainly learned the word "vast" orally, rather than through writing, since his spelling is otherwise impeccable, and that, in spite of being literate in English, he is still hearing English with Spanish phonemes. Which is to say, he hears the voiced labiodental fricative ("v") as a voiced bilabial fricative (β), which he understands as the intervocalic allophone of the phoneme /b/.

Of course, one possible reading of this is to say that Alvaro appears to be a fully functional English speaker who has not internalized the English phonetic system... which suggests that the typical Spanish student who does not understand that, for example, the Spanish phoneme /d/ encompasses something very like our "d" as well as an allophone that is exactly like our phoneme /ð/, which we spell "th", may not be in such a bad situation.

Nonetheless, I think it does make a difference... a student who hears the phrase "de dónde eres" as "devonderes" is surely at a disadvantage (and that error is not that atypical in my experience, provided you provide students with actual examples of Spanish speech, and not with typical American-Non-Native-Speaker-Spanish-Teacher pronunciations.

Dialect and the VP Debate, taken up by a real expert

Who better than linguistics-populizer Steven Pinker to take up my rambling thoughts after the VP debate in an articulate Op-Ed on the style and content of Palin's speech. He agrees that the "en" vs. "eng" is a conscious dial of informality, but clarifies that the accent is authentic (however much it annoys me).

VP Debate

So I hadn't really seen much of Palin until tonight. My God, it felt surreal seeing her on stage with Biden. I also hadn't seen too much of Biden before, who was remarkably sharp. She seemed completely out of place.

I'm struck that I have no idea how affected Palin's speech was. The high frequency of "-in" (in place of "iŋ") for the "-ing" ending and the phrases like "you betcha" and "gosh darnit" are the obvious things about her speech, but she also has quite a strong noticeable accent.

Thinking about the "-in" vs. "-iŋ" distribution, I realize that there's an interesting intersection of accent and formality here -- in this case, (nearly) all speakers use both endings in informal speech and avoid "-in'" in formal speech. What this meant was that Palin's constant use of "-in'" seemed not just like her accent, but like a deliberate attempt to seem folksy, or, alternatively, like a failure to take the debate seriously.

This leaves me wondering about the rest of her accent — it also struck me as out of place in the debate. The question that leaves is, is that just prejudice against her accent, or am I right that her accent was not just non-standard but obnoxiously informal.

Regarding the content of the debate... I'm a bit shocked now to be watching the PBS talking heads suggesting that the debate was a wash... granted, expectations for Palin were low, but she looked rather incredibly outclassed, outsmarted, and outspoken to me.

How I relax...

So if you know me, you know I've been working far too hard the last few weeks. On Friday, I got home and though I had a pile of work to do, I knew I couldn't do anything unless I let myself relax a bit first.

A bit of backstory — one thing I started doing this summer to relax was taking up guitar lessons again, which has been a good thing. One thing I've been working on is learning series of inversions. The thing I like about this exercise is that it allows me to generate a limitless number of new chords, which means I can now help myself get un-bored when I find myself in a guitar rut. Lately, for example, I've been taking some songs I wrote that have very simple progressions (just C and G basically) and playing with different inversions and voicings.

Anyway, I realized what I really wanted to do on Friday was to write a program to generate those series of inversions for me. Here's an example of how it works...

./inverter.py 3x043x
Printing inversions of  3x043x
--x--x--x-
--3--8-12-
--4--7-12-
--0--5--9-
--x--x--x-
--3--7-10-

In that case, there are three inversions generated because it's a three note chord. If I give it a chord with four notes, it will of course generate four inversions:

tom@hydrophax:~/Projects/chord_inverter$ ./inverter.py 3x443x
Printing inversions of  3x443x
--x--x--x--x-
--3--7--8-12-
--4--7-11-12-
--4--5--9-12-
--x--x--x--x-
--3--7-10-14-

I can also make it print out the notes so I can keep track of where the root is:

$ ./inverter.py --include-notes x3201x
Printing inversions of  x3201x
--x------x------x-----
--1-(C)--5-(E)--8-(G)-
--0-(G)--5-(C)--9-(E)-
--2-(E)--5-(G)-10-(C)-
--3-(C)--7-(E)-10-(G)-
--x------x------x-----

And of course it can move down as well as up:

$ ./inverter.py --down xxx988
Printing inversions of  xxx988
--8--3--0-
--8--5--1-
--9--5--0-
--x--x--x-
--x--x--x-
--x--x--x-

Finally, it handles alternate tunings -- here's the inversions of D in drop-D tuning for example (which, by the way, illustrate that not all inversions are pleasant to finger -- check out the second chord):

$ ./inverter.py --tuning DADGBE 0xx323
Printing inversions of  0xx323
--3--6--9-10-
--2--3--8-11-
--3--6--7-12-
--x--x--x--x-
--x--x--x--x-
--0--5--8-11-

This means it will work for any fretted instrument.

The next step would be to have it name the chords, but of course that's kind of complicated. One of the things that pops out of this sort of exercise are "oh duh" moments like when I generated this series based on Am7 and found that the 2nd chord was already fixed in my muscle memory:

--x--x--x--x-
--5--8-10-13-
--5--9-12-14-
--5--7-10-14-
--x--x--x--x-
--5--8-12-15-

It took me a second until I realized something I already knew: an Am7 has all the same notes as a C6, which is what I'm used to calling 8x798x...

The next step would be to cook up a web interface and make this into a handy tool for everyone. In the mean time, the full source code follows... (by the way, if anyone knows how to attach a generic file to a post or do the equivalent of an lj-clip on blogger, please let me know!)

#!/usr/bin/env python

import types
UP = 1
DOWN = -1
notes = ['C','Db','D','Eb','E','F','Gb','G','Ab','A','Bb','B']
synonyms = {'C#':'Db','D#':'Eb','F#':'Gb','G#':'Ab','A#':'Bb'}
x = None

def get_degree (note):
    '''Return the numeric degree of the note named note.
    '''
    return notes.index(synonyms.get(note,note))

def get_name (degree):
    '''Return the name of the note from the degree'''
    abs_degree = degree % 12
    return notes[abs_degree]

def add_to_note (note, steps):
    return get_name(get_degree(note)+steps)

def get_interval (a,b):
    """Return the interval in chromatic steps between two notes
    """
    a = get_degree(a)
    b = get_degree(b)
    if a > b:
        b += 12
    return b - a

def pad (txt, length, pad_char = '-'):
    if len(txt) > length:
        raise ValueError
    elif len(txt) == length:
        return txt
    else:
        pad_with = length - len(txt)
        left = pad_with / 2
        right = pad_with / 2 + pad_with % 2
        return pad_char*left + txt + pad_char*right
    
class String:

    def __init__ (self, root='A'):
        self.root = root
        self.nroot = get_degree(self.root)

    def get_note_for_fret (self, n):
        return get_name(self.get_degree_for_fret(n))

    def get_degree_for_fret (self, n):
        return self.nroot + n

    def get_next_fret_in_chord (self, start, chord, direction=UP):
        for n in chord:
            try:
                assert(n in notes or n in synonyms)
            except:
                raise ValueError('Chord contains invalid note %s'%n)
        if start is None: return start
        n = start + direction
        chord = [synonyms.get(note,note) for note in chord]
        while self.get_note_for_fret(n) not in chord:
            n += direction
        return n

def get_fingering (fingering):
    if type(fingering) in types.StringTypes:
        fingering_ltrs = fingering[:]; fingering = []
        for char in fingering_ltrs:
            if char in ('x','X'):
                fingering.append(x)
            else:
                fingering.append(int(char))
    return fingering

def fingering_to_txt (fingering):
    s = ''
    for f in fingering:
        if f is None: s += 'x'
        else: s += str(f)
        s += ' '
    return s[:-1]

class FretBoard:

    def __init__ (self, strings='EADGBE'):
        self.strings = [String(n) for n in strings]


    def fingering_to_chord (self, fingering):
        fingering = get_fingering(fingering)
        chord = []
        for fret,string in zip(fingering,self.strings):
            if fret is not None:
                chord.append(
                    string.get_note_for_fret(fret)
                    )
        return chord

    def invert_chord (self, fingering, direction=UP, chord=None):
        fingering = get_fingering(fingering)
        if not chord:
            chord = self.fingering_to_chord(fingering)
        next_fingering = []
        for fret,s in zip(fingering,self.strings):
            if fret is None:
                next_fingering.append(x)
            else:
                next_fingering.append(
                    s.get_next_fret_in_chord(fret,
                                             chord,
                                             direction)
                    )
        return next_fingering

    def get_inversions (self, fingering, direction=UP):
        chord = self.fingering_to_chord(fingering)
        n_fingerings = len(set(chord))
        fingerings = [get_fingering(fingering)]
        for n in range(n_fingerings - 1):
            fingering = self.invert_chord(fingering,
                                          direction,
                                          chord)
            fingerings.append(get_fingering(fingering))
        return fingerings

    def print_inversion_series (self, fingering,direction=UP,include_notes=False):
        fingerings = self.get_inversions(fingering,direction)
        lines = []
        for n,s in enumerate(self.strings):
            line = '-'
            for fing in fingerings:
                fret = fing[n]
                if fret is not None:
                    note = '(' + s.get_note_for_fret(int(fret)) + ')'
                    fret = str(fret)
                else:
                    note = ''; fret='x'
                if include_notes:
                    line += pad(fret,3) + pad(note,4)
                else:
                    line += pad(fret,3)
            lines.append(line)
        lines.reverse()
        for l in lines: print l
        
                
if __name__ == '__main__':

    # If called from the commandline, treat our argument as a chord
    # and print the series of inversions...
    import optparse

    parser = optparse.OptionParser(option_list=[
        optparse.make_option('--tuning',
                             action='store',
                             type='string',
                             dest='tuning',
                             default=None,
                             help='A custom tuning'),

        optparse.make_option('--down',dest='direction',default=UP,action='store_const',const=DOWN,help='Print the series of inversions moving up the neck (down in pitch). Default is to move down the neck (up in pitch'),
        
        optparse.make_option('--include-notes',default=False,const=True,action='store_const',dest='include_notes')
        ]
        )
    (options,args) = parser.parse_args()
    
    if False:
        1
    if options.tuning:
        fb = FretBoard(strings=options.tuning)
    else:
        fb = FretBoard()
    include_notes = options.include_notes
    direction = options.direction
    for a in args:
        try:
            print 'Printing inversions of ',a
            fb.print_inversion_series(a,
                                      include_notes=include_notes,
                                      direction=direction)
        except:
            import traceback; traceback.print_exception()