Syntax highlighting

PlasticBoy got me most of the way there when it came to syntax highlighting. All I had to do was figure out how it fit into my .vim directory structure, which is a clone of Martin Greffel’s excellent setup. This turned out to be pretty straightforward

• Save the mkd.vim file to ~/.vim/syntax/mkd.vim
• Put the following in ~/.vim/ftplugin/mkd.vim:

  " markdown filetype file
  if exists("did\_load\_filetypes")
   finish
  endif
  augroup markdown
   au! BufRead,BufNewFile *.mkd   setfiletype mkd
  augroup END

• For file type auto detection (i.e. if you want syntax highlighting automatically loaded for files with extensions like .markdown and .mdown), add this to ~/.vim/ftdetect/markdown.vim:

  autocmd BufNewFile,BufReadPost *.mkd,*.markdown,*.mdown set filetype=mkd

Converting a document or selection from Markdown to HTML

Converting markdown to html from inside of vim is nice and easy. In fact, you don’t even need the syntax files installed. You do need the markdown script installed somewhere (say, /usr/local/markdown).

We can take advantage of vim’s command line filtering here, and simply run the markdown command on all or part of the document, right from within vim. To convert the entire document, use the percent sign:

:%!/path/to/markdown --html4tags

If you just want to convert part of a document, say a highlighted visual block, you can just omit the percentage sign:

:!/path/to/markdown --html4tags

Bam! Your document is converted. Neat, huh?

All of the below examples are intended to outline the interactions you might need to answer specific reporting needs. It is important to note that these queries are in no way optimized, and could quite possibly put excess load on your system. Further, some of these are not actually tested (i.e. they are pulled or adapted from memory), and are only included as guides to help you get going in the right direction.

These queries are focused on Blackboard Learning System 8.x, however they should run just as well on 9.x (Blackboard Learn) releases.

One of the broader questions that you may be trying to ask is, how are people using the system? Since there are any number of contexts in which that question can be answered, we’ll start by breaking it down into more manageable chunks.

Aggregate Tool usage

A broad picture of the tools being employed across the application can give hints about how instructors are using the system to actually teach. For example, we might start by asking how many instructors are using tools like discussion boards and assessments in their courses.

There are no built in reporting methods with which to view specific tool usage in Blackboard. Looking at the database, we are left with some detective work to determine which tables and fields will be most useful. Like all detective work, there is some guessing involved. One good guess is that some of the data we are looking for can be found in the ACTIVITY_ACCUMULATOR table.

We also might be able to guess that the column within the ACTIVITY_ACCUMULATOR named internal_handle has a list of tool identifiers available on the system. From there, we can start building a query to, say, count the most accessed tool pages as listed in the accumulator, grouped by tool and sorted by page view.

SELECT COUNT(*) AS page_views, activity_accumulator.internal_handle
FROM activity_accumulator
WHERE activity_accumulator.event_type = 'COURSE_ACCESS'
GROUP BY activity_accumulator.internal_handle
ORDER BY COUNT(*) DESC

This gives us an idea of the tools available for further inspection, as well as which ones we might want to take a closer look at.

Tool usage by course

Now that we have the tools and their identifiers, we can use the ACTIVITY_ACCUMULATOR table to begin piecing together answers for a more specific set of questions, such as: Which courses are using which tools the most? Are some departments using certain tools more than others? Can we contact instructors that are using specific tools (i.e. in order to get feedback and offer further training)?

Say we wanted an idea of how many instructors were using assessments in their course. If we assume that the cp_test_manager is the handle for the Test Manager in the Control Panel, then by looking at how often the instructor views that tool’s page we can surmise a rough usage pattern. In other words, courses with a significant number of hits to that tool can be assumed to be using said tool in some fashion.

SELECT COUNT(*) AS page_views, course_main.course_name, course_main.course_id
FROM activity_accumulator, course_main
WHERE activity_accumulator.course_pk1 = course_main.pk1 
AND activity_accumulator.internal_handle = 'discussion_board' 
GROUP BY course_main.course_name, course_main.course_id 
ORDER BY page_views DESC;

This can be done with other tools, such as the discussion board, to make educated guesses about its use. Note that since the “cp_” designation appears to indicate a control panel page, hits to the discussion_board page should be assumed to be by all users in the course, and not limited to the instructor in the case of the test manager.

Tool deployment

Learning Objects Campus Pack LX products don’t show up in Blackboard’s internal tool handle tables in the same way as native tools. However, you can get an idea of the usage of these tools by looking at which courses have them installed. Running queries against the CONTENT_HANDLER table will let you see how many blogs or wiki’s have been installed a course.

