Gibbon: an open source education management system

In search of a flexible, open education management system

Image by : 

opensource.com

Watching gibbons play is like nothing else on earth: they show astounding flexibility, speed, and grace as they swing, run, and jump. These long-armed primates are found in forested areas of Southeast Asia and move by swinging and leaping from tree to tree. Their sense of fun is almost tangible in the air around them. Although lofty, these attributes are what the Gibbon project, an education management system, aspires to bring to schools and colleges.

When I started working in education, I was hired to build web-based systems to fill the gaps left by other school platforms. For example, a system might have been designed to work for a North American school, but after deployment to an IB school, it was discovered that certain features were missing. These large, unwieldy systems were difficult to use, even for a technician, and never seemed to do quite what the job called for. In one such system, it was not unsual for a teacher to have to master SQL table joins before being able to retreive data on their students. Needless to say, such interfaces with student data did not prove popular with teachers struggling to meet the demands of their jobs. As I progressed in my career, I became involved in evaluating, procuring, and designing large systems like these, all with the goal of finding one that met the diverse needs of a large group of schools (e.g. taking attendance, learning more about a student, keeping an organised grade book, etc). Never once did a system jump out as being particularly easy to use, nor did any seem to be complete in needed functionality.

Gibbon

After changing career paths and training to become a classroom teacher, I began a job as the ICT Coordinator for International College Hong Kong. In this position I was responsible for providing coherent software tools to help teachers and students work effectively. What I found installed was a corporate ERP tool hacked to fit a school setting. Naturally, this did not really facilitate teaching and learning in the way I had hoped, for example, by allowing teachers to plan lessons and share them with students.

I felt strongly that an open source system was the answer because it could be improved and tailored to meet the needs of the college. However, after much searching, I could not find a flexible, open, and functional school system to meet our needs. Without really understanding the size of the task, I decided the only path was to build one myself.

This decision was also driven by a feeling that I had benefited from open source software many times in my life. I've been a user of Linux, Firefox, Drupal, and WordPress—as I'm sure many of you have as well. I felt this was my chance to give back to an open source community of committed users and developers whom I respect.

I own the copyright to a school-centered system called Muse, so I began there, stripping back and rebuilding the code to produce a user authentication and management system—today called, Gibbon. With this in place, I began building one of Gibbon's defining features: a flexible system for controlling functionality for users across the system. Like Drupal, it has a flexible set of modules, each defining a set of actions users could perform. Grouped in roles, users can then be given access to functionality with just the check of a box. Gibbon has core modules and themes and is built to allow easy integration of additional code to adjust both functionality and appearance.

With the framework in place, I began replicating in the database and code various structures found in schools, like: academic years, year groups, spaces, roll groups, courses, classes, students, and teachers. Each of these structures was designed to work for a broad range of schools, such as those catering to different ages (primary or secondary school) and those teaching different systems (e.g. UK National Curriculum, IBO, etc). With this type of flexibility comes difficulty, as it requires thinking not just about the case in front of you, but of all possible cases. For example, you cannot simply hard-code in a school week running from Monday to Friday, as this is not universal around the world. Although time and resources were limited, I spent a lot of time on this, reasoning that it would save time in the future.

Next, I was ready to start writing user functionality. Naturally, I began with the needs that were most pressing at the college where I worked. The first was access to students' profiles, where teachers could learn all they might need to know about a student. Then I built a module where teachers can create, store, and share lesson plans, followed by another where they can also store and share grades. I built each new module or functionality in private in order to avoid getting bogged down, including pet features for everyone, releasing it to relevant users only when it was stable and useable (if not complete). I then got feedback from the few early users and quickly implemented changes. By operating in this manner, I showed a willingness to improve the system and attracted more users to the system.

Overall, development of Gibbon was rapid, non-linear, and unplanned. Driven by the needs of now-interested colleagues, myself, and the other developers on the project, I have added functionality to track behaviour, run activities, view timetables, plan units of work, share resources, and more. By releasing early and often, each new development exposed the system to new strains, which needed to be addressed before moving forward.

The result, for users (administration, teachers, parents, and students) is an education management system that provides end-to-end workflow, supporting teaching and learning from planning to classroom learning to asssessment to reporting. Gibbon also supports a wide range of educational experiences—for instance, all within one system, a teacher can use Gibbon to plan their curriculum, share lesson plans, assign and collect homework, and grade and assess feedback.

Three years and seven versions into the project (v7.1.00, Agile, was released in December 2013), and Gibbon has reached a relative level of maturity, if not completion. It is currently used in the running of most aspects of my own college and of our partner school. It is also under testing in several other schools. Gibbon ships with 24 core modules, handling tasks as diverse as education, school management, finance, and communication. With a library of five free additional modules, and developers available to custom-build more, it is highly malleable to the varying needs of any educational institute.

The next phase for Gibbon is growing the base of education organizations that implement and use the system as well as the passionate community of developers and supporters. If you would like to learn more about Gibbon:

 

About the author

Ross Parker - Teacher & Technology Director, open source developer (http://thegibbon.org ) and advocate. Working in the strange and wonderful intersection of technology and education, living in Hong Kong. @rossdotparker on Twitter.