With last week’s release of Blackboard Learn Release 9, the first release in the new Project NG series, people can begin to explore my implementation of the Learning Environment Connector API to integrate Sakai 2.5.3+ with Blackboard.

The integration consists of two parts, a Building Block portion contributed to the OSCELOT community found here
http://projects.oscelot.org/gf/project/bb-sakai-lec/ under the Apache License, Version 2.0,
and a Sakai project contributed to the Sakai community here
http://confluence.sakaiproject.org/confluence/display/BBLEC under the Educational Community License, Version 2.0. Combined, the two enhancements enable the integration of Sakai user, course and enrollment data into Blackboard and allows the users to access their Sakai course data from within the Blackboard user interface.

While the initial release of the connector implementation should still be considered beta, we’ve successfully tested and demonstrated the implementation and plan to begin further testing by the end of February. Hopefully we’ll have the integration running in production locally for the start of the next Fall semester.

For further details, including screenshots, please visit either of the links above. I’m looking forward to hearing your feedback!

I haven’t posted an update in awhile since I’ve been “heads down” working on the integration between the Sakai CLE and Blackboard learning environments. It’s a lot to do in a short amount of time, but things are going well…I have good help. More updates/details regarding the project to follow once the connector is released alongside Blackboard 9, the first release of the new Project NG series.

I’ve given some thought to the limitations of current enterprise learning systems (LMS, CLE, ePortfolio, etc), and thought it’d be a good time to elaborate on them after reading Mary Grush’s interview of Gary Brown in the recent Campus Technology publication [1], entitled “The Future of Web 2.0″ (perhaps more appropriately entitled “The Future of the LMS”).

Some personal observations regarding these systems:

• Despite best intentions, tools within the systems are not the best of their kind, and, unless mandated, are not the ones chosen by students and faculty. Many of the tools are re-implementations of existing standalone content-based tools (file storage, discussion, wiki, blog, messaging, presentation). A lot of resources are wasted (IMHO, fruitlessly) trying to compete with the alternatives.
• Content created in external systems typically needs to be recreated in or imported into the LMS.
• A significant amount of development effort goes into the framework services provided to support the tools. This is not necessarily a bad thing if these services support the pedagogical tools I mention later.
• The level of integration possible is much greater then the level of integration realized. Is the need realistic and does it outweigh the limitations posed by standalone components?
• The solutions are heavy-weight; they’re generally prepackaged with several default preselected components. It requires a lot of effort to strip down and/or reconfigure to meet specific needs.

Since the LMS can’t compete with content generating alternatives, the concentration should be on tools to manage and facilitate pedagogy itself. Strip the LMS down to just those necessary parts and focus on making them extremely easy to use. I’m stepping out of my realm here, but it seems the gaps we should be filling are on management of assignments, learning outcomes, curriculum, workflow, rubrics, assessment, etc. Leave the content creation, discussion and presentation to those systems that manage it best. Rather, allow for users to submit links to their external content for assessment purposes. This is quite similar (perhaps exactly) the system that Gary Brown refers to during the interview:

Right now at WSU, one of the things we’re developing in collaboration with Microsoft is a “harvesting” gradebook. So as an instructor in an environment like this, my gradebook for you as a student has links to all the different things that are required of you in order for me to credit you for completing the work in my class. But you may have worked up one of the assignments in Flickr, another in Google Groups, another in Picasa, and another in a wiki. Maybe you’ve also made some significant contributions to Wikipedia. So, I need a gradebook where I have the link you’ve provided me, rather than a copy of the work, and the gradebook should be capable of pulling in all of these various sources.

If there’s any difference, I’m almost certain it is in my idea of the implementation. Unfortunately, WSU has chosen to “collaborate” with Microsoft on a solution, so I assume we’ll never know for sure.

Going back to early 2004, when my group at The (very soon to be defunct) Living SchoolBook was working on developing our own portfolio system, we discussed using RDF to link artifacts stored internally or externally with system-defined learning outcomes (the idea, IIRC, was Matthew Metnetsky’s). To make a long story short, feature creep and resource limitations drove us to switch to development of Goal Management within Sakai. Somewhere during that move I, regretfully, lost track of the idea of using RDF, but I think it applies now more then ever. Instead of requiring content to reside in one solution or another, we should augment the solutions with RDF capabilities to allow creation of “meaningful” relationships between content. The LMS focus then, would be management of the pedagogical parts that are semantically linked to content and providing a facility to crawl and query the resulting graphs.

Update – Just to clarify, I don’t think RDF is a solution in and of itself. There are obviously serious concerns that need to be addressed regarding privacy, authentication and authorization. I’m also not trying to say that tools for minor edits within the LMS are unnecessary/useless, and that there is no need for local copies (snapshots) of external content. The point I’m trying to make is that we need to abandon approaches that require users to use built-in content creation/organization/presentation tools. The focus needs to be on an open architecture that supports streamlined interaction (enhanced usability) with external tools integrated with the pedagogical tools that the LMS does best. Recent trends/movements towards portable data formats and open standards-based architectures to facilitate integration may support this possibility.

