Abstract: Becoming a Full-Service Indie Publisher of Open Tools and Content using Tsugi.org

If open educational resources are to truly compete with commercial publishers, we must provide a full set of open capabilities that support a book. Publishers provide learning resources in a learning object repository (LOR) that allows remixing and easy integration into learning management systems using protocols like LTI. Publishers provide learning resources like slides, assignment, and interactive software to help those who use the book. Every open book should also have a truly free and open MOOC associated with the book that does not depend on any institutional LMS or MOOC hosting provider. We need the ability to have a OER website for a book, a “LOR of my Own”, an “LMS of my Own” and a “MOOC of my Own” using only our locally owned and controlled resources. The tsugi.org project in effect is the WordPress for Open Education. By downloading, configuring, and hosting a simple PHP application augmented by free content delivery networks, it is possible to deploy a scalable worldwide MOOC with surprisingly low cost. This presentation will introduce the tsugi.org software and show how it is used to build sites like www.py4e.com.

Submitted to: Open Textbook Summit 2017 – May 24-25, 2017 at SFU Harbour Centre in Vancouver, British Columbia (Canada)

Abstract: Sakai Community Update

The past year has been very eventful for Sakai. The Sakai-11 release was completed with the new frameless (Morpheus) portal, new Grade Book, responsive design, and many other game changing features to bring Sakai very much in line with the best LMS systems in the marketplace. A large number of Sakai sites are moving their production to Sakai 11 and we are working on a Sakai-12 release. This presentation will will give a brief summary of the Sakai project to date as well as expectations for the next year. The presentation will also feature a question and answer session with members of the Sakai Project Management Committee (PMC).

Submitted to: Open Apereo 2017 – Sheraton Philadelphia Society Hill Hotel, PA | June 4-June 8, 2017

Abstract: Tsugi Update: Progress towards the NGDLE

The past year has brought a lot of progress and adoption in the Tsugi project. A NodeJS version of Tsugi has been developed in addition of the existing PHP and Java implementations. The library code has been refactored to focus on providing the Tsugi libraries using the Composer dependency management system. Support for IMS Common Cartridge and IMS Content Item has been added so as to allow Tsugi to function as a Learning Object Repository in addition to an Application Store. These new functions have been combined together to produce a truly “next generation” Learning Management System that enables an “indie” publisher to deploy a topic-oriented, LMS, MOOC, LOR, and App Store using low-cost readily available hosting infrastructure. This presentation will provide an over view of the current status and plans for Tsugi going forward.

Submitted to: Open Apereo 2017 – Sheraton Philadelphia Society Hill Hotel, PA | June 4-June 8, 2017

Abstract: Building a Next Generation Digital Learning Environment with Tsugi (Workshop)

The Tsugi project is providing technology to enable a wide range of educational technology use cases. Initially, Tsugi was developed to simplify the development of educational tools and to allow those tools to be deployed in an “App Store” pattern using IMS Learning Tools Interoperability (1.1 and 2.0). More recently, Tsugi has added support for IMS Common Cartridge, IMS Content Item, and a Lessons capability that allows Tsugi to function as a Learning Object Repository that is easily integrated into existing LMS systems. Tsugi is also evolving into an easy-to deploy Learning Management System focused on supporting a web site for a single class or topic. We call this use case a “MOOC of Our Own”. Tsugi can both support individual deployments as well as institutional-scale deployments. This workshop will walk through a Tsugi installation and configuration and experiment with using Tsugi as both an application development environment, a Learning Object Repository, and an Application Store.

Submitted to: Open Apereo 2017 – Sheraton Philadelphia Society Hill Hotel, PA | June 4-June 8, 2017

Student Programmer Position: Working on Sakai – Open Source

I would like to fill a student programmer position (at the University of Michigan) to help me work on the Sakai open source Learning Management System. Sakai is the most popular open source learning management system for top-level research schools around the world like NYU, Oxford, University of Capetown, Notre Dame, Duke, University of North Carolina and many others. There are well over 200 schools that use Sakai as their primary learning management system and there are millions of daily users of the product.

I am currently working on defining and building the next generation of interoperability standards that allow learning systems to share and exchange data via standard, open protocols. I am also working on making Sakai certified against standards for accessibility like WCAG.

Skills Required

In the position you will make direct contributions to the open source Sakai project in your own name as well as work with me as I develop new and expanded functionality for Sakai.

This will require a pretty significant set of solid programming skills:

– Java
– Java Servlets
– Structured Query Language (SQL)
– HTML / CSS
– Accessibility
– JavaScript
– Git / github

