Category Archives: Ruby on Rails

OLM: What is it?

I’ve mentioned the OLM project a few times, and more than once, I’ve been asked:  “What is this OLM thing you keep talking about?”

So that’s what this post is for:  to provide a plain-English explanation of what OLM actually is/does.

Note: I can’t guarantee that the history of OLM is entirely accurate – I’m assembling this from hearsay, and personal accounts.  If there are any corrections to be made to this post, please comment or email me.

Part 1:  How it Used to Be

Computer Science students, at one point or another, have to computer programs for their assignments.  These programs are written in a myriad of languages (Java, Python, C, the list goes on…), and have to be marked by teaching assistants.

Originally, after students submitted their completed programs, the TA’s would print off the source code and write on the printouts to give feedback on how the code was written.  They would also use a rubric to grade the overall assignment based on predetermined criteria – which isn’t at all unusual in grading student work.

That’s how it used to be.

Part 2: The Birth of OLM

One day, the Computer Science Department at UofT decided that they wanted to write a web application for instructors to manage assignments, and to receive student submitted code.  They also wanted TA’s to be able to log in, and mark the code, almost as if they were doing it on paper.

So OLM (On-Line Marking) was born.  It was written in a web framework called TurboGears by a group of undergraduate students.

And it wasn’t bad.  It’s still used in the department to this day.

Part 3:  OLM is Reborn as…Checkmark…or OLM…or something

The original OLM has a few deficiencies.  The instructors who actually use it could probably rattle off plenty of stories about how, sometimes the client-side of the interface doesn’t entirely agree with the server, or little glitches that require diving into the database to fix.

Plus, the code-base is kind of a hodge-podge.  Not easy to extend, not easy to maintain…the framework that OLM was written on was no longer the “hot framework”, and there was little in the way of support.  Something needed to be done.

So it was decided that OLM would be recreated from the ground up, and would be an evolution based on the lessons learned from the original implementation.  It was going to be rebuilt in Ruby on Rails, and it was going to be awesome.

It was also going to be renamed.  The name “Checkmark” has been bounced around, but should really be more considered as a code-name.  The project is still referred to as OLM, or Checkmark.

(Just came up with a name idea:  MarkUs.  Note to self:  send name idea to supervisor…)

Part 4:  As it Stands

The new implementation of OLM is actually in pretty decent shape.  There are plenty of bug-fixes and unimplemented features, but a lot of the hardest stuff seems to be over – at least, in terms of matching the feature list of the original OLM.

And that’s important, because our supervisor wants this thing polished, tested, and deployed for the Fall term – and it’s got to at least match the original feature set of OLM, if not exceed it.

Part 5:  Want to See It?

If you want to see this thing, you have three choices:

  1. Catch me in person, and ask to see it.  If I have my laptop, I’ll give you a demo.
  2. Get it from our Subversion repository, and get it running on your own machine.
  3. Enroll in a CS undergrad course in the Fall, and who knows…maybe you’ll end up using it.

Anyhow, if there are any OLM related questions, or even some name ideas, please don’t hesitate to post.

Rendering Multiple Partials with Ruby on Rails

So, as we speak, I’m going through a bit of the code that I’ve submitted for the OLM project, and I’ve begun refactoring.

While doing this, I ran into an interesting problem:  I want to use Rails’ remote_function to update two sections of the page with an AJAX call.  For a while, this stumped me, because you can really only have one render call within a controller method, like this:

render :partial => "footer"

But I was determined to render two.  So here’s what I ended up doing:

On the client side, I’ve got this in my view…

<%= remote_function (:url =>{ :action => "codeviewer", :id => @assignment.id, :uid => @uid },
                   :with => "'fid='+fid", :after => "$('working').hide();")%>

And in the Controller, in the “codeviewer” method, I do this: 

render :update do |page|
    page.replace_html 'codeviewer', :partial => 'codeviewer', :locals =>
        { :uid => params[:uid], :filetext => filetext, :annots => annots}
      #Also update the annotation_summary_list
    page.replace_html 'annotation_summary_list', :partial => 'annotation_summary', :locals => {:annots => annots, :fid => @fid}
end

This will render my two partials in the DOM elements with ID’s ‘codeviewer’ and ‘annotation_summary_list’, respectively.

Nice.