stevengharms

Some people, when reviewing for Latin finals pull out a legal pad and a few sharp pencils and then happily go about their day.

Others write a LaTeX guide to:

• Forming the Subjunctive
• Subjunctive Uses

And post them on the internet…

I mean, GOSH, how anyone study without these charts being beautifully typeset via LaTeX? Lauren remarked that she didn’t know my Latin class had a LaTeX-formatting component.

Eep.

elephantus parvus iucundusque recreas in aequa

Latin Mnemonics:

I’m having a difficult time remembering some rote memorization tasks in Latin. I’m trying to make up some mnemonics or rhymes, but am not having much luck.

Special deponent verbs that take “objects” in the ablative case

Subjunctive Conditional Helping Verbs

Can anyone do better?

OK I said that you conjugate the verb fully, but that’s not entirely true. As I’ve not yet learned the subjunctive system, I’m limited to the indicative present and perfect systems. I’ve also included the participles as well as the infinitives.

Might I add that linguistic and string processing with Ruby is a pleasure. Many Years (tm) ago I tried this is French with Java and it was an unholy pain.

Can anyone guess where I’m going with these last few posts?

• Simplified macron-based entry ( \={a}, \={e}, etc.)
• Process simplified text to UTF-8 ( the language of rails )
• Code to process these strings into full conjugations
• Rails as a display engine

What do you think I’m making?

BTW: This code is very much rough draft, it’s enough to handle the ideas, but needs more modularization and more refactoring, so this is not “steven at his best” level code

(more…)

When I write my Latin homework in LaTeX, the source winds up looking like this:

\item[13.] Am\={\i}c\={o}s tr\={\i}st\={e}s exc\={e}pit, ad m\={e}nsam inv\={\i}t\={a}vit, et e\={\i}s perfugium ac s\={o}l\={a}cium h\={\i}c dedit.

{ Aside: You might be thinking that entering “\ = { \ i }” just to get a single character would be a drag, but thanks to Textmate I have created snippets such that Control + letter does all that typing for me }

Now if I want to post this to the web, I need to convert those characters from say “\={\i}” to “\ī”. I would like it to go through the sentence and change each of those LaTeX-macron characters to HTML entities.

Similarly, I occasionally have need to convert LaTeX-macron sequences to UTF-8 codes.

And yet other times I want it to convert those codes to macron-ized characters.

So I wrote a script that takes input of the LaTeX form and will let you specify if you want the output in HTML entity (default), macron characters, or utf8 characters.

The best part is that I’ve written this function into Textmate as an extension so for me conversion is:

Default String

Highlight the LaTeX string

Choose my command with this script in it

Text is replaced, magically!

And it looks like this in a browser…

\item[13.] Amīcōs trīstēs excēpit, ad mēnsam invītāvit, et eīs perfugium ac sōlācium hī

Previously I had shown how I had used Ruby to re-create passive system conjugations. I decided I’d try to add on some functionality and I’ve come up with a Ruby script that handles full verbal system conjugation for 1st and 2nd conjugations (-āre / -ēre) in Latin.

I’ll ultimately build this into a Rails application, but I’m getting the design and debug out of the way with a ruby script.

Check out the code on my tracking page. I need to add support for 3, 3-io, and 4th, but I’m amazed by how light this code has come up to be ( ~ 300 lines with generous whitespace! ).

I’m pretty pleased with my recursive macron validation scheme. Showing off recursive code ( for non Lisp people ) is sorta like being a white guy demonstrating your breakdancing skills. You’re embarrassed to try, you’re embarrased with the result, but even if you do it a little bit, you feel way proud of yourself ( probably too much ).

My printfs aren’t aligning as you see in the output. If there are any printf gurus that can help me let me know.

If you’re interested in my notes or charts, or references, check out amorlatinae.com.

Insomnia is a total bitch. I wouldn’t have thought that Work, Class, Dancing at the Fed would be a formula for “I can’t sleep” but it appears to be so. At least something creative has come out of it.

Latin.

“Now remember Captain, you first have to look at the gender, number, and case of the adjective and coordinate the translated tense with respect to the infinitive”

If you want them to succeed in the world of technical, non-linear, cross-functional thinking, accept no substitute.

The argument could be made “but we live in an area with a strong Hispanic population ( uh, where? Anywhere in the lower 48? ) - Billy should learn Spanish.”

This is an understandable and pragmatic attitude. Spanish is a beautiful language that gifted us Lorca, Marquez, and Cervantes.

But here’s the thing, each step in latin is like a chess game, each tiny decision is the product of several threads collapsing to to a single point, and that point, in turn, opens up a wide path of contingencies that cascade into the text series of associations. Spanish, as I believe it is taught in the introductory level focuses on the quotidian tasks: “no me gusta el helado” or the particularly inane instruction of my French book “j’aime faire de la planche à voile”.

Much like making a chess move of placing a stone in “Go”, Latin invites careful pre-consideration, re-consideration, making a move ( but not taking your hand off the piece! ), un-making the, no wait, committing to the move, and being done with it. I have never, ever, ever encountered anything that taxed my mental faculties in a grueling, grinding, methodical, focused, unrelenting fashion.