This is not a position where you will learn those skills – you must already have them. Sakai is a million lines of code – much of which is a decade old. Working with real, mature, production code that was developed over time by a team of >100 programmers is both a technical challenge and very gratifying at the same time.

https://github.com/sakaiproject/sakai

In addition to your skills, you will need solid hardware to do Sakai development. My own laptop is a quad-core-i7 macintosh, 16GB RAM, and 500GB SSD. When you are building and testing a million lines of code – it takes some resources.

Benefits

You will work with a highly talented and deeply committed team of software designers, end-users, and software developers to tackle the most advanced issues in building software for teaching and learning. I would work as your mentor to bring you into this community. The community is very active. We have several teleconferences per week that are attended by people around the world where we work on topics like development, accessibility, marketing, and teaching and learning with Sakai. I will encourage you to attend these teleconferences to make sure that your work fits well into the community and product. I am not the expert in all things Sakai – much of what you learn about Sakai will come from many others in the Sakai community.

There may be travel to Sakai meetings and/or standards meetings where you will met engineers from all of the major learning management systems like Moodle, Blackboard, Canvas, Desire2Learn, Schoology and others. If you have an interest in working in the educational technology space there is potential to make many good contacts that might lead to an internship or a job. My goal is to be your mentor rather than your boss and in time for you to be a respected contributor in your own right.

When you have mastered the Sakai code base – you will know what it takes to understand a million lines of code and develop in a professional manner. You also will know that your contributions have advanced the cause of teaching and learning with technology worldwide.

This is a student programming position – not a full time professional position but the work you do will be at a professional level.

Getting Started

The best way for you to figure out if you have the skills and development environment to handle Sakai is to download it and get it up and running in your development environment. You can follow the official installation instructions at:

https://www.sakaiproject.org/download-sakai

(Start with the git repository)

I have built a set of scripts that allow me to check out and set up an instance of Sakai with a few scripts. They work on Mac or Linux and make things easier:

https://github.com/csev/sakai-scripts

Please feel free to send me a resume or ask a clarifying question.

What is static, double colon (::), $this, and arrow(->) in PHP OO

I wrote this code to answer some PHP Object Oriented questions during office hours.

function plus($x, $y) {
    return $x + $y;
}

class Thing {
    public $value;
    private $a;
    protected $b;

    function __construct($start=0) {
        echo("Construct\n");
        var_dump($this->value);
        $this->value = $start;
        $value = 12345;
        var_dump($this->value);
        echo("Done\n");
    }

    public static function add($x, $y) {
        // Cannot use $this
        echo("Adding $x $y \n");
        return $x + $y;
    }

    public function increment($x) {
        $this->value += $x;
        echo("New:" . $this->value . "\n");
    }

    public function inc2($x, $y) {
        $this->increment($x);
        $this->increment($y);
    }

    public function add10() {
        $this->value = self::add($this->value, 10);
        $this->value = $this->add($this->value, 10);
        $this->inc2();
    }

    function __destruct() {
        echo("AAAAAAAAAAAAAARGH!!\n");
    }

}

$y = plus(3,4);

$y = Thing::add(3,4);

$z = new Thing(7);
$a = new Thing(10);

$z->increment(4);

$a->increment(5);

$y = $z->add(5,6);

unset($z);
echo("The last line\n");

Fixing when a jQuery UI Modal Shows Behind Fixed Bootstrap Navigation

I am blogging this because I searched stack overflow and Google and no one had the answer. Too bad I can’t just state something in StackOverflow after hours of research and a bunch of “close” questions and answers. But ah well – here it is.

I am working on my Tsugi OER site www.pr4e.com.

What I am trying to do is use the modal capabilities of jQueryUI modal dialogs (mostly because I do not like the overblown markup of BootStrap modals) while the rest of the site is styled with BootStrap. All goes well until the modal is larger than the overall window vertically and the modal slides under the BootStrap fixed navigation bar.

Here are some images:

Navigation with enough vertical space (good): good_nav

Not enough vertical space, modal slides below the navigation (bad):bad_nav

Not enough vertical space, modal atop the navigation (good): better_nav

Solution

The key is to set the z-index of the *generated* markup created by the jQuery UI dialog call after the dialog was created:

function showModal(title, modalId) {
    console.log("showModal "+modalId);
    $("#"+modalId).dialog({
        title: title,
        width: modalDialogWidth(),
        position: { my: "center top+30px", at: "center top+30px", of: window },
        modal: true,
        draggable: false
    });

    // In order to float above the BootStrap navigation
    $('.ui-dialog').css('z-index',9999);

    $(window).resize(function() {
        $("#"+modalId).dialog("option", "width", modalDialogWidth());
    });
}

