The Clinical Trials Unit at the National Perinatal Epidemiology Unit (NPEU CTU) recently decided to use WebLearn to help stream-line the administration of follow-up in a clinical trial. They commissioned a small amount of development of the web services interface to the Sign-up tool to provide integration with their appointments database. NPEU CTU contacted an external consultant to do this work for them.

The NPEU CTU has a WebLearn site that will be used for booking two-year follow-up assessments for approximately 1400 infants who are participating in the I2S2 trial (a randomised controlled trial of iodine supplementation in preterm infants). The site will be accessed securely by a trial co-ordinator and two IT professionals from the NPEU CTU, and approximately seven clinical assessors located across the UK.

Each appointment is made on the Microsoft Access I2S2 administrative database by the I2S2 Trial Co-ordinator and sent automatically to WebLearn using the newly developed Sign-up tool web services interface. WebLearn then generates an email notification which is sent to the assessor.

The assessor is able to view details of the appointment using either a networked computer or a mobile phone. They also have the ability to accept or reschedule the bookings. Each assessor has their own link which presents their own appointments on a web page which can then be printed.

A Schedule Tool in a separate WebLearn site will be used for assessors to mark days when they are not available. This calendar is superimposed on the assessments calendar to prevent booking “conflicts”. The co-ordinators and assessors are also able to see the assessment and annual leave bookings on their internal Outlook calendars using the recently developed “Private URL” service.

This trial of using WebLearn in an NPEU CTU trial will hopefully lead to other beneficial developments in future.

WebLearn has replaced a time-consuming manual email/phone-based system without the need to invest significant sums of money in proprietary or bespoke software. It has allowed co-ordinators and assessors working in different organisations to work together securely, without compromising patient confidentiality. This would not have been possible without WebLearn.

Author:  Stella Khenia (NPEU)

Links

• I2S2 Information
• Sign-up tool
• Schedule tool
• Private URLs
• Web Service interfaces (warning: heavy technical content herein!) note that this interface will expand significantly with the move to version 2.8 of WebLearn on 29^th May

AuSakai 2012 – Call for Proposals

18-19 September 2012

Hosted by Charles Sturt University
Bathurst, Australia

The AuSakai 2012 Organising Committee invites proposals for presentations and workshops for the upcoming AuSakai 2012 conference.

AuSakai 2012 will explore ‘Sakai Futures: Openness and Innovation!‘ and papers are invited from the Sakai community that reflect this.

Presentations should explore one of the following themes:

• Learning and Teaching
• Technical and Development
• Research and Collaboration

Come and hear about the new Sakai Open Academic Environment.

Abstract Submission:

Proposals should be emailed as an attachment to the Conference Team.

Guidelines for Abstracts:

• There is a 300 word limit.
• The conference session presentations will run for 40 minutes with an open format.
• The session may include a 30 minute presentation with 10 minutes for questions and answers.
• Please note: There will be no poster presentations at this year’s conference.

Important dates

• The closing date for submission of proposals is 23 July 2012.
• Presenters will be advised of proposal acceptance from 16 August 2012.

Further information and the registration form for AuSakai 2012 can be found at www.ausakai2012.com.au

Please note: Accommodation options are listed on the landing page as well as in the online registration form

We look forward to seeing you at AuSakai 2012.

ENQUIRIES OR FURTHER INFORMATION
Contact Name: Kate Rose
Telephone: 02 6338 4804

Email: ausakai@csu.edu.au
Contact Name: Lorraine Stephens
Telephone: 02 6338 4515

AuSakai 2012 printable flyer

(Posted on behalf of the AuSakai 2012 Organising Committee)

Since I emerged from the dark world of Java where anything is possible I have been missing the freedom to do whatever I wanted with threads to exploit as many  cores that are available. With a certain level of nervousness I have been reading commentary on most of the major languages surrounding their threading models and how they make it easy or hard to utilize or waste hardware resources. Every article I read sits on a scale somewhere between absolute truth to utter FUD. The articles towards the FUD end of the scale always seem to benchmarks created by the author of the winning platform, so are easy to spot. This post is not about which language is better or what app server is the coolest thing, its a note to myself on what I have learnt, with the hope if I have read to much FUD, someone will save me.

To the chase; I have looked at Java, Python touched on Ruby and thought about serving pages in event based and thread based modes. I am only considering web applications, serving large numbers of users and not thinking about compute intensive, massively parallel or GUI apps. Unless you are lucky enough to be able to fit all your data into memory or even shard the memory over a wide scale cluster, the web application will become IO bound. Even if you have managed to fit al data into core memory you will still be IO bound on output as core memory and CPU bandwidth will forever exceed that of networks, and 99% of webapps are not CPU intensive. If it was not that way, the MPP code I was working on in 1992, would have been truly massively parallel, and would have found a cure for Cancer the following year. How well a language performs as the foundation to a web application is down to how well that language manages the latencies introduced by non core IO and not how efficiently optimises inner loops. I am warming to the opinion that all languages and most web application frameworks are created equal in this respect, and its only in the presentation of what they do where there is differentiation. An example. A Python based server running in a threaded mode compared to Node.js.