SELECT course_main.pk1, course_main.course_name, 
course_main.course_id, course_contens.pk1, course_contents.title 
WHERE course_contents.crsmain_pk1 = course_main.pk1 
AND course_contents.cnthndlr_handle = 'resource/x-lobj-journal';

While this may not paint as clear a picture of usage as page view counts, it will still allow you to make general assumptions about pedagogical impacts.

Enrollment and Participation

You can also get an approximate idea of enrollment in a course using data in the activity accumulator. This can be done by joining the acumulator on the course_users and course_main tables. Querying the course user’s role and their last access is often a better indicator of recent activity in a course than the built in “active user” numbers generated by the GUI reporting tools. This is especially true if you are only looking for activity in a course within a specific timeframe, such as a term/semester.

Course usage by term can also be determined by querying on the start date fields if they are populated. In this way you can identify not only course usage in general, but also student vs. faculty usage by term.

If you don’t have start date fields populated in your tables, you may need to query off of other fields. If your course id’s contain term data, for example, you might be able to do something along the lines of “LIKE ’200809%’”.

Other Usage Metrics and Tools

The administrator manual documents some of the feilds and tables above, but a full schema documentation does not appear to be available at this time. I’ve been told that version 10.x will ship with a fully documented (and public?) schema, but that’s probably more rumor than fact at this point.

How do you aggregate usage on your system? Are there specific tools you use in your reporting process (i.e. Crystal Reports, SAS)? Are you using GUI-side tools like the nascent Project ASTRO? Are there open source tools that you are using? Do you have special queries you run to address certain questions?

• TypeError: this.visibleRows[pos] is null
• syntax error
• TypeError: Result of expression ‘a’ [null] is not an object.

After digging up a thread with a helpful post by Eric Knickerbocker that suggested that this might have been caused by an errant “smart View”, we were able to confirm that they had indeed being playing with smart views. That same thread offered a solution involving some URL hacking. This allowed us to get the tool to load appropriately,using a url that looked something like this:

https://your.server.edu/webapps/gradebook/do/instructor/manageCustomViews?course_id=THECOURSEID

While we still have not been able to determine the specific steps to replicate the problem, we have some theories. It may have something to do with smart view attempting to include disabled users in a view. Shortly after purging a data source, we noticed that the problem seemed to have resolved itself – only to return a day later. This was before the instructor had removed all the smart views in the course. A few of the smart views in question were being built on specific users, i.e. the view was created by selecting all the users in the list. It may be that certain logic behind the smart view function is failing when it attempts to access a record that is no longer enabled.

Safety First

If you choose to implement the above solution to get a grade center back, you should back up your data first. Downloading it in the form of a comma separated or tab delimited file will make sure that you have a local copy that is readily accessible.

You can do this by using the same method as described above. For example, to get to the download page without loading the grade center, you should be able to access a url like this:

https://your.server.edu/webapps/gradebook/do/instructor/downloadGradebook?dispatch=viewDownloadOptions&course_id=THECOURSEID

Generating a full course export and archive is also highly recommended before proceeding with something like this.

All array-related functions use needle, haystack and all string-related functions use haystack, needle.

There are certain words in the english language which no matter how many times I spell or use them, I always have to pause and wonder if I got it right. The best way to conquer such elusive patterns is by placing them in context. Derek does a nice job of illustrating the context for these PHP search functions.

After a little digging in the manual and perusing a few conversations, I ended up with something that might look like this:

@people.delete_if { |person| @roster.include?(person) } #short and sweet!

I gotta admit – as much as I love brevity, that is almost too short. The nice thing about some of these common control structures, and for that matter functions that are named like in_array, is that if you are careful you can write code that is almost self-documenting.

foreach ($roster as $participant) {
 
	if ($found_participant = array_search($participant, $people)) {
 
	    unset($people[$found_participant])
 
	}
 
}

That is, if you asked a stranger to just read the words in the passage above out loud to themselves, chances are they will be able to figure it out. I’m not so sure that’s the case with that beautiful little line of Ruby. Maybe it’s just me and my relative inexperience.

Speaking of readability, Henrik Nyh has a nice little piece on making your function calls more readable in Ruby.

After a few weeks of letting the thought stew in the back of my mind, I had almost forgotten about it. Then serendipity and the interwebs teamed up in the form of a Boing Boing post about the Dvorak layout and the wonderful DVzine.org. That was enough to give my motivation a kick in the pants. Not being entirely comfortable with the thought of rearranging the keys on my keyboard (or washing them, for that matter), I purchased a cover for my keyboard. I started practicing and drilling.

By the time my rubber cover had arrived, I was well on my way to a respectable, peck-free typing speed. I even got a warm, fuzzy morale boost when a colleague indicated his intent to defect from the QWERTY ranks as well.