I figured out the generated elements and changed their z-index.

Working code: www.py4e.com (Log in and go to “Use this service”, and press “Using Your Key”).

Code in github: tsugiscripts.js

October 1: Moving the Tsugi GitHub Repositories

I am just back from a successful trip to South Korea where I talked a lot about the NGDLE, Sakai, and Tsugi:

http://www.slideshare.net/csev/building-the-next-generation-teaching-and-learning-environment-66291838

I focused a lot on the new Tsugi use case of being a single-course LMS that is integrated into a single-site OER materials / course site.

https://www.py4e.com/
https://www.wa4e.com/

There was a good bit of interest from technically minded teachers and folks from educational technology centers. I made it clear that Tsugi was not trivial to install and run yet – but on a good path to be ready for teachers to to build web sites in 2017.

But some want to get started now. And so on October 1, I will be moving the main Tsugi repositories from

https://github.com/csev

to

https://github.com/tsugiproject
https://github.com/tsugitools

The core bits (PHP, Node, and Java) will all move into the “tsugiproject” and tools will move into “tsugitools”.

For folks who have been using the “csev” repositories, GitHub is good about forwarding requests when repositories are renamed or moved.

I am sure this will be a bit of a disruption – but probably better now than later.

If you have any issues with this or suggestions as to how to best do it, let me know.

Abstract: Building the Next Generation Digital Learning Environment using Tsugi

This presentation will give an overview of the Tsugi project and applications of the Tsugi software in building a distributed approach to teaching and learning tools and content. One company involved in the Internet of Things claims that “The next big thing will be a lot of small things”. If we apply this logic to the educational technology marketplace, an essential element needed to achieve the NGDLE is to reduce the granularity of the learning content and applications to the individual teacher or even individual student. Tsugi is a 100% open source effort that is part of the Apereo Foundation.

It is not sufficient to simply make a bunch of small web-hosted things and claim we have “implemented” the NGDLE. We must be able to coherently search, find, re-construct and re-combine those “small pieces” in a way that allows teaching and learning to happen. To do this, each of the learning application and content providers must master detailed interoperability standards to allow us “mash up” and bring those distributed and disparate elements back together. While there has been much said about the ultimate shape and structure of the NGDLE, and there are many current and emerging interoperability standards, there is little effort to build and train providers with usable technology that will empower thousands or hundreds of thousands of people to build and share applications and content that will populate the new learning ecosystem.

In effect, we need to build the educational equivalent of the Apple App Store. Except that it needs to be open and extensible and not depend on a single vendor intent on maximizing shareholder value. This presentation will show how the Tsugi project is doing research into how this works in actual practice. Tsugi is a 100% open source production-ready application and content hosting system that is simple enough to use to allow interoperable and pluggable learning applications or learning content to be built, hosted, deployed and shared by individuals or various-sized organizations.

Dynamic .htaccess to deal with Url Rewriting mod_rewrite.c, and FallbackResource

As I built Tsugi, I want to ship with a decent, working .htaccess in folders that need it. My most typical use case is that I want to map all the URLs in a folder into a file like index.php.

There are two good ways to do this. The old standby is a long set of mod_rewrite rules. The new, much more elegant trick is to use FallbackResource in mod_dir in later versions of Apache 2.2.

The problem is that clever hosting providers upgrade to the new Apache and then figure they can remove mod_rewrite so you know how to do it in either case but don’t have a good way to trigger when to use what approach.

This is my approach that I use in Tsugi when I want to map all URLs to one file:

    <IfModule mod_rewrite.c>
        RewriteEngine on
        RewriteRule ^ - [E=protossl]
        RewriteCond %{HTTPS} on
        RewriteRule ^ - [E=protossl:s]
        RewriteRule "(^|/)\." - [F]
        RewriteCond %{REQUEST_FILENAME} !-f
        RewriteCond %{REQUEST_FILENAME} !-d
        RewriteCond %{REQUEST_URI} !=/favicon.ico
        RewriteRule ^ index.php [L]
    </IfModule>
    
    <IfModule !mod_rewrite.c>
        FallbackResource index.php
    </IfModule>

It is not perfect but kind of deals with things as the move forward. If mod_rewrite is there – use it – it works in later Apache versions as well but if mod_rewrite is there, use it and if not, hope that FallbackResource is there.

Now of course there are some Apache versions / setups where this fails – but on average, over time as Apache’s get upgraded, things get simpler and over time the mod_rewrite code just will stop activating.

I also added this information to a Stack Overflow question.