And besides, picking up Spanish will be a snap with your Latin base in place. The skills for syntactical analysis would be without compare or companion and Romance languages, are by in large, pretty simple to master once you have one ( or an ancestor ).

That said, there’s always Mandarin or Ancient Greek…

This started off as a bit of an amusement just to see if i could show the elegance of Ruby — and find a way to help me memorize the suffix-addition-heuristics that characterize inflected languages like Latin.

As usual, it quickly became much more than that.

Known Issue:

The macrons are slightly off, particularly in the 3rd person plural ( no vowel before ‘nt’ should ever be lengthened ). I’ll write a fixer routine soon.

[code lang="ruby"]
#!/usr/bin/env ruby
class Verb < Object
  attr_reader :firstpersonform, :infinitive, 
              :perfectstem, :passperfpart, :stem
  def initialize(initString)
    (@firstpersonform, @infinitive, 
       @perfectstem, @passperfpart)=initString.split(/,\s+/)
    pparts=initString.split(/,\s+/)
    @passive_endings = ["r", "ris", "tur", 
                        "mur", "min\xc4\xab", "ntur"]
    @personages = ["First Singular", "Second Singular", 
                   "Third Singular",
                   "First Plural", "Second Plural", "Third Plural"]
  end
  def stem
    # For efficiency, if the iVar @stem is defined, don't go 
    # through this structure
    return @stem unless @stem.nil?
    if @infinitive =~ /?re$/
      return @stem = @infinitive.gsub(/(.*)?re$/,'\\1?')
    end
    if @infinitive =~ /?re$/
      return @stem = @infinitive.gsub(/(.*)?re$/,'\\1?')
    end    
  end
  def to_s
    return "#{self.firstpersonform} #{self.infinitive} 
       #{self.perfectstem} #{self.passperfpart}"
  end
  def present_passive
    local_pe=@passive_endings.clone
    return [@firstpersonform + "r", 
      local_pe[1..-1].map{|x| self.stem + x}].flatten!
  end
  def imperfect_passive
    imperfect_stem = self.stem + "b\xc4\x81"
    return @passive_endings.map{|x| "#{imperfect_stem}#{x}"}
  end
  def future_passive
    fp_stem=self.stem+"bi"
    standards = @passive_endings[2..-1].map{|x| fp_stem + x}
    return [@stem + "b\xc5\x8d", @stem + "beris", standards].flatten!
  end
  def passive_system
    p_sys_hash= { :label=>@personages,
                  :present => self.present_passive,
                  :imperfect => self.imperfect_passive,
                  :future => self.future_passive}
    0.upto(5) do |index|
      printf("%-15s %-10s %-16s %s\n", 
                      p_sys_hash[:label][index],
                       p_sys_hash[:present][index],
                       p_sys_hash[:imperfect][index],
                       p_sys_hash[:future][index]
                      )
    end
    puts "\n\n"
  end
end
[/code]

    x=Verb.new("laudō, laudāre, laudāvī, laudatus")
    puts x
    x.passive_system

    y=Verb.new("moneō monēre, monuī, monitus")
    puts y
    y.passive_system

And the output?

    laudō laudāre laudāvī laudatus
    First Singular  laudōr    laudābār       laudābō
    Second Singular laudāris  laudābāris     laudāberis
    Third Singular  laudātur  laudābātur     laudābitur
    First Plural    laudāmur  laudābāmur     laudābimur
    Second Plural   laudāminī laudābāminī   laudābiminī
    Third Plural    laudāntur laudābāntur    laudābintur


    moneō monēre monuī monitus
    First Singular  moneōr    monēbār        monēbō
    Second Singular monēris   monēbāris      monēberis
    Third Singular  monētur   monēbātur      monēbitur
    First Plural    monēmur   monēbāmur      monēbimur
    Second Plural   monēminī monēbāminī    monēbiminī
    Third Plural    monēntur  monēbāntur     monēbintur

I don’t think that you have to be a Ruby guru to see that Ruby code is incredibly tight. Interestingly enough, Latin, as according to the gospel of Wheelocki, is taught in a very programmatic heuristic manner. You’re taught to carry a certain data file of critical givens on your biological hard drive ( a verb has 4 principal parts, the principal parts of “to praise” …. ) and then are taught a series of transformations to be performed on those 4 principal parts. Working those out is an exercise being a mental computer, mutating data according to heuristic and spitting it out.

Interestingly, when printing technology was much more expensive ( or, students were much more rebellion-prone when forced to pay outrageous prices for books ) Latin instruction was a few terse rules and the homework was “Write out the application of these heuristics to the following data items”. With the rules, and the given inputs, the human scribbler would write out the references he would need to be able to advance to the next chapter.

I have a certain admiration for this method.

But I also have ruby, and remembering how i applied a few map()s or flatten!() statements is just as good.

Latin I Test collection
Originally uploaded by sgharms

I checked out my grades for Fall semester and I got an A in latin. I think these test grades had something to do with it.