Defining Assessment Records

April 17, 2010

I’ve already talked a bit about pulling the best assessment record, but I haven’t really talked about how I’m defining Assessment records in the OSIMS database.  Here’s that discussion:

At their most basic level, assessments measure students’ abilities in one or more skills.  Most often those abilities are reported as numerical values for each skill.  In some cases the assessment may also report a composite score which is a combination of all those individual skill scores.  I’ll accommodate up to 20 of these “Score Reporting Categories” or SRCs, both composite or skill scores per an assessment.  The number 20 was an arbitrary choice which should give me plenty of room for nearly any assessment.  The likelihood that an assessment is going to report on more than 20 individual areas is fairly slim.

Each line in the database will represent a separate assessment instance, with up to 20 skills represented.

Other Important Information

There are some other pieces of information to record for each assessment to make the data more useful.

In order to monitor the progress of individual students and even to group them together, I’m going to need include a unique student identifier.  I’ll also keep track of some other items that may help identify the assessment at a later date should we need to locate it.  Specifically, the user who entered the data and the date they entered it, the teacher who gave the assessment and when it was given, and the title of the assessment if one is given.  Some of these items find themselves most useful on reports intended for the students themselves.  They’ll know who to talk to if their performance on Mr. Johnson’s “Science Lab #3″ given on January 18th didn’t pass muster.

For the most flexibility in the design, I’m going to use this same database for many different types of assessments.  SAT, ACT, Oregon State Assessments, formative and local assessments designed by teachers are all going to end up in the same place and be accessible through all the same reports and tools.  So I’ll also need to provide a field that differentiates what type of assessment the record contains.

Defining Assessment Types

Assessments come in many different flavors.  Most people are familiar with the large scale “summative” assessments which present students with a lot of questions to determine their knowledge of an entire subject.  These assessments are generally given only once per a school year at most.  On the other end of the spectrum are the more informal “formative” assessments which might be as simple as reading aloud to the class for 1 minute each week.  The teacher would then record the number of words read to monitor each student’s abilities.

After examining a number of different assessments currently in use by my school district and from various vendors, I’ve identified the following criteria as being important for determining the skills and/or expectations for a wide range of assessments:

Vendor: Simply who provides the assessment or the common name used for the assessment.  This is mostly for identification purposes.  For example: Oregon Assessment of Knowledge and Skills or (OAKS).

Subject: The subject to which this assessment pertains.  Reading, Math, etc…

Level: For which  level of student is this assessment appropriate?  3rd grade, 4th grade, 10 year olds, high school students, etc…

Window: Or “window of time” for assessments which are given multiple times a year.  The test may expect students to perform differently at different points in the school year, or even measure different skills at different points.  This identifies to which window of time the assessment relates.

Discipline: At times an assessment may be available in different areas.  In the case of the Oregon Writing assessment, students may write a narrative or persuasive piece.  This would allow for identifying those traits and would allow for different skills to be measured in differing disciplines.

I’ve chosen to allow each unique combination of these traits to represent a different assessment type.  Each assessment type dictates which skills are to be assessed, and what students are expected to know.

For example, the the DIBELS assessment measures Reading skills for students in primary grades K-3rd.  First grade students are measured during the fall window of time on “Letter Naming Fluency” but by the winter window, that measurement is replaced with two other skills.  By tying the skills to the traits above, we’re able to make that transition in skills within the system.

At the same time, the same structure can accommodate the OAKS Social Science assessment for middle school which measures kids on five skills and is only given at the 8th grade. Or SAT scores…


Pulling the Best Assessment Record

March 25, 2010

During the course of a school year, it may be necessary to assess students multiple times.  This information can be very useful for monitoring the progress of students, but it also causes problems when you simply want to know the best scores that a group of students have posted.  Getting the best record for an assessment often means a two part process of identifying the best records and then pulling those records together for display. In many information systems there are whole routines set up which go through the data student by student every night to identify and flag the best score for each student.

Maybe it’s just me, but this seems like a really inefficient method of finding the information.  What if you want to enter scores and get a report today, rather than waiting for a process to run?  What if you want to know the best score between October and December instead of the best score for the entire year which the system flagged?  I’m exploring a method to give schools realtime, flexible access to to best records.

Why you can’t just use MAX