Helpful hints

Every day I can feel my speed and accuracy improve. The faster I get the easier it is to learn. Here are a few concepts I have found useful so far.

• Relax, and remember to breathe. It’s hard to concentrate if you are focused on beating the clock. Keeping a consistent pace is more important than trying to increase your words-per-minute. Try to find a rhythm.
• Don’t throw away that QWERTY. It makes for a slower start, but not being able to look down will help you memorize the new layout. So don’t start popping off those keys just yet. Wait until you are more comfortable with the locations of the Dvorak layout so you’re not tempted to look down – otherwise you’ll be back to hunting and pecking.
• Keep a printout of the Dvorak layout stuck to your monitor for easy reference. This will help with the next tip.
• Don’t Panic.
• Practice. Every day, several times a day. Short 15-30 minute bursts are best.
• Just do it. I’ve seen suggestions to go “cold turkey” and drop QWERTY all at once, and I don’t think I could. It would be too stressful, and take all the fun out of it. So try typing an email or a blog post (this post was composed in Dvorak) here and there.

Useful tools

• I’ve found PowerTyping’s Dvorak lessons to be the best mix of drills and word review.
• dvorak.nl is also nice, although I found myself needing more drills at first to familiarize myself with the keyboard.
• Ten Thumbs is a stand-alone app that works well, though I’m still not convinced it’s worth that much dough. We’ll see. It does offer tips on finger placement, which is helpful.
• KB Covers offers a thin rubber cover that is an alternative to dissecting your keyboard. It is nowhere near as useful as the above tools and concepts have been, but it does serve as a sort of mental safety net and confidence builder. The cover was a bit thinner than I had expected, but it fits well, looks good, and seems durable.

Happy typing!

This goes a long way in increasing awareness about a host of disabilities. It also is a very useful tool in combating the fear that stems from not knowing how to communicate with someone. How many times have you seen a person completely ignore someone else, for no other than they didn’t know how to communicate with them?

I found out about it because today is veterans day. The version I saw, in paper form, was branded with a VA logo instead of the United Spinal brand on the cover. Whatever form you find it in, grab (or order) a few extra copies to send along to friends and colleagues.

However, I still need to be able to go back and fix things. Doing so makes use of some funky looking chmod wizardry:

chmod -R u=rwX,go=rX foldername/

Where foldername is the name of the folder and contents you want to “fix”. Note that if you are at UVM and on their “zoo” cluster, they have a form that will let you do this to your entire directory. The above snippet does the same thing, but gives you a little more fine grained control over what you are “fixing”.

Update: At the time of writing, I couldn’t find the link to where I found the above recipe.

How do I know if I have orphaned users?

Symptoms include a “+” (that’s a “plus”, or “addition” sign) nexxt to the user’s id in the manage students listing. The student often won’t see the course listed in their “MyWebCT” area when they log in, even though they are listed in the course with the fated plus mark next to their id.

How might one find a home for orphaned users?

It seems that one cause of orphanage among users in WebCT concerns how they are marked for inclusion in the course via the “Courses” field and the “Registered Courses” field. For example, the course in question might be listed in their “Registered Courses” list for the user, but not listed in their “Courses” list. The solution is to add them to the course (in other words, in admin you are making the courses field look the same as the Registered courses field). This can be done, starting in Admin -> User Management:

1. querying for the student,
2. checking the box next to their name
3. clicking on the “Courses” button
4. adding the student to the course.

The student should no longer be an orphan. Logging back into the course should show them without a plus next to their name.

Great! Now how do I do this for more than one?

Easy enough for one user, but how about a whole course full of users? This was a little harder to find, since it doesn’t seem to let you add more than one user to a course. Until you find the “Add Multiple Students” button. Then it goes something like this (once again in User Management):

1. Perform a query on the “Registered Courses” field, where it equals the course id (not equals, as there may be other courses in the fields you are searching for).
2. This should give you a list of students. Choose “Select All”.
3. Click “Add Multiple Students”.
4. Select the course or courses you wish to add the students to and select add.
5. Click “Verify” (you might be able to just continue here, but verify seems to work).
6. Select all
7. Add.

You should now have a course full of non-orphaned users.

“One of the most useful skills you can utilize when performing date math is taking full advantage of the UNIX timestamp. The UNIX timestamp was built for this kind of work.”

The comment goes on to give some relevant examples. If you aren’t a fan of doing date math – in any language – take this concept to heart. It will make your life easier.

Comments like this are a great example of why the PHP Manual is one of the best reference manuals out there. I would bet that this documentation format has been a big driver behind the popularity of the language. Any good API, manual, or set documentation should include moderated comments.