Will.Whim

A weblog by Will Fitzgerald

Monthly Archives: June 2011

Eliot, Causley and Reading Poetry

There is a new iPad application out, a multimedia presentation of TS Eliot’s The Wasteland. I’ve only just begun to explore it. It seems to have its oddities, as all things do, I suppose: two pictures of Bob Dylan in the photo section, but only one of Eliot himself. But I’d never seen pictures of young Ezra Pound, and I thought—I know that guy, the confident artiste completely sure of his editorial prowess, more than willing to slash his way through the manuscript of The Wasteland; his edits are also included.

And then there is a video of Seamus Heaney discussing Eliot and his poetry. Among other things, he talks about growing into Eliot’s work, having first read him prior to university, then teaching him as a lecturer, then later as a working poet, and now, it appears, it is simply part of the Heaney’s mental furniture. When I read Eliot as an undergraduate, I knew I needed a vade mecum—how else would I understand a poem whose inscription is a Latin one which itself quotes Greek? I could never read him on my own. And so, I delighted as much in knowing about the poetry as the poetry itself. Still, I always thought myself a lesser scholar; marginal notes were what I had, but what I needed was an Oxbridge education. I was no Pound. To change the metaphor and crib from Prufrock, I was an attendant lord.

An attendant, anyway—and, in any case, eventually, not even that, except to pull down a copy of Eliot’s Collected Poems (now, alas, gone missing from my library), or to pull out a half-remembered quotation from my memory. Heaney’s stages of poetry ring seem familiar enough: we might read poetry in school, we might teach poetry at school, but, unless you have some kind of professional interest, it’s unlikely that you be reading, discussing, or enjoying much poetry at all. So, I hope that the iPad application will be a good way to enter into this great poem, anyway.

During Lent, I discovered the poetry of Charles Causley, a Cornwall poet who wrote during the second half of the last century—in other words, after Pound and Eliot and the like. The poem that caught my eye—and ear, due to a marvelous musical setting by a group called Antiphony, is “I am the great sun,” a cri de coeur of Christ from the cross:

I am the great sun, but you do not see me,
I am your husband, but you turn away.
I am the captive, but you do not free me,
I am the captain you will not obey.

Causley’s poetry is a little hard to come by, legally, at least: he was known, I think, mostly in Great Britain and by professional poets. I found a used copy of his Collected Poems 1951-2000 on Amazon.com. He wrote poetry that children liked, though, and he had some fame at that. Causley’s poetry is fairly accessible, especially compared to Eliot. He often writes in ballad-like forms. His poems usually rhyme, and fit on one page. They make use of the old stock of English poetry: repetition, assonance, alliteration, familiar imagery, meter (but often subtle meter for all that). A fair number of his poems are war poems—he was a soldier in the second world war. And many of his poems speak of spiritual realities. Here is an odd one:

Infant Song

Don’t you love my baby, mam,
Lying in his little pram,

Polished all with water clean,
The finest baby ever seen?

Daughter, daughter, if I could
I’d love your baby as I should.

But why the suit of signal red,
The horns that grow out of his head,

Why does he burn with brimstone heat,
Have cloven hooves instead of feet,

Fishing hooks upon each hand,
The keenest tail that’s in the land,

Pointed ears and teeth so stark
And eyes that flicker in the dark?

Don’t you love my baby, mam?

Dearest, I do not think I can.
I do not, do not think I can.

Yes, well: simple words, classic images, short, rhyming lines; perhaps easy enough to dismiss as a child’s poem. But the images and rhymes have a staying power; it’s a poem you can take with you.

I don’t have a vade mecum for Causley; perhaps I need one to tell me whether this is one of his children’s poems, but I think not. I can enjoy it, live into it, even “be read by” it without an apparatus, just as I can enjoy singing without performing, or programming for the joy of it. I don’t quite know how well I will come to know Causley’s poems, but I’m glad to have a few in my mind and heart.

ʬ

I discovered “extended IPA” symbols today, including ʬ (smacking your lips). Which I think would be an awesome symbol for “will/whim.”

ʬ

Father’s Day is coming, ʬ.net is available, but my family is not geeky enough to get it for me…

F# One liners to impress your friends

In the spirit of 10 Scale One Liners to impress your friends, here are some F# one liners:

  1. Multiply each item in a list by 2.
    This is simple to do; F# has map: [1 .. 4] |> Seq.map (fun x -> x * 2);;
    val it : seq = seq [1; 4; 9; 16]
  2. Sum a list of numbers.
    This is simple to do, too F# has sum:[1 .. 4] |> Seq.sum;;
    val it : int = 10
  3. Verify if any item in a sequence exists in a string
    This is simple to do; F# has find:>["f#"; "scala"] |> Seq.find(fun w -> "this tweet contains f#".Contains(w));;
    val it : string = "f#"
  4. Read in a file (boooring!)F# has all the libraries of .NET behind it. It’s easy to treat read lines as a sequence
    File.ReadLines(@"file.txt") |> Seq.map(fun l -> l.Length) |> Seq.sum;;
    val it : int = 198183
  5. Happy birthday to you!Also boring… but here it is:
    [1 .. 4] |> Seq.map (fun i -> "Happy Birthday " + (if i = 3 then "dear NAME" else "to you")) |> Seq.iter Console.WriteLine;;
  6. Filter (actually, partition) lists of numbersUsing the built in partition function, we can easily partition lists:
    [49; 58; 76; 82; 88; 90] |> List.partition (fun i -> i > 60);;
    val it : int list * int list = ([76; 82; 88; 90], [49; 58])
  7. Fetch and parse XML
    Again, the .NET libraries come in handy. Unfortunately, this isn’t exactly a one-liner in F#. But Don Syme shows how to do this both synchronously and asynchronously.
  8. Find the minimum and maximum in a list.
    F# has min and max built in:
    > [49; 58; 76; 82; 88; 90] |> Seq.min;;
    val it : int = 49
    > [49; 58; 76; 82; 88; 90] |> Seq.max;;
    val it : int = 90
  9. Parallel processing
    This example comes from J Rocha. Assume we have an ‘isprime’ method (which, of course, will be somewhat expensive to calculate), and we want to get a count of prime numbers grouped by their final digit, from 1 to 50,000. PSeq processes sequences in parallel (so filtering and grouping and mapping are happening in parallel in this example):
    > [|1 .. 50000|] |> PSeq.filter isprime |> PSeq.groupBy (fun i -> i % 10) |> PSeq.map (fun (k, vs) -> (k, Seq.length vs)) |> Seq.toArray |> Seq.sort |> Seq.toList;;
    val it : (int * int) list =
    [(1, 1275); (2, 1); (3, 1290); (5, 1); (7, 1288); (9, 1279)]

Is this impressive enough?

The Trumpet, Volume 1, Issue 2

There are more details at the http://SingTheTrumpet.com, but let me make a quick announcement that The Trumpet Vol 1, Issue 2 is available:

I’ve been working on this pretty intensively for about a week.