[1] Mary Grush, “The Future of Web 2.0,” Campus Technology, 2/27/2008, http://www.campustechnology.com/article.aspx?aid=58872

We got ourselves into a little bind and had to add a few hundred users to our portfolio system in a short period of time. The alternatives were to figure out a way to script the addition of users or manually enter the students and add them to the appropriate worksite. Since I’m always up for a challenge, I decided to tackle the script…believe it or not I’ve never had the opportunity to work with perl and/or web services, so this was a great opportunity to get my hands dirty.

A quick search led me to Will Trillich’s helpful documentation over at Serensoft, which enabled me to get started pretty quickly. There was also some documentation over in the Sakai Confluence wiki that helped with the configuration. In order to use web services in sakai, you need to turn it on in the sakai.properties configuration file as follows:

# Enable web services login
webservices.allowlogin=true


If that line doesn’t exist, go ahead and add it.

Here’s the perl script I ended up with to add users from a csv file to sakai and enroll them in a specific course…play nice, it’s my first:

#!/usr/bin/perl

#
# Perl script to add a list of users to sakai and enroll
# them in a given course.  Users are read from a csv formatted
# file with lines like the following:
#
# SUID;DOB;LastName;FirstName;NETID
#

use SOAP::Lite;

# Sakai service location constants
use constant {
    LOGIN_WS => "/sakai-axis/SakaiLogin.jws?wsdl",
    SCRIPT_WS => "/sakai-axis/SakaiScript.jws?wsdl",
    SYR_ADDY => "\@syr.edu",
    DEFAULT_ROLE => "access",
};

# Initialize variables from command line parameters
my $userlist = shift;
my $host = shift;
my $id = shift;
my $password = shift;
my $siteId = shift;
my $roleId = shift;

# Routine to display some usage information
sub usage {
    print "\nUsage: useradd.pl filename host username password [siteId] [roleId]\n\n";
    print "e.g.  useradd.pl userlist.csv http://localhost:8080 admin admin_pass\n\n";
}

# Routine to connect to sakai login service
sub sakaiLogin {
    return $host.LOGIN_WS;
}

# Routine to connect to
sub sakaiScript {
    return $host.SCRIPT_WS;
}

# Routine to create an email address
sub makeEmail {
    my $username = shift;
    return $username.SYR_ADDY;
}

# Create password
sub makePassword {
    my $username = shift;
    my $dob = shift;
    ($month, $day, $year) = split(/\//, $dob);
    $month = ($month < 10) ? "0".$month : $month;
    $day = ($day < 10) ? "0".$day : $day;
    return $username.$month.$day;
}

# If either are undefined, display usage and exit
if (!$userlist ||
    !$host ||
    !$id ||
    !$password) {
    &usage;
    exit;
}

# Open the file containing the user list
open(USERLIST, $userlist) || die "Unable to open $userlist!\n";

# Initialize SOAP client
$loginClient = SOAP::Lite->new(proxy => &sakaiLogin($host));
$sessionId = $loginClient->login($id, $password)->result;

print "SESSION_ID: ".$sessionId."\n";

$scriptClient = SOAP::Lite->new(proxy => &sakaiScript($host));

while (<USERLIST>) {
    chop;
    ($suid, $dob, $lastName, $firstName, $netId) = split(/;/);
    my $email = &makeEmail($netId);
    my $password = &makePassword($netId, $dob);

    print "Attempting to add user:\n";
    print "\tEID:\t\t".$netId."\n";
    print "\tFIRST_NAME:\t".$firstName."\n";
    print "\tLAST_NAME:\t".$lastName."\n";
    print "\tEMAIL:\t\t".$email."\n";
    print "\tPASSWORD:\t".$password."\n";

    my $result = $scriptClient->addNewUser($sessionId,
					   $netId,
					   $firstName,
					   $lastName,
					   $email,
					   '',
					   $password)->result;

    print "Result: ".$result."\n";

    if ($siteId) {
	if (!$roleId) {
	    $roleId = DEFAULT_ROLE;
	}
	print "Attempting to add ".$netId." to site ".$siteId." with ".$roleId." role...";

	$result = $scriptClient->addMemberToSiteWithRole($sessionId,
							 $siteId,
							 $netId,
							 $roleId)->result;

	print $result."\n";
    }

    print "\n";
}

$loginClient->logout($sessionId);

close(USERLIST);

I was blown away how easy it was to accomplish so much with so little! In hindsight, there were several cases where I used bash scripts to do too much, whereas a simple perl script would have saved me a great deal of effort. I notice that there’s a pretty big dispute going on over which is better, perl or python…maybe next time I’ll give python a shot and let you know what I think.