Assessments records are really a collection of scores also called traits.  A student may score 100 overall, 130 in estimation and 95 in measurement all on the same test.  The next time he may get 110, 100, and 105 respectively.  If I use the SQL max function on each trait I would get a mix of the two test records that would look something like 110,130,105.  While this is the best he performed in each trait, it’s not indicative of any one attempt, they both got jumbled up together.

A better method would be to use max on the overall trait, somehow identify the record and them come back and pull all the traits for that record.  Even that has it’s issues within SQL and requires at least two queries against the database.

More Left Joins

I’ve spoken before about my love of left joins for querying student data.  When dealing with a class list, it simply makes sense to have all the students represented once, whether they have data or not.

What I’ve found is that with a more creative use of left joins I can readily get the best record in a number of situations.  I’ll start with the students, left join assessment records, and then left join the assessments again to force the best record to show.

In pseudo code it might look like this:

select stu.*, a1.*
from students stu
left join assessments a1 on ( ... define the assessments I'm looking for ...)
left join assessments a2 on ( ... exact same as the definition of a1 above ... and a2.overall>a1.overall)
where is null

So what have I done here?  I’ve told the SQL engine that I want two assessment records and that a2 should be “better” than a1 in the overall trait.  Then I’ve used a bit of reverse logic to say that I only want records where a2 doesn’t exist.  That would effectively mean cases in which there is no record better than a1.

A little Deeper

There is a danger that the two assessments may have identical overall scores, which would cause the system to return two records for any given student.  To address this, I actually append the record ID number to the overall score before comparing the records.  Since the IDs are unique by definition, I’ m guaranteed that one record will be “higher” than the other.

In practice the on statement code that does the c0mparision actually looks like this:

... and ( concat(lpad(a2.overall,10,0),lpad(,10,0)) > concat(lpad(a1.overall,10,0),lpad(,10,0)) )

The padding makes certain that the two records are compared on even grounds.  In the event of a tie in overall score the record with the higher ID number wins, which tends to favor more recent records, but that should be acceptable in most cases.

Inherent Flexibility

Unlike many existing systems that flag records ahead of time, this left join approach allows me to change at any time the range of records I’m examining.  For example, I might start out looking for the best Math tests regardless of grade level, then limit them to 5th grade scores, then go even further and ask for the best scores on 5th grade math tests given between October 5th and November 5th in Aardvark Elementary.  There’s no recalculating and reflagging required because this single SQL call can handle any of these requests by simply changing the ON clauses related to the assessment records.

Other Uses

I’m sure there are dozens of uses for this type of query.  I’ve found it useful for pulling the best record on any number of criterion, including the performance level, any of the traits, and even the “Most Recent” record within any time frame.


The Case for Left Joins

March 6, 2010

When working with educational data, the student is going to be the center of nearly every database query.  From there we might attach test records, classes or involvement in programs.  Often times programmers accomplish this with what is known as a “full inner join”.  A method by which relevant records from both database tables are only shown when there is a definite match.  This is the most basic of SQL calls and usually the first one learned.  It goes a little something like this:

select * from students,
assessments as a3,
assessments as a4
where = a3.studentid
and = a4.studentid
and a3.grade = 3 and a4.grade = 4

The above database query would return all of the students and assessment scores for students who have 3rd and 4th grade assessments.  After the “where” reserved word I’ve specified how to relate the table to the student and which grade I’m expecting.  A major downfall of this query is that it won’t  show me students who don’t have both assessments.    If a student has a 3rd grade test but no 4th grade test he just won’t be in the results. Nor will students with no tests.  Most often educators and teachers are going to want to see their entire class list with holes where students haven’t taken assessments.  For this kind of information a different type of query is required, known as a “left outer join”:

select * from students
left join assessments as a3
on ( = a3.studentid and a3.grade = 3)
left join assessments as a4
on ( = a4.studentid and a4.grade = 4)

A query in this format will pull all of the students and then fill in the assessment data where available, leaving blanks where students have no data.  This is a much more useful and intuitive way to display student information.  Students don’t appear to be “missing” from class rosters, and staff can quickly locate scores or even identify students who didn’t receive the assessment.

Clarity and Modularity of Code

I feel that code making use of left joined tables is easier to read.  Instead of parsing through the where clause to find the ways in which tables are joined together and limited, I can quickly find the same information in the on clause immediately following the introduction of the table.

Because the pieces are grouped together so well, it becomes easier to write a program that will build the SQL statement.  I can start with the student table and then just ask if any other modules have left join information to include.  An assessment module might provide the left join statements for including 3rd and 4th grade tests.  A Student Groups module might include the left join that specifies whether or not the student is ELL.  Thanks to the format, these can all happen independently of each other.


The left join also allows us some additional flexibility with regards to filtering the results. By appending some simple where clauses to the example SQL statement above we can find out some quick and useful information.

where is null

will show us students who don’t have a 3rd grade score but any 4th grade scores they may have.

where is not null

will show us only those students who have 3rd grade scores.

Of course, we could mix and match a3 is null and a4 is not null and so on to find all kinds of groups including

where is not null and is not null

which simulates the original non-left joined query above.

This level of flexibility is one of the main reasons I prefer to use left joins.  I can quickly provide a list of students who were enrolled in a given class and who have not yet taken an assessment so that they can be brought in to test.

Throughout the OSIMS system I’ll be making near exclusive use of the left outer join format.


Grouping Student Data for Analysis

February 22, 2010

When designing the student data I made the unusual choice not to include the student’s gender in the student table.  While the information may be useful for identifying students it really only narrows the field by roughly 50% and I think there are more useful ways to track the information.

Aggregating / Disaggregating Student Assessment Data

When analyzing student assessment data we often look at the aggregate, or combined, data for a school.  What percentage of the students in the school proved they understood the concepts they’re expected to know at their grade level?  It might then be useful to look at how well different groups are learning the material.  Do the girls seem to be doing better at math than the boys?  We call  this disaggregated data.  Truthfully it’s information that’s still “aggregated” but at a finer level than the whole school.

In order to allow for the maximum flexibility, I want to create one method for aggregating and disaggregating students that can be used in many different scenarios.  I’m going to do this by creating “groups” into which students can be assigned.  An individual student can be a member of many groups at the same time, and each group can then be used to aggregate the data.

Virtually anything can be a group of students. Some possible example groups are:

  • Male/Female
  • School
  • Grade
  • Teacher
  • Ethnicity
  • Native Language
  • Football Team
  • Needs Additional Tutoring

Having the ability to create such diverse groups will allow educators to track the performance of many different student populations and the effects of instructional programs.  Teachers will be able to use any number of groups when drawing reports.  By specifying multiple groups, extremely targeted information can be attained.  Perhaps we want to know the effects of a new textbook on Russian speaking students in Aardvark Elementary school as compared to their English speaking peers.  Trust me, that type of information can be difficult to determine in many of the systems that educators are currently using.  We’ll be simplifying that to a few clicks of the mouse.

Types of Groups

For many reasons it makes sense to define types of groups.

The first is for clarity and organization.  The Male and Female groups are both Genders and should be a separate field from the Caucasian, Hispanic, and African American groups in the user interface.

The second reason is that some groups should be mutually exclusive and some should not.  Students shouldn’t be able to fall into two different gender groups, but they might fall into a couple different ethnicity groups.

The third reason is to make some required.  When adding a new student to the system, it might be wise to force school staff to enter the student’s gender and ethnicity, but they students don’t have to be required to have an after-school activity.

User Defined Groups

In addition to information that is tracked through the formal existing data systems, teachers sometimes need to track small informal groups of students.  Maybe the teacher has identified a few struggling students and is giving them additional tutoring.  It would be nice to be able to show those students to their peers.  Allowing all users of the system to create their own private groups gives the greatest amount of utility.  Each user can track exactly the type of information they wish to see.

Access Control

When it comes to student-by-student information, teachers generally only need to see the information for the students in their class.  In OSIMS the teacher’s class will exist as a group with students assigned to it and we’ll simply allow the teacher access to that group.  Similarly, Principals will have access to their school’s group, and specialists might have access to the Special Education group within a school.

By assigning students to groups, and allowing aggregation on any number of groups, OSIMS will give educators an unprecedented ability to monitor the progress of students.


Interactions between Xaraya and ExtJS

February 13, 2010

I’m building OSIMS as a series of Xaraya modules enhanced with ExtJS.  Xaraya does a great job at returning whole webpages of information, but that may be more than I need in many cases.

How Xaraya Builds Pages

Web page requests come in through the Xaraya core and are routed to the appropriate module and function.  They are routed based on three variables: module, type, and func .  The type is generally used to define if these are admin (data manipulating) functions or user (data viewing) functions.  Effectively, it tells the core in which folder of the module it can find the function.  Requests are sent through display functions which in turn make requests to the API functions that actually interact with the database.  The results are bundled up and applied to the appropriate template which results in the webpage that is displayed.

Using ExtJS, OSIMS is going to be a heavily Asynchronous Javascript And XML (AJAX) program.  When creating AJAX type programs, the web browser sends dozens of requests for small pieces of data.  Where a non-AJAX program might allow a user to choose a School District from a select box and then reload the entire web page to get the appropriate schools in another select box, an AJAX program would just send a request for the schools in the background and quietly update the list.  The responses from the server shouldn’t be whole webpages which then need to be boiled down to discover the relevant data.  Such an approach adds a lot of overhead and complexity to both sides of the equation as well as drastically increasing the bandwidth requirements.

My first attempt to reduce the amount of data coming back from the server was to create a Xaraya theme called “ajax” which did nothing more than wrap the module’s response in <xml></xml> tags.  By having my javascript send its requests with theme=ajax as a variable, I would get back just the basic responses from the module without any menus, headers, footers, or styling.

This worked pretty well, but what I found was that I was creating little mini-functions that did nothing more than pull data from the database APIs and then turn that data into an XML structure to be sent out.  The whole thing was kind of messy requiring me to create functions and templates for every little thing that could possibly be requested.  What I found is that I really just wanted to take the data straight from the database API and send it to the javascript.


At the same time I was questioning the need for XML and finding that there was perhaps a better transfer method.

AJAX stands for Asynchronous Javascript And XML, but the ExtJS authors prefer to use something called JSON or JavaScript Object Notation to transfer data from the server to the javascript code.  With JSON, the server sends back valid javascript code which can be quickly interpreted and used by the javascript engine.  Not only does this reduce the parsing overhead, but it also cuts down on the data size since javascript notion is more concise.  A JSON response for two students might look like this:


where the same XML might look like this:


Even with just two records it’s easy to see the JSON response is much shorter.  Imagine pulling data on thousands of students.

The decision to switch from XML to JSON became even clearer when one release of ExtJS included new functionality for writing to the database in JSON that wasn’t available  in XML.  It may have been an oversight in a single release, but it was enough to persuade me to make the change.

Specialized JSON Functions in Xaraya

Instead of returning XML through a specialized theme and creating dozens of functions and templates, I’m going to to create javascript specific functions that hook straight into the Xaraya API and return JSON results.  My javascript will now send requests to the “json” type rather than “user” or “admin” and those functions will take the results straight from the API and encode them as JSON.  I’ve created a helper function within the ExtJS module just in case PHP isn’t loaded with JSON support.

A brief example of this in action might look like this:

function students_json_read(){
  $result['items'] = array_values(xarModAPIFunc('students','user','get',$args));
    $result['success'] = true;
    $out = xarModAPIFunc('extjs','user','encode',$result);
    $result['success'] = false;
  echo $out;

The OSIMS Store in ExtJS

Since nearly every module that I’m going to build will have the same sort of functions (create, read, update, delete), it makes sense to build common components that can be re-used.  In ExtJS, I’ve created my own datastore by extending the provided JsonStore with some predefined settings.  By doing this, I only need to define the specific Xaraya module that I want to interact with, and which fields should be expected back and I’ve given ExtJS everything it needs to know to read and modify data for that module.  It knows to send the requests through my json type to the module  and which functions to hit.  Now setting up a datastore that can interact with my student data is as simple as


Designing Student Data

February 6, 2010

The key to any student based information has to be the students.  They are, afterall, the reason we’re building the system.  In this assessment system we’ll be tying all sorts of data to these students.  They’ll be enrolling in schools and classes, participating in educational programs, taking assessments and accumulating requirements toward graduation and certification.  Because they are so central, it’s important to closely consider what needs to be tracked and how it will be most useful.

Just the Basics
When determining what qualifies as student information there are a myriad of possible fields.  Things such name, nickname, birth date, gender, graduation year, school of enrollment and native language quickly come to mind.  The easy thing to do would be to start building a students database table and adding all these fields and more as needs arise.  But I think it’s important to put a little more though into the system and the manner in which we’ll want to access the information.

Instead of creating a table that’s thirty or forty fields long, I’m going to choose a few key pieces of information which will help me to identify unique students and use those to create my students table.  I’ll be leaving off a lot of information so that it can be incorporated in ways that make it more useful in the future.  Perhaps the biggest surprise is that I’ve decided to not even include gender in the students table.

Here are the pieces I feel are necessary to identify unique students:

Unique Interal ID Number
First Name
Middle Name
Last Name
and an
External ID (or two).

For school district staff to be certain they have the correct students, name and birthdate is usually more than sufficient.  In practice that only falls apart when you have twins (whose first names can sometimes be similar) or when the district contains two students with the same name (think John Smith and the like) and who are roughly the same age.  Then you really have to scrutinize the birthdates and at times make a few calls to determine you’ve got the right student.  Such instances, while rare, are virtually unavoidable.

Most data we receive into this system should, hopefully, identify the student by a unique numerical identifier which I’ll store in external id.  Although I’ve only defined one external id per a student at this time, I may reconsider and add a second.  In practice students can have as many unique student ids as there are data systems.  In the last seven years I’ve seen a district go through two and a half primary datasources which has left us with two district assigned ID numbers for kids.  The state of Oregon maintains it’s own unique identifier for each student in the state.  Food services, migrant services and other programs each assign students from their own set of identification numbers.  Even other tracking tools give students their own ID numbers.  In an ideal world one student ID would be sufficient, but I can easily see how my particular case may require at least a district and state identification number.

But why not gender?

There are some very common ways in which student data is grouped and analyzed, one of which is gender.  Though it can be enlightening and entertaining, we aren’t likely to group students by first name and compare all the Johns’ test scores to the Joes’.  We may, however, want to compare schools, ethnicities, poverty, English proficiency, or gender.  I’ve made the concious decision not to include gender in the students table because I want to include it alongside all those other indicators for reporting purposes.  The case could be made that districts may wish to analyze data by age and that birth date is the gateway to that element.  This is a valid point, but in the past eight years I’ve only had age requested once, and grade level was a fair proxy for that information.  If the need is great enough, it could be fulfilled by creating a process that extracts date of birth and fills the related indicator for age.

In Conclusion

I’m designing the student table with only the most basic and necessary pieces of information.  Any indicators which are likely to be requested for reporting purposes are being left to a separate process.  I’ll explain the process for these indicators in a future post.


Integrating ExtJS into Xaraya

January 30, 2010

I’m using Xaraya as the php backend for this project.  It’s a very robust platform to build upon with a number of great features for dealing with access control, templating and customization.

It was, unfortunately, built in the time before “AJAX” when javascript use was far more rudimentary and mostly for cosmetic purposes.  After a fairly substantial development hiatus, recent updates to Xaraya have sought to improve this situation.  They’ve recently introduced the ability to include javascript frameworks within Xaraya and have used JQuery to improve many of the administrative interfaces within Xaraya.

Unfortunately, I still see some problems with the Xaraya approach, so I’m going to create an ExtJS module for Xaraya which will make the framework’s functionality available in this project.

The Pre-Existing JS Support in Xaraya

The existing support for Javascript in Xaraya is supplied through the “base” module, which is the core module of Xaraya.  It’s the base on which everything else can be developed.  At the most basic level, Javascript files can be linked either from within the API backend by calling the “modulefile” function like this:


or in the page templates by including a custom Xaraya tag in a template:

<xar:base-include-javascript module="extjs" filename="ext-base.js" />

Both of the above examples do essentially the same thing.  They simply tell Xaraya to look in the ExtJS Xaraya  module and link the javascript file called ext-base.js into the current page.  This function also takes care to ensure that each javascript file is only linked once per a page regardless of how frequently the request to include it is made.

The Expanded JS Support in Xaraya 1.2.0

Just in the last couple weeks the Xaraya team released version 1.2.0 in which the primary improvement is the inclusion of JQuery and better javascript support.  This change adds several new javascript template tags:

<xar:base-js-framework name="extjs" />
<xar:base-js-plugin name="rowactions.js" style="rowactions.css" />


<xar:base-js-event name=”ready” code=”$code” />

These tags seek to formalize the javascript abstraction layer by loading a pre-defined “framework” and then applying its plugins.  The event tag actually uses some framework specific templates to send javascript to the browser.

The first two seem like a step in the right direction, but the last one seems a bit misguided to me.  The intent is to be able to pass the $code to the ready event of whichever framework is currently being used.  Ideally this would allow one  javascript framework to be exchanged for another, but in practice any javascript code in $code that’s being passed is unlikely to be framework agnostic.  The passed code is going to need to be specifically tailored for the toolkit being used.  So there seems little point in having the ability to pass code to javascript frameworks that likely won’t be able to understand what to do with it.  Besides, the rules about how to compose and send javascript code through this function gets really confusing.

As an additional hassle, to be able to use an existing framework in this way, the framework needs to be “Xarayaized” to fit specific layout requirements.

Avoiding the Overhead

Xaraya dictates a very strict structure for its modules.  Within each module are sections for APIs, Styles, Templates and so on.  In this structure, all javascript is to be in the ./xartemplates/includes folder.  Cascading Style Sheets (CSS) should be in the ./xarstyles folder.  Images all belong in the ./xarimages folder.  This works well when developing a stand alone module, but when building on the work of someone else, it means a lot of time is spent pulling out pieces of the package and updating the text of CSS and javascript files to point to the correct locations.  Everytime there’s an update to ExtJS I would have to search through the folders for all the images and css files, move them to the correct folders and modify the css to look in xarimages.  Even Javascript Frameworks included by the base module have to go through a similar process and end up as bits and pieces scattered around several directories.

I’m lazy.

I’d much prefer to just drop in the latest release from the ExtJs team so I’ve created a module called extjs.  Inside the module, in the ./xartemplates/includes/ folder I just upload the entire extjs package.  I’ve then created an api function called base which does the following:


This function is looking at the specific locations where these files are located within the ExtJS packages distributed by the ExtJS development team.  The xarTPLAddStyleLink function creates the CSS link similar to the javascript functions.  Normally it would look for the CSS files in the xarstyles directory, but I’ve I’ve used the relative URL ../xartemplates/includes to back out of the xarstyles directory and point it in the right direction.  Now I no longer have to pick apart the the ExtJS packages, I can just drop them in and they’re ready to go.

Adding More Functionality and Convenience

To make things a bit more convenient, I’ve added a Xaraya module variable for the ExtJS version, and another to turn on/off debug mode.  By changing the module configuration through the user interface I can select which version of ExtJS to use and whether to use the smaller file to save on bandwidth.

Because I haven’t broken the ExtJS code into bits and pieces, all the distributed examples and documentation is intact, and a couple quick links can be provided directly from the module’s admin page.

Finally, the Xaraya template engline allows the creation of custom tags.  In the installation of my module I have the following line:


Which allows me to include the ExtJS in any template simply by including the HTML-like tag:

<xar:extjs />

I’ve made the Xaraya ExtJS Module available here:


Building the Framework

January 16, 2010

At a wedding last summer I was seated next to a gentleman who sells motorcycles for a living.  He asked me about computer programming, “It’s all ones and zeroes, and a lot of math isn’t it?”  It was an interesting question because, yes, ultimately everything in the computer is just ones and zeroes, but programmers don’t often work on that level.  Having seen more than a few episodes of Orange County Choppers, I came back with what I thought was a fair analogy.  When building a motorcycle he uses parts that other people have already designed and built like the engine, the carbeurator, and wheels.  Similarly, I don’t work in ones and zeroes, I use tools created by others to build a complete machine.  I guess my analogy wasn’t strong enough because he soon dropped the conversation to focus more intently on his meal.

In any case, here are the pieces I’m planning to use for the OSIMS motorcycle.

Open Source and Web Based

Open Source software provides a cost effective starting point for any project.  Thousands of people world wide are able to collaborate on software for the mutual benefit of everyone.   From games to email to image processing to whole operating systems, virtually anything that needs to be done can be done well if not better with Open Source software.

For the educational environment which can require collaboration on hundred of data points around students which move between classrooms, web based delivery is a must.

With that in mind, I’m using the popular LAMP setup as the basis for this project:

  • Linux – The operating system of choice for the web
  • Apache – The webserver of choice
  • Mysql – a popular database system
  • Php – a web scripting language

In truth, only the last two will be critical for this program.  Mysql and Php can be run on many operating systems and webservers.  Linux and Apache are well supported and free, so I’m going to use them for cost reasons.

Application Framework


I’ve been using Xaraya for years to develop web applications.  Billed as a Content Management System it does much more than just deliver blog posts.  The system is well designed to allow programmers to create modules which then benefit from a fine-grained user permission system, comprehensive templating system, and the features of any other module.  Perhaps the most impressive feature is the concept of Dynamic Data.  In this program we’ll be able to create a simple student object containing only the student’s name and then, through no additional programming and at the whim of the administrative user, be able to append fields to allow the entry of the student’s birthdate, gender, nationality, fees due to the school, or even the student’s school photo.


Five years ago I designed web applications to specifically avoid javascript.  At the time it was generally used only for decorative flourish, and was often implemented poorly and inconsistently across web browsers.  Then, one day, Google introduced “live search” and suddenly the playing field changed.  Now, the functionality of Asychronous Javascript And XML (AJAX) is all but expected in web development.  By responding to user interactions in real time we’re able to create a much richer end user experience.

ExtJS provides a lot of excellent functionality with a very well documented API.  With very few lines of code, we’re able to create things like sortable, filterable, and groupable tables of data.  I intend to make extensive use of the ExtJS framework to create an elegant interface for users to interact with the assessment data.  I’ve definitely got more than a few dreams which I believe can be realized though this framework.

The Xaraya framework was built in the time before AJAX but thanks to it’s well designed module structure, I’ve been able to create a module to incorporate ExtJS into the project.  We’ll have the user functionality of ExtJS with the security and data abstraction features of Xaraya.  At this point my biggest concern is that I may loose many of the theme and accessibility features of Xaraya.  But hopefully with some effort I’ll be able to restore those down the road.


If a picture is worth a thousand words than a graph is worth a thousand tables of data.  Finding effective ways to convey information through graphs and charts has become something of a past time for me.  Surprisingly, I find many of the available graphing APIs to be sub-par.

Ideally I would like to have a purely javascript solution, but those available seem to be extremely limited in their capabilities.  The most recent version of ExtJS has a chart module, but it too seems limited at this time and it requires flash on the client computer.  I would like to keep the requirements for the clients as simple as possible, so I’d like to avoid browser plugins.

Chart Director is one I’ve been using for years.  It can create very pretty graphs featuring multiple data sets.  It generates a high quality image along with an image map to go with it.  My current plan is to capture this image map and use it to provide some javascript functionality to the standard Chart Director graph.

Chart Director isn’t ideal.  It’s distributed as a PHP module which requires some very specific server setup which can be a hurdle to some folks, it’s also not Open Source.  There is a licensing fee though it’s very economical for the benefits it provides.  I’ve got a $100 developer license, and it’s conceivable that we could get a $500 redistribute license for this project.

In Conclusion

There are the pieces that will make up my motorcycle.  Right now they’re just a bunch of parts in a box, but soon we’ll begin tooling the end machine.


Web Software Makes Sense for Educator Tools

January 13, 2010

Education is a very interesting environment in which to design software.  There are many moving pieces of information.  Students move into and out of the system, they progress through multiple classrooms and through many different teachers.  Software designed for educators to track data on students  must take this into consideration.

Desktop software can be a very isolated experience.  Each user installs his own fresh version of the software and sets to work in his own private environment.

Perhaps I’m a teacher who has gathered assessment data on my students.  If I want to share the data I might create a file and send it to you, but then you’re posed with the task of loading it into your version of the software.  Along the way there are many places in which things can go wrong.  Perhaps your version of the software isn’t up to date and so you can’t open my file.  If we’re on different operating systems we may find we can’t even use the same piece of software.  Maybe I’ve got the student first period and you’ve got him fourth.  So I’m recording more information each day, am I supposed to send you a data file every morning for every student?

Web delivered software addresses all of these issues and has many advantages, especially within an education system.

Mobility and Collaboration

As I mentioned above, educators frequently struggle with issues of mobility.  Students who arrive in a classroom often come with very little (or no) data.  Maybe the previous teacher had kept meticulous records in her own electronic score book and recorded a whole year’s worth of data, but that doesn’t come with the student.  For a school district which has adopted an web delivered solution all of the data from every assessment is stored in a central location on the server.  Teachers have instant access to the entire depth of the student’s educational data within the system including multiple years of performance without needing to do any data transfers or imports.

Similarly an English teacher may be tracking the student’s Reading abilities, and the Math teacher his Math abilities, but neither can see that the two are related when the records are stored on separate computers.  If the data is housed in a central location, the breadth available to teachers is greatly expanded.  Suddenly it becomes apparent whether the additional instruction in Reading is improving the student’s Math scores as well.

OS Agnostic

People have their preferences and the divide between Mac and Windows users can run deep.  We could argue at length about which OS is best for the educational environment but we would never be able to reach a decision on which everyone could agree.

Some software will only run on a single operating system; I’ve actually seen staff members with two computers on their desk to deal with just this type of issue!  Whatever the operating system preference, any modern operating system must be able to support a web browser.

By creating web based software we can avoid the OS question all together.  In fact, as mobile devices such as cell phones become more sophisticated and web ready, it’s not inconceivable that teachers could be entering and accessing assessment data from their cell phone while waiting to check into a conference or get a table at their favorite restaurant.

System Requirements and Upgrades

Obviously, if we’re talking about crunching data from cell phones, we’re talking about quickly outpacing the processing capabilities of such a small device.  With a web application, the number crunching can all be done on the server, and the results can be sent as something displayable on even the oldest or weakest computer.  For public institutions concerned about budget allocations a single server upgrade can be very cost effective when compared to upgrading hundreds of teacher computers.

At the same time, software upgrades can all be done within the server.  Users never have to download or install anything to get the latest and greatest versions of the software.  Bug fixes can happen instantaneously and we can be confident that all users are seeing corrected information.


Web delivered software has many advantages over traditional desktop software, particularly when used to collaborate between many different people.  It can ensure that everyone has seamless access to the most recent data and software improvements.

Education is an environment where dozens of people may collaborate on the education of each student.  Web based software is the most effective method for that collaboration.


Taking Educational Assessment Data to the Next Level

December 18, 2009

What is OSIMS all about?

Several years ago I was hired by the North Clackamas School District in Oregon to help facilitate their assessment tracking efforts. What I didn’t realize then was that I was to be an integral part of a very progressive approach to student assessment in the State of Oregon. While seniors that year were able to prove their abilities on state tests to receive an optional certification on their diplomas, the North Clackamas School District was looking to go one step further by requiring seniors to prove their mastery of material through multiple options and opportunities. Tracking the multitude of options such as state assessments, classroom work samples, third party nationally-normed assessments and classroom credit for thousands of graduates was a daunting task which my manager, Dr. P. Craig Nikolai, recognized as requiring a very customized piece of software.

Times Change

Seven years later, Oregon has officially scrapped the certification model and is instead moving toward a achievement based graduation model where seniors are required to prove their mastery of material through multiple options and opportunities. Suddenly the software Craig and I developed and maintained for the North Clackamas School District over the past seven years is of relevance to a lot more people.

Also during the last several years, schools have become increasingly more sophisticated in the ways in which they use assessment data to track student achievement and inform instruction. A huge amount of professional development centers around strategies enabling teachers to better use assessment data to identify potential gaps in student learning and to track students’ response to teaching techniques. Software to support these strategies often lag behind the assessment and strategies themselves and tend to be limited in their scope.

The data system currently employed by North Clackamas was designed in a bubble, addressing one district’s very specific needs around a very specific set of assessments. As the years have passed, the limitations of that system have become increasingly apparent. Graduation requirements have changed; specific assessments have come, gone, or been modified; teachers’ data needs have increased drastically; support for complicated web delivery particularly javascript has gotten a lot more robust; and data formats have changed and changed and changed again. All of these changes over the years have had me re-imagining the North Clackamas system with the type of clarity that can only be achieved in hindsight. At the same time, it seems only logical to design the system in such a way that it can be useful to other educational institutions as well and to share my experience with others.

The OSIMS project was originally envisioned by Craig Nikolai in 2005 as a continuation of the work he’d begun in North Clackamas. Now, years later, I’m ready to apply the lessons I’ve learned through the last seven years to build a data system which I hope will allow educators to not only to find the answers they seek today, but allow them to answer the questions they’ve not yet even though to ask.