Some background. Node.js uses the Chrome Javascript engine that predicts patterns of JS code and converts them into C. It runs as a single thread inside a process on one core, delivering events to code that perform work exclusively until they encounter some code that releases control back to the core event dispatch, normally by returning from the event handling code. The core of Node.js generally uses an efficient event dispatch mechanism built into the OS. (epoll, kqueue etc). There is no internal threading within a Node.js proces and to use multicore hardware you must fork separate OS level processes which communicate over lightweight channels. Node.js gets is speed from ensuring that the single thread is never blocked by IO from doing work. The moment that happens the single thread in Node.js moves on to performing some other useful work. Being a single process it never has to think about inter-thread locking. That is my understanding of Node.js

Python (and Ruby to some extents), when running as a single process allows the user to create threads. By default these are OS level threads (pthreads) although there are other models available. I am talking only about pthreads here which dont require programmer intervention. Due to the nature of the Python interpreter there is a global lock (GIL) that only allows 1 python thread to use the interpreter at a time. Threads are allowed to use the interpreter for a set time after which they are rescheduled. Even if you run a python process on a multicore system, my understanding is, only 1 thread per process will execute at a time. When a thread enters blocking IO it releases the lock allowing other threads to execute. Like Node.js, to make full use of multicore hardware you must run more than one Python processor. Unlike Node.js the internal implementation of the interpreter and not the programming style ensures that the CPU running the python process switches between threads to ensure its always performing useful work. In fact thats not quite true, since the IO libraries in Node.js have to relinquish control back to the main event loop to ensure they do not block.

So provided, the mechanism for delivering work to the process is event based there is little difference in the potential for Ruby, Python or Node.js to utilize hardware resources effectively. They all need 1 process per hardware core. Where they differ is how the programmer ensures that control is released on blocking. With Python (and Ruby IIUC), control is released by core interpreter with out the programmer even knowing it is happening. With Node.js control is released by the programmer invoking a function that explicitly passes control back. The only thing a Python programmer has to ensure is that there are sufficient threads in the process for the PIL to pass control to when IO latencies are encountered, and that depends on the deployment mechanism which should be multi-threaded. The only added complication for the Node.js model is that the IO drivers need to ensure that every subsystem that performs blocking IO has some mechanism of storing state not bound to a thread (since there is only 1). A database transaction, for one request must not interact with that for another. This is no mean feat and I will guess (not having looked) is simular to the context switching process between native OS level threads. The only thing you cant do in Node.js is perform a compute intensive task without releasing control back to the event loop. Doing that stops a Node.js from serving any other requests. If you do that in Python, the interpreter suspends the pthread and reschedules after a set number of instructions. Proof, in some senses that multitasking is a foundation of the language rather than an artifact of the programmers code base.

The third language I mentioned is Java. Having spent most of my the last 16 years coding Java based apps I have enjoyed the freedom to be able to use every hardware core available from a single process all sharing the same heap. I have also suffered the misery of having to deal with interleaving IO, synchronization and avoiding blocking over shared resources. Java is unlike the other languages in this respect since it gives the programmer the tools and the responsibility to make best use of the hardware platform. Often that tempts the programmer to think they can be successful in eliminating all blocking IO by eliminating all non core memory IO. The reality is somewhat different, as no application that scales and connects humans together will ever have few enough connections between data to localise all the data used in a request to a single board of RAM. From my MPP years this was the domain decomposition bandwidth. It may be possible to eliminate IO from disk, but I have to doubt that a non trivial application can eliminate all backend network IO. In a sense, the threading model of Java tempts the developer to try and implement efficient hardware resource utilization, but doesn’t help them in doing so. The same can be said for many of lower level compiled languages. Fast and dangerous.

Don’t forget, with web applications, it’s IO that matters.

(this is a draft of an abstract for an upcoming talk I am giving – comments welcome)

The idea of moving educational content to the web to make it more scalable has been around since the mid-1990s. Almost as soon as the web was widely used, one of the first imagined uses would be moving classroom instruction onto the web and achieving economies of scale using the web. While the idea seemed obvious and felt like it would quickly become a solved problem, repeated attempts to replicate the classroom experience at scale achieved only disappointing results. At some point, it seemed to many people that if the problem of teaching on the web at scale remained unsolved after 20 years – that perhaps it was simply not possible. But recently with the breakthrough Stanford AI class with over 160,000 students and the rapid development of efforts like Coursera, Udacity, and edX, it seems like Massively Online Open Courses (MOOCs) are seeing significant investment and amazing growth.

What is different? What has changed? What is unique about MOOCs? Why does it seem like the same idea that has failed so may times before will finally work this time? Will these new MOOCs succeed or be just another hopeful experiment that ultimately fails in the long term?

This talk will look at what it is like to develop and teach a Coursera course from a teacher’s perspective. Dr. Severance is teaching a course titled Internet History, Technology and Security on Coursera on July 23. Teaching with Coursera is part of a long-term effort that he started in 1996, when he developed the first lecture capture system called Sync-O-Matic in order to move his courses to the web when his students were using 28.8 modems. He will look at where Coursera is unique, different, and what is new and compare it to previous effort.

Dr. Charles Severance
University of Michigan School of Information
www.dr-chuck.com

There will be a short period of downtime on Tuesday 29th May between 7am and 9am so that we can perform a major upgrade to WebLearn.

We will be moving to a service based on Sakai 2.8 which offers a number of improvements in key areas:

• Big improvements to Sign-up tool based on user feedback (categories, change organiser, auto create groups, prevent withdrawing when closed, better export (compatible with OXCORT)
• Many improvements to the Forums tool (including better user interface (UI), photos of author
• Improved webservices interface which can be exploited by Mobile Oxford
• New Profile tool with Social networking facilities
• New improved Email Sender tool (replaces Mailtool)
• Improved wiki UI
• Improved tool permissions ‘widget’
• SES tool bug fixes
• Site templates facility – it will be possible to base a new site upon a selection made from a choice of templates each tailored for a specific situation and each containing their own help and guidance.

By Michael Feldstein

A while back, I had the privilege of being the keynote speaker at the NERCOMP LMS Unconference. I had never attended an unconference before, nevermind keynoting one, and I found the prospect to be fascinating and exciting. And nerve-wracking. On the surface, a keynote appears to be the antithesis of the unconference spirit. I needed to do something different than the usual fare in order to make it work. I needed to do an unkeynote. And yet, Stephen Downes had warned me that he, Brian Lamb, and D’Arcy Norman had tried giving an unkeynote before and, in his words, “They almost lynched us. They were not happy to receive an unkeynote.” (D’Arcy’s post-mortem of their effort is definitely worthwhile reading.) So, what to do?

The approach I tried seemed to work, judging by the feedback I got from the attendees and, to a lesser degree, by the influence of the presentation that I was able to observe on the rest of the unconference. I had intended to blog about the experience a while ago but it fell off my to-do list. However, prompted by the good folks of the NERCOMP LMS SIG, I am now returning to the topic.

A Word About Unconferences

Let me start with my own observations about the role of the unconference in the wider world of conferences. For those who aren’t familiar with the idea, unconferences don’t have set agendas with pre-defined speakers. Instead, people come with ideas of topics that they want to discuss, the group votes on which topics people want to talk about, and the people who post the topics lead the discussion. At the NERCOMP event, people wrote their ideas for topics on index cards and posted them on a wall. The participants then put stickers on the cards that interested them the most. The top four or five topics became breakout sessions.

Some folks are attracted to the unconference format because they are allergic to the “sage on the stage” syndrome and have a commitment to democratize the conversation. That’s not such a big driver for me. I find that the traditional conference format can be very useful sometimes. For example, in a truly academic conference, where people are presenting their research, I often don’t have a whole lot to say. I want to hear about the research. Yes, we could “flip” the conference by having me read the paper beforehand and spend the entire session in discussion, but that has a number of disadvantages for me. First, I often don’t have time to read the paper beforehand. The presentation helps me decide if I want to invest that time in getting the details by reading it afterward. Second, I’m the kind of learner who absorbs more by hearing it than by reading it. And third, I like to be able to ask questions while I am absorbing the material and it is fresh in my mind. So I appreciate the traditional conference format when the content is truly new to me and the speakers know a lot more than I do.

That said, a lot of conferences aren’t primarily about presenting original research. Instead, they are about presenting what people have learned in the course of doing their work, which may be research but often is just best practices or lessons learned. These conferences are highly vulnerable to the law of diminishing returns for participants. The first year, the event is great and you learn a lot. The second year, you start seeing some repeats. By the third year, it all starts to seem like the same conference over and over again. The only people who learn are the inexperienced ones. The sessions do very little to advance the state of the art. Whenever you observe this kind of phenomenon, you probably have a good candidate for an unconference.

In an unconference, you get to harness the collective knowledge of the participants. If there’s a thorny problem that nobody has quite solved but that a lot of smart folks in the room have tricks for dealing with or thoughts about potential approaches, then having a discussion-focused brainstorming session is much more productive than having one presenter talk about one sliver of the expertise in the room that can be brought to bear on the problem. Also, if there is some collective action that can be taken to further research the problem or develop a solution afterward, then conversation may reveal potential coalitions for taking action. At the same time, because the sessions are democratic in nature, they seek their own level. For example, I ended up moderating a session at the NERCOMP event on the pros and cons of open source. But because there was only one other person in the group who had experience with open source, the session turned out to be more me answering questions and giving guidelines, so closer to a traditional presentation (although still very audience-driven in the sense that my presentation was 100% focused on questions asked in the moment).

The point I’m trying to make is that we get a lot of insight into what unconferences are good for when we think about them in pedagogical rather than ideological terms. I used the same lens when thinking about how a good unkeynote should work.

Priming the Pump

You have a certain advantage in an unconference that you often don’t have in classes in that the participants are attracted to the event specifically because it is participation-focused. Even so, you still face some form of the tyranny of the blank sheet of paper. Getting started can be hard. So the point of an unkeynote should be to prime the conversational pump. We want to generate a surfeit of potential topics so that the group can immediately begin the work of identifying the best ones and focusing on them.

If the point of an unconference is to generate productive, self-directed educational group work, then we are dealing with a pretty familiar pedagogical problem. In fact, it’s ubiquitous in any sort of creative work. And usually the solution to the problem involves two ingredients: stimulation and time to think. Creative writers go through exercises that are not necessarily focused on writing the story or novel or poem that they want to create but rather on generating ideas and opening up creativity. For example, Julia Cameron’s book The Artist’s Way contains lots of exercises like this one:

Collage: Collect a stack of at least ten magazines, which you will allow yourself to freely dismember. Setting a twenty-minute time limit for yourself, tear (literally) through the magazines, collecting any images that reflect your life or interests. Think of this collage as a form of pictorial autobiography. Include your past, present, future, and your dreams. It is okey to include images you simply like. Keep pulling until you have a good stack of images (at least twenty). Now take a sheet of newspaper, a stapler, or some tape or glue, and arrange your images in a way that pleases you. (This is one of my students’ favorite exercises.)

Notice that the task here involves no writing. This is about preparing to write. It is about harnessing both the conscious and unconscious mind to look for patterns and, more generally, to engage with something.

But the technique is not just important for the disciplines that are traditionally seen as creative. When I taught eighth grade science, I used a great curriculum out of the University of Hawaii called Foundational Approaches in Science Teaching (FAST). On the first day of class, I showed the kids a giant graduated cylinder. It was filled with two liquids of different colors, one of which was clearly heavier than the other because it sank to the bottom. Also within the cylinder were three vials filled with varying amounts of green liquid. The vial that was completely full floated at the top of the cylinder. The vial that was two-thirds full sank to the bottom. And the vial that was one-third full floated at the interface between the heavier and the lighter liquid in the cylinder. I would show them this and ask them, “Can you explain this?”

Rather than having them talk about it immediately, I had them write their ideas down and think about them. Then we discussed it. That session kicked off a series of experiments at the end of which the kids would tell me what buoyancy is and how to calculate it. The experiments were defined in the curriculum, but often the kids came up with ideas of their own that they wanted to test. I usually let them do that as long as it wasn’t dangerous. That, after all, is science. There was no textbook per se in the FAST curriculum. Students had no Source of Truth from which they read answers. However, it was very important for them to have experiments that were structured as generative touch points that pushed them to think about the problem from new angles. The point is, we need stimulation and time to think if we’re going to be creatively engaged.

That’s what an unkeynote should do. Rather than trying to push people into immediately taking charge of the conversation, I wanted to stimulate them to think of things that really excited them to talk about. Then all I would need to do, as one of my mentor teachers once put it to me, is get out of the way and let them learn. I wanted to do the equivalent of presenting that giant graduated cylinder. I wanted to find the participants’ zone of proximal curiosity. These folks came to talk about LMSs, starting with their experiences and their problems. I wanted to get them to reflect on those experiences and problems in fresh ways. So I gave a talk that didn’t demand immediate group participation, but it was all questions. I gave no answers. I wanted to start with some of the concerns that may have already been on their minds walking in the door and take them just a few steps further. “OK, you’ve all wasted months of your lives wrestling with bad LMS grade books, regardless of the particular brand of LMS you have. Why are LMS grade books all so bad? Are we trying to solve the wrong problem with them?” Or “Many of you have done LMS tool usage surveys and, regardless of which LMS you use, the usage patterns look roughly the same. Lots of use of announcements, file sharing and grade book. Some use of discussion boards and test engine. Everything else falls off the cliff. Why is that, and what does it tell us about what we need from an LMS?” These questions functioned similarly to the assignment bank in DS106: “Here are some ideas for discussion. If they don’t excite you, then find something that does. Maybe just looking at the list will give you inspiration for a better idea.”

My impression is that the approach worked (although I welcome unconference participants to comment with their own perspectives here). But the larger point is that, no matter how strong our commitment is to empowering people to participate (whether at a conference or in class), it’s important to focus on their learning process rather than on the instructor’s position in it. The question of “guide on the side” versus “sage on the stage” still makes the conversation all about the teacher rather than the learner. Sometimes it’s OK to be the “guide on the stage” if that helps the students/participants through the cognitive and creative processes that we call “learning.”

Possibly related posts:

1. Sakai Conference: Kamenetz Keynote OK, this was worth the wait. I have video of...

How to Keynote an Unconference by %%AUTHORINK%% on e-Literate

In the light of the new EU Cookie law, we thought it would be a good idea to detail what cookies are used by (new) WebLearn (2.8):

• jsMath – wiki, has the user been shown the missing jsMath fonts warning message?
• sakai_nav_minimised – is the LHS tools menu minimised (new feature)
• JSESSIONID – session status (secure)
• webauth_at – a webauth token (secure)
• webauth_found – an IDto achieve one-shot login to both old and new WebLearn. This will vanish when old WebLearn is switched off
• /sakai-gradebook-tool/JSESSIONID – we believe this is caused by a Sakai bug

The only cookie that links to personal data is JSESSION.

We consider all of these to be essential for the service, none of them persist after the session has ended and none are third party cookies

There is a small elephant in the room in that site maintainers can upload content that sets cookies. We cannot effectively police these third party cookies and hope that they are only used when necessary. We are happy to contact site owners if any users feel that such cookies are not essential.

Regarding Old WebLearn, there is one cookie ORG_BODINGTON_SERVLET_SESSION which lasts for the length of the session and maintains session status; it links to personal data.

Photo credit: http://www.flickr.com/photos/klara/403856634

By Phil Hill

One of the trends I highlighted last summer was that the LMS or learning platform market was overlapping the educational content market.

The lines are blurring between content delivery systems (e.g. Cengage MindTap, Pearson MyLabs, etc) and LMS.  Content delivery and ability to keep students engaged within the content will drive much of the broader ed tech market.  This integration of markets is being seen as a strategically important issue for institutions, particularly for online programs.

While I feel quite confident in having made that description, I did not have a model, or explanation, of what was driving the trend. Nine months later, I believe the trend has proven itself empirically, as more examples emerge: Apples iBooks2 / iTunesU App, Online Education Service Providers such as 2tor combining online programs with custom learning platforms, Pearson OpenClass, MOOC startups with custom platforms such Coursera, Udacity, etc.

Last week Roger McNamee, co-founder and managing director with venture capital firm Elevation Partners, gave a presentation to the Mashable Connect conference titled “How to Revive the Web”. The presentation described how Apple won big by betting against the web and its prevailing culture (Mashable post here and Roger’s full presentation here). Roger’s theory is that Apple’s strategy was to move away from commoditized content, which most of the PC-based web (HTML4) assumed,  by delivering content in a differentiated, elegant manner – tightly combining content and the delivery mechanism. Furthermore, as HTML5 emerges, this move will accelerate.

If this theory is correct, I think it helps explain the trend of the LMS market combining and blurring with the educational content market.

McNamee Theory

From the Mashable article:

“Most of all what Apple did was they charged $400 to $1,000 for the hardware that was necessary to get a differentiated user experience on data that 100% of their customers could get for free off a desktop device,” he said. “Every Apple customer has consciously voted with $400 to $1,000 against the world wide web.”

The result of that vote is a move away from the desktop experience of free, undifferentiated content. Mobile users don’t navigate the Internet with Google searches. They use apps, which deliver a better experience. And they spend much more time within those apps than on any web story.

McNamee’s point is that by combining content and delivery into an engaging experience, there is increased engagement. Investors see tremendous value in content-based platforms that can engage consumers, getting them to interact and spend more and more time with the systems. In another interesting aspect of this theory, the power and value of content publishers and consumers increases with differentiated content, and the value of middle men decreases.

Application to Ed Tech Markets

While I would not go so far as to make a direct comparison between iOS / HTML5 with today’s learning platforms, and while educational content has been anything but free, the macro trend described by McNamee is a key driver to what we are seeing in ed tech markets. From the investment side – private equity, venture capital, publisher internal investment, even university investment – there is a lot of money going into the concept of differentiated content that can engage students. Ed tech is also seeking tight integration of content and delivery into a differentiated, engaging experience leading to increased student engagement.

Note that the educational publishers have been making aggressive moves lately to take back control of the e-textbook or e-content experience from the middle men such as Inkling and Kno. Publishers want to own and control the differentiated experience, and it is a valuable market worth fighting for. The stronger middle men will also want to own the experience, but their relationship with publishers is tenuous in my opinion.

Furthermore, I think that the open content movement – OER – will need to develop an ecosystem that can deliver the differentiated experience to students and faculty. It will not be enough to provide free, high-quality content. For increased adoption of OER to occur, delivery platforms that can provide the overall experience will need to be developed and available to the market.

On the learning platform side, we are probably at the stage where we are seeing more choices in innovative systems, but we are not to the stage where students are truly benefiting from the overall experience and engaging with educational content in a meaningful way. Expect to see more investment in this area, but eventually the concept has yet to prove itself as a permanent change to the marketplace.

Update: Removed Boundless Learning as example of middle men

Possibly related posts:

1. "An excess of teaching presence will limit student-student interaction" Joe Ugoretz has a...
2. Search, Copyright, and Course Pack Affordances I’m still very much interested in the idea of creating...
3. RSS Feeds for Search Engines: A Very Good Thing I just upgraded to the long-awaited 2.0 version of NetNewsWire...
4. Distributed Learning is Here: Ask Any College Student This is a guest post by Jim Farmer for a...
5. Social Learning and the Re-bundling of the College Experience Just a couple of hours after I posted on social...

The Search for Differentiated and Engaging Student Experience by %%AUTHORINK%% on e-Literate

As a recovering CVS user turned svn master, and now an aspiring git ninja, I am sharing some of the tips and tricks to make my git environment as enjoyable and effective as possible.  First a little tough love: if you are not using the git command line, then just move along… these aren’t the droids you’re looking for.  But seriously, if you want to learn how to use git better you MUST MUST MUST use the command line. But if you are going to use a GUI, then PLEASE do us all a favor and avoid Github for Mac and instead get a tool like Tower.

So if you are still reading you are in the right place!

Tip #1:  If you are not using bash-completion, start now! Seriously! Stop reading this post and go install bash-completion immediately! This is the single biggest time saver; period. It provides completions via a deep knowledge of common tools such as git, ssh, jar, java, man, etc. For example:

1. cd <your favorite git project>
2. git checkout origin/<TAB><TAB>
3. You will see all of the branches from the remote repo appear like magic!
4. The git bash-completion knows about git commands, tags, branches, repositories, etc. So cool!
5. Now try: git log –<TAB><TAB>
6. It shows you all of the command line options for git log. With each git command having a wealth of options, this is a huge sanity saver.

Tip #2: Now that you have bash completing your git commands for you, how about we add some color to the results of git commands? Yes, seeing the output of a “git diff” colorized with additions in green and subtractions in red is, well after you get used to it, simply required.

Edit your ~/.gitconfig and add the following section:

[color]
  diff = auto
  status = auto
  branch = auto
  interactive = auto
  ui = auto

And while you are in there add this section to automatically run garbage collection for you!

[gc]
  auto = 1

Tip #3: Tired of typing “git status” to figure out if your branch is clean or dirty? Or if you need to push or pull to get caught up with a remote repo? The next git trick will really knock your socks off! Via the bash prompt, it displays the git branch you are currently on. If the branch is dirty the name of the branch is displayed in red. If the branch is clean the name is displayed in green. For example:

…clean…

    [develop] /Develop/k2/rsmart/nakamura

…dirty…

    [develop] /Develop/k2/rsmart/nakamura

…ahead…

    [develop↑] /Develop/k2/rsmart/nakamura

…behind…

    [develop↓] /Develop/k2/rsmart/nakamura

…branches have diverged…

    [develop↕] /Develop/k2/rsmart/nakamura

Curious yet? Here are the arcane .bash_profile incantations to make this a reality:

c_cyan=`tput setaf 6`
c_red=`tput setaf 1`
c_green=`tput setaf 2`
c_sgr0=`tput sgr0`
parse_git_branch ()
{
    if git rev-parse --git-dir >/dev/null 2>&1
    then
        git_status="$(git status 2> /dev/null)"
        branch_pattern="^# On branch ([^${IFS}]*)"
        remote_pattern="# Your branch is (.*) of"
        diverge_pattern="# Your branch and (.*) have diverged"
        # add an else if or two here if you want to get more specific
        if [[ ${git_status} =~ ${remote_pattern} ]]; then
          if [[ ${BASH_REMATCH[1]} == "ahead" ]]; then
            remote="↑"
          elif [ ${BASH_REMATCH[1]} == "behind" ]]; then
            remote="↓"
          fi
        fi
        if [[ ${git_status} =~ ${diverge_pattern} ]]; then
          remote="↕"
        fi
        if [[ ${git_status} =~ ${branch_pattern} ]]; then
          branch=${BASH_REMATCH[1]}
          echo "${branch}${remote}"
        fi
    else
        return 0
    fi
}
branch_color ()
{
    if git rev-parse --git-dir >/dev/null 2>&1
    then
        git_status="$(git status 2> /dev/null)"
        color=""
        if [[ ${git_status} =~ "working directory clean" ]]; then
            color="${c_green}"
        else
            color=${c_red}
        fi
    else
        return 0
    fi
    echo -ne $color
}
export PS1='[\[$(branch_color)\]$(parse_git_branch)\[${c_sgr0}\]] \w\[${c_sgr0}\]$ '

With this information in hand, you should be well on your way to leveling-up your git ninja (ginja?) skills…

Every now and again Time Machine will spit out a “Cant perform backup, you must re-create your backup from scratch” or “Cant attach backup”.  For anyone who was relying on its rollback-time feature this is a reasonably depressing message and does typify modern operating systems, especially those of the closed source variety. At some point, having spent all the budget on pretty user interfaces, and catered for all use cases the deadline driven environment decides, “Aw stuffit we will just popup a catch all, your stuffed mate dialog box”. 99% of users, rant and rave and delete their backup starting again with a sense of injustice. If your reading this and have little or no technical knowledge, thats what you should do now.

If you get down to bare nuts and bolts you will find that a Time Machine backup is not that disimular to a BackupPC backup of 10 years ago. It makes extensive use of hard links to snapshot the state of the disk. It perform this in folders with thousands of files creating uniformly distributed tree. That all works fine except when it doesn’t. Anyone who has used hard links in anger on a file system will know it tends to put the file system under a lot of stress resulting in more filesystem corruptions than normal. File systems are not that transactional so if an operation fails part way through, then the hard links may start to generate orphaned links.

Now TimeMachine runs fsck_hsf when it attaches a sparse bundle file system which is the Time Machine backup. Unfortunately it doesn’t try that hard to fix any problems it finds and couldn’t possibly corrupt its pretty UI by telling the user that it might have a problem with the users cherished backup of life’s memories. Not good for marketing, loosing your loyal customers photos when you promised them it wouldn’t happen. Fortunately, those messages are logged in /var/log/fsck_hfs.log. If you use Time Machine and are finding the attach stage takes forever. Take a look in there for the words “FILESYSTEM DIRTY”. That indicates, that the last time Time Machine tried to attache the drive the file system check was unable to check the file system and correct any errors, and so, it marked it DIRTY. It is possible to correct one of these filesystems, however, with all those hard links the likelyhood is that your filesystem, even if fsck_hfs -dryf /dev/discXs1 does correct the errors and put it into a FILESYTEM CLEAN state, it wont be a usable and valid backup. When your laptop exits you house with a man wearing a stripy jumper and tights over his head, your children (and you) will cry realising that the backup in the cupboard is corrupt.

What advice can I give you?

1. Check your backups regularly
2. If you use TimeMachine, open the “console” program, type DIRTY into the search box and if you find that word, go out an buy another backup disk…. quick.

For those that want to try and recover a Time Machine backup.

chflags -R nouchg /Volumes/My\ Time\ Capsule/mylaptop.sparsebundle
hdiutil attach -nomount -noverify -verbose -noautofsck /Volumes/My\ Time\ Capsule/mylaptop.sparsebundle
tail -f /var/log/fsck_hfs.log
# If you see  "The Volume could not be repaired"
# then you need to run
fsck_hsf -dryf /dev/rdiskXs2
# where X was the number of disk listed when you hdutil attached.
# I can almost guarentee that the disk will not be recoverable and you will see tens of thousands
# of broken hard link chains. Fixing those will probably corrupt the backup.
# which is why this is futile.

If you are using a Time Capsule, power cycle it first, connect your machine to it of 1000BaseT and make sure no other machines are accessing it. Don’t use Wifi unless you want to grow old and die before the process completes.

Update

Perhaps I am being a little unfair here. The same unreliability could happen with any backup mechanism that is vulnerable to corrupted backups as a result of the user shutting the lid, the computer going to sleep, a power failure. Time Machine and Time Capsules weakness is that its all to easy to disconnect the network hard disk image and once you do that the Time Capsule end has no way of shutting down the back up process in a safe way. Do that enough times (I have found 1 is enough) and the backup is corrupt and unrecoverable and even the HFS+ Journal can’t recover.

I was also a bit unfair on BackupPC, which is initiated from the server and so although it may create nightmare file systems, can leave the backup image in a reasonable state when the server looses sight of the client.

Time Machine on an attached drive appears more reliable, but a lot less useful.

Mike Jennings from the University of North Carolina at Chapel Hill has created a Spring MVC Maven Archetype for Sakai. This generates a fully functioning application for Sakai, complete with service layers, from a single Maven command.

This is just like the Apache Wicket version I created. Nice one Mike!

I’ve just released it into the Sakai Maven repository so it is now available for everyone to use. The command to generate a Sakai app from the archetype is:

mvn archetype:generate -DarchetypeGroupId=org.sakaiproject.maven-archetype -DarchetypeArtifactId=sakai-spring-maven-archetype -DarchetypeVersion=1.2 -DarchetypeRepository=https://source.sakaiproject.org/maven2/

Then simply mvn clean install sakai:deploy and you are on your way.

Any issues should be reported in JIRA: https://jira.sakaiproject.org/browse/MARCH

The 2012 Sakai Fellows have been announced. Congratulations to you all!

Lucy Appert (New York University)

Lucy Appert has been a member of the Sakai Community since 2008, when she and Bob Squillace developed a Sakai CLE-based portfolio for their liberal arts program at New York University that was funded by a National Endowment for the Humanities grant.  She subsequently became the co-chair of NYU’s Sakai/ATLAS Working Group, a joint faculty and IT task force formed to develop Sakai OAE at NYU.

Lucy has also been the organizer of the User Reference Group (URG) for the Sakai OAE Project since 2010, a member of the Sakai OAE Steering Group, and an active volunteer on the Sakai Conference Program Committee. Within the Sakai Community, NYU and larger academic communities, she has worked to raise faculty awareness of and support for the new direction in academic technology represented by Sakai OAE.

Lucy is the Director of Educational Technology in the Liberal Studies Program at NYU, where she works with the program’s more than 2000 students and 130 faculty members in New York, London, Paris, Shanghai, and Florence on creative instructional technology solutions. She holds a PhD in 17th & 18th c. British literature and has twenty years of teaching experience, twelve of them at NYU.

Chris Maurer (Indiana University)

Chris has authored over 900 code commits in support of Sakai CLE development since joining the project in 2004.  Early on he was involved primarily with the Portfolio community (OSP); his responsibilities now include serving as the lead developer for Oncourse, Indiana University’s branded installation of Sakai.

Chris is also a member of the Sakai Community’s Infrastructure Group and is the lead systems administrator for the Sakai CLE Subversion code repository (source.sakaiproject.org), nightly build server (nightly2.sakaiproject.org) and qa3-us quality assurance server instance (qa3-us.sakaiproject.org).

Chris is a Principal Systems Analyst at Indiana University, where he has worked for 8+ years. He holds a B.S. in Computer Science from Rose-Hulman Institute of Technology.

Sam Ottenhoff (Longsight Group)

Sam filed his first Sakai JIRA ticket over seven years ago (SAK-93) and has contributed to Sakai CLE development and QA ever since.  He was a member of Megan May’s QA group for the Sakai CLE 2.6 release and for the 2.7 series provided QA support as well as code patches.  In 2010 he joined the maintenance team and also the release management work group, helping triage bug tickets and serving as a 2.8.x branch manager.  He was elected to the Sakai CLE Technical Coordination Committee in September 2011 and currently serves as release manager for the upcoming CLE 2.9 release.

Sam is a founding partner of The Longsight Group, a company created to focus on supporting open-source applications for higher-ed.  Sam graduated from Kenyon College with a BA in History and worked on an early generation of campus web applications.  After college, Sam worked in New York City for interactive learning company ACTV and then as an educational technologist at Teachers College, Columbia University.

Sam Peck (Sakai OAE project)

Sam joined the Sakai Community in 2009 while working for a London-based user experience firm.  As the creative lead of the Sakai OAE design team, his work on interface and interaction design helps guide OAE’s user-centered, design-led development activities.

Sam is dedicated to ensuring that the Sakai OAE experience helps its users grow and develop beyond what the traditional LMS can offer.  His remit is to provide a user-friendly experience that promotes academic networking, group collaboration and content creation, curation, discovery and sharing–all informed by the needs of educators, learners and researchers.

Sam has been a User Experience Consultant for over 5 years and a Creative Director, Usability Consultant, Art Director and Designer for interfaces, web, applications, devices and various platforms for over 10 years.  He has worked with both start ups and large corporations and government agencies such as Billabong, eHarmony, IBM, Vodafone, Deutsche Bank, UK National Heath Services, UK National Lottery and the UK Government (to name a few).

Lance Speelmon (rSmart)

Lance is a long-time Sakai contributor who has worked on both the CLE and the OAE.  His recent development work includes leveraging IMS BasicLTI to provide “hybrid” integration points between the OAE and CLE sites and tools.  He also currently serves as a member of the OAE Technical Reference Group.

His association with Sakai actually pre-dates the project’s Mellon Foundation grant (2003).  While at Indiana University he worked with Stanford on the Navigo project (Samigo’s predecessor) and later joined the CLE architecture team headed by Chuck Severance and Glenn Golden.  He has served as track lead on a number of Sakai Conference Committees and was also seconded to the Sakai Foundation as a staff member during 2009-2010.

Lance now works for rSmart where he leads Sakai OAE and CLE development efforts.  He particularly focused on developing Sakai OAE agile processes, which rSmart is helping to mature and bring to market.  rSmart has contributed new capabilities and bug fixes to OAE as well as an automation suite around configuration, deployment, QA, and load testing.

Lance writes that “Sakai has been a game changer for me, and I am very happy to be able to remain at the service of the community.  I look forward to continued involvement with the community in as many capacities as I can muster.  It is an honor to be selected as a Sakai Fellow. I am humbled.”

Lynn Ward (Indiana University)

Lynn Ward has been actively involved with Sakai and Open Source Portfolio Communities since 2006, first as an instructional design and technology consultant with the IUPUI Center for Teaching and learning and more recently as a business analyst with the teaching and learning division of University Information Technology Services at Indiana University.  In her current position she provides functional leadership for Oncourse CLE, IU’s local instance of Sakai.

Lynn is an active contributor to several Sakai working groups, including the Sakai portfolio community, the portfolio visioning group and the teaching and learning capabilities design lenses group.  Last year she helped establish the Samigo working group, which she co-facilitates with colleagues from Stanford, and in January of 2012 she worked with Jon Hays (UC Berkeley) and Robert Squillace (NYU) to lay the groundwork for the “Teaching and Learning with OAE”, which now meets on weekly basis.

She also represents the portfolio community on the OAE User Reference Group and leads an OAE User Needs Group at Indiana University.  She has given presentations about Sakai CLE, OSP, and OAE at the annual Sakai Conference, the annual meeting of the EDUCAUSE Learning Initiative, (ELI), the annual conference of the Professional and Organizational Development (POD) Network, the Assessment Institute, and the annual conference of the Association for Authentic, Experiential and Evidence-Based Learning (AAEEBL).

By Michael Feldstein

A handful of you have let me know that you are getting 403 errors when you try to access e-Literate. There seem to be some residual caching issues from an anti-spam plugin that I deleted. I have cleared the cache on the server, and most folks have been reporting to me that when they clear their browser cache, the site loads just fine.

Sorry for the inconvenience.

Possibly related posts:

1. Site Update The site re-design is coming along and should hopefully be...
2. Site Upgrade I have upgraded the plumbing to Expression Engine 1.4. You...
3. The Site is Back Up After two days of being down due to problems with...
4. Site Themes Revamp I just spent the afternoon editing e-Literate’s site theme organization....
5. Upcoming Site Revamp This week, with the help of pMachine Services, I’ll be...

If You Are Having Trouble Accessing the Site… by %%AUTHORINK%% on e-Literate

I’ve been talking to several folks since my last post on PyOAE and it has become clear that the name doesn’t convey the right message. The questions often center around the production usage of a native Python webapp or the complexity of writing your own framework from scratch. To address this issue I have renamed PyOAE to DjOAE to reflect its true nature.

It is a DJango web application and the reason I chose DJango was because I didn’t want to write yet another framework. I could have chosen any framework, even a Java framework if such a thing existed, but I chose Django because it has good production experience with some large sites, a vibrant community and has already solved most of the problems that a framework should have solved.

The latest addition to that set of problems already solved, that I have needed is data and schema migration. DjOAE is intended to be deployed in a DevOps like way with hourly deployments  if needed. To make that viable the code base has to address schema and data migrations as they happen. I have started to use South that not only provides a framework for doing this, but automates roll forward and roll back of database schema and data (if possible). For the deployer the command is ever so simple.

python manage.py migrate

Which queries the database to work out where it is relative to the code and then upgrades it to match the code.

This formalizes the process that has been used for years in Sakai CLE into a third party component used by thousands and avoids the nightmare scenario where all data migration has to be worked out when a release is performed.

I have to apologise to anyone upstream for the name change as it will cause some disruption, but better now than later. Fortunately clones are simple to adjust, as git seems to only care about the commit sha1 so a simple edit to .git/config changing

url = ssh://git@bitbucket.org/ieb/pyoae.git
to
url = ssh://git@bitbucket.org/ieb/djoae.git

should be enough.

If you are the standard settings you will need to rename your database. I did this with pgAdminIII without dropping the database.

I will be giving a keynote at the first Sakai Mexico Conference Monday April 23 at 12:30 – after lunch.

http://www.u-red.com.mx/sakaimexico/en.html

This will be a lot of fun and for me perfect timing.

I of course will talk about IMS Learning Tools Interoperability, past present, and future. I will look at current and future interoperability strategies from a Sakai CLE, Sakai OAE, IMS, and Blackboard perspective. I will also talk about Massive Open Online Curses (MOOCs) and my course on Internet History, Technology, and Seciurity in particular. I will talk about why I am excited about the pedagogy of MOOCs and in particular why I love the pedagogy of Coursera. I will also talk about where I would like to see Coursera and other MOOC efforts like MITx and Udacity go in terms of a technical and strategic directions. In a sense – what I see as the real impact of MOOCs over the next 5-10 years. I will talk about the next two MOOCs I am planning to develop as well as how I plan to inject technology education into the Liberal Arts curricula of the future with these MOOCs.

All along, I thought that IMS Learning Tools Interoperability was a destination and that once we arrived, our work would be done. Increasingly I see IMS LTI as a mere doorway that once opened, lets us gaze at an amazing landscape of the future of teaching and learning.

This talk won’t be boring and it would be a mistake to miss it. I assure you.