Author Archives: Brian Panulla

Why Open Rubrics?

In my past few posts, I tried to shed a little light on my interest in an open data model for educational rubrics. If you’re new to the general concept of a rubric, there’s a fine summary on Wikipedia. So what do I mean by an “open data model”? Let’s break that down.

Again from our friend Wikipedia:

A data model in software engineering is an abstract model that describes how data are represented and accessed. Data models formally define data elements and relationships among data elements for a domain of interest.

The jist is that we need a way to describe rubrics, whole or in part, for use in a software system.

Most of the online rubric generator tools produce a rubric document – usually in HTML, or possibly PDF or Excel, that lends itself well to printing and other pre-Internet use cases. But document rubrics are not easily integrated into any sort of information system – in these cases, they are merely presentational forms of a rubric, and contain little or no semantic information about the meaning of the various parts of the document. So the world of computerized rubrics is similar to the state of Web development in 1999 – lots of non-semantic, presentation-laden documents that are hard to process by any sort of software.

So why an open data model? My thoughts on this tend to group into two arguments:

  1. transportability – a rubric is a document that should be able to move from one technological system to another. There are a few existing rubric tools that do create a computer-readable rubric document, but the file format is proprietary – rubrics created in such a system can only be used in that system, and can’t be exchanged with other systems that might be able to use them, except in some presentational form like PDF.
  2. continuity – relying on any sort of proprietary system as the sole means of reading and storing important data is no longer an option. Even de facto standard formats like Microsoft’s Word DOC and other Office file formats are deemed too risky by many governments, leading to the creation OpenDocument Format Alliance.

So what type of format should we use? HTML and XML are great at describing the structure and content of documents, but less so the meaning implied by the information.

The Semantic Web provides some exciting possibilities for open data in all forms. So why not rubrics?

Next: Semantic Rubrics

March 9, 2010Permalink Leave a comment

Why many Microformats begin with ‘h’

I’ve been spending some quality time with several Microformats as part of my work for DealerPeak. We’ve been adding semantic attributes, including hCard, hProduct, and hListing, to the pages generated by the DealerPeak Automotive Dealership CRM/CMS system.

During a recent redesign of the car listing page, I was adding hCard microformat information to the dealer contact information block. As I was reviewing the hCard specification, I came across the following text:

The root class name for an hCard is “vcard”. An element with a class name of “vcard” is itself called an hCard.[1]

This distinction struct me as a bit odd, but I didn’t think too much of it because I had a deadline.

Over the past few days I’ve been working with one of the other developers again on some Microformat ideas, this time implementing some of the hProduct and hListing elements into a similar page. Sudden inspiration struck me – the ‘h’ is an ASCII-safe lower-case Mu (μ) – the SI prefix for “micro”!

[1] http://microformats.org/wiki/hcard#Root_Class_Name

March 3, 2010Permalink 3 Comments

Towards an Open Rubric – Part Two

In part one, I related the shambling development project to build an online generalized rubric builder/application tool, codename:”Rubricator”, at the IST Solutions Institute at Penn State from 2007-2008. The official project met an untimely demise as a result of a college reorganization. While this certainly wasn’t the first technology project to be offed by a surprise reorg, we had a more troubling problem – we had promised the tool to a colleague to help execute her research!

Carol McQuiggan, a friend of teammate Stevie Rocco is a member of Penn State’s instructional design community. Carol had provided the first rubric we marked up and used for early testing and development – a self-assessment rubric to help faculty members measure their own preparedness for online teaching. We had signed Carol on as the first pilot user of the rubric system, and she been accepted to the upcoming Sloan-C International Conference on Online Learning to present on her research.

Stevie had since moved on to a new position with Penn State Online, and I was in charge of building the new Extreme Events Lab at Penn State. Stevie and I resolved not to hang Carol out to dry. Through some long evenings, work sessions at the local Panera and the assistance of the local Adobe Flex Study Group, we managed to finish a limited version of the rubric tool. This version was enough for Carol to complete her research and presentation. Stevie and I were also able to parlay our experiences into a presentation at OpenEd 2009.

Stevie was also able to find a permanent home for the rubric tool as the Faculty Self-Assessment: Preparing for Online Teaching with Penn State Online.

In our rush to finish the “rubricator”, we unfortunately had to compromise on our initial design in a few severe ways. We were still no closer to an open model for rubrics, one independent of the application that displays them. In fact, we were left even without a clear path to release what we created as open source – it remains property of Penn State due to institutional intellectual property policies. Perhaps someone still at PSU will take up the charge.

Next: Part Three – Liberating the Rubric

March 2, 2010Permalink Leave a comment

Towards an Open Rubric – Part One

Though it seems like just a short time, almost three years ago my old workgroup at Penn State set out to do something crazy: help our faculty deal with an overnight tripling of class sizes in our college.

The College of Information Sciences and Technology had been created by University President Graham Spanier in 1999 under a protectionist model: class sizes were capped and admission to the major was restricted in order to try to create something different: a program built from the ground up around Problem Based Learning. At the same time, the administration recognized that the college couldn’t be self-sufficient with these restrictions, and provided the startup funding necessary to allow it to prosper.

When this additional funding came to an end, the college administration discovered a sobering fact: class sizes would have to nearly triple for the college to become self-sufficient. The artificial environment under which the college had prospered was coming to an end.

At the time of this inflection point, I was the Senior Technologist of the now-defunct IST Solutions Institute. SI was the education R&D arm of the college: an eLearning and technology “Skunk Works” comprised of Instructional and Multimedia Designers and Software Developers. A few months earlier, Stevie Rocco, one of our Instructional Designers and my partner in crime at SI, had come across an interesting project: a JavaScript-based rubric tool for evaluating student course work [I'm trying to find a reference to this project - BP]. There were a number of technical limitations of this prototype, but the idea was sound: have the rubric be the UI metaphor with which faculty could interact with a system that facilitated higher-quality, higher-speed grading by the faculty member by simultaneously:

  1. handling the accounting operations behind grading and giving feedback
  2. fostering the sharing of grading standards across a diverse faculty

We set about to design develop a rubric-centric application, one that would complement Penn State’s ANGEL LMS and SI’s existing Edison Services suite of eLearning tools.

In my mind, an absolute imperative behind developing such an application would be the separation of the definition of rubric documents (or data objects) from the application code of such a system. Many of the existing rubric tools (including that first JavaScript implementation) had no clear separation of data from behavior; at best, this makes them inseparable from their single, embedded rubric. In any case, the result is effectively a closed systems with little hope of sharing data with open systems in the education enterprise.

Still other rubric-based systems decomposed a rubric into multiple Relational Database tables, shattering the coherence of the rubric as a first-class part of the system. One can hardly fault such projects: this was the prime application design pattern of Web 1.0 and even Web 2.0 applications then coming into common use.

As we developed our prototype rubric tool (which we jokingly called “The Rubricator”), I made sure the design was built around a rubric as a document, at the time marked up in XML, that could be separated from the application, shared, remixed, etc. The UI was built in Adobe Flex with a server layer in ColdFusion, two technologies the SI gang was already very familiar with from previous projects. “The Rubricator” would load the rubric document payloads at runtime, ensuring a strong separation from logic and data representation.

The whole process of design at SI was one we took very seriously. To date, this project was the best example of team collaboration and iterative design and development I have experienced in my professional career. After two iterations of prototyping and design meetings, we now had a clear design and application flow:

Rubricator Application States

After the ensuing six months of back-burner and after-hours hacking, we approached the end of our third iteration and a magical “1.0″ release. Then the unthinkable happens: SI was dissolved and the team was scattered across other units in the college. While that was disappointing to all of us personally and professionally, we were leaving a big stakeholder in a really awkward position.

Next: Part Two – Finishing what we started

February 23, 2010Permalink 2 Comments

Speaking tonight on the Semantic Web

The Semantic Web has been a strong interest of mine over the last two years. When I came across RDF and OWL through a research project at IST back in 2008, a Web Standard no less, I’d somehow been completely oblivious to its existence.

If you’ve never heard of the Semantic Web, here’s a quick intro video. I’ll wait here.

Everybody back? Okay! The concepts behind OWL seemed to solve a few thorny design issues I’d come across in a decade of building relational databases-backed Web 1.0 apps, and do so in a really elegant way. Working with OWL fuses aspects of relational database modeling, information architecture, and object oriented design into a new set of technologies and techniques.

As I started talking to members of the developer community at Penn State about the Semantic Web, I got a lot of blank stares and misunderstandings (“Isn’t that just XML?”). And yet, every graduate student in IST was exposed to ontologies and semantic modelling as a routine part of the curriculum. The research community had been working with ontologies for years. Clearly there was a large academic-practitioner gap here to be bridged.

So as I’ve done many times in the past with a new technology or concept, I started talking about the Semantic Web at user group meetings and conferences, and looking for ways to apply these technologies in low-risk venues.

Tonight is the latest in this series of speaking engagements, and possibly the most challenging thus far. I’ll be presenting my talk “An Argument For Semantics” at the Portland Java User Group. I’ve been really impressed by the quality of home grown presenters at PJUG since I started attending. My talk will be very different – less code, more conceptual – than usual PJUG speakers, but I’m hoping the technical experience in the room can generate a good discussion on how and when it makes sense to employ Semantic Web technologies in real world applications.

February 16, 2010Permalink Leave a comment

Awakenings

It’s been almost a year since I posted anything here… things have been crazy.

By far the biggest change has been my move to Portland, Oregon this past summer! After almost twenty years in State College, Pennsylvania (home of Penn State University), my wife and I decided to try something new, and relocated to the West Coast.

Portland is a great city – for you East Coasters, it ranks between Atlanta and Milwaukee in size – with a thriving food scene (including amazing food carts), great public transit, and an active tech and entrepreneurial sector.

Since relocating, I’ve launched back into consulting, presented at a couple of conferences, dusted off some old skills, and learned a few new ones.

So what got me back here, talking about things? Kevin O’Shea, a colleague in the Ed Tech world, threw down the gauntlet, challenging others to post one blog post per week. I share his feelings towards blogging, and have a much easier time sharing ideas on Twitter.Several of my colleagues took up the challenge, and I decided to throw in my lot.

I’ll be representing #teamicing.

Update: There is now a dynamic scoreboard for the participants in #nerdthunderdome.

February 9, 2010Permalink Leave a comment

A Cloak of Accessibility

If you regularly run your browser with JavaScript support disabled like I do, you’ll occasionally run into a Web site that completely fails to operate, especially among so-called Web 2.0 sites.

I don’t know if you’ve ever noticed, but Twitter.com is not the most accessible site on the Web. I find that somewhat odd, given the relative simplicity of the user interface. This has improved a bit in the 18 months or so that I’ve been using the service, but I wouldn’t say it’s perfect yet. At least the site functionality gracefully degrades when you don’t have JavaScript.

Enter Dennis Embree. Seeing a need, or at least an opportunity, he created a more accessible Web-based Twitter interface: AccessibleTwitter.com

The site contains a short list of some of the things the developers fixed:

  • All links are keyboard accessible.
  • Simple, consistent layout and navigation.
  • Works with or without JavaScript.
  • Large default text size and high color contrast.
  • Looks great in high or low resolution.
  • Forms are marked up for optimal accessibility.
  • Code is semantic, light, and adheres to best practices in Web Standards.

I wonder if there is a niche here for accessibility-aware Web developers: find Web 2.0 sites that brush off demands for accessibility affordances and wrap them in a “cloak of accessibility” spun from their own APIs.

I think this is a really interesting idea. I wonder what other sites could benefit from such a technique?

February 16, 2009Permalink Leave a comment

IT Leaders can learn a lot from McDonald’s

While I’m sure a few IT professionals wound up working in Food Service after the dotcom bubble burst, that is not really what this post will be about. Instead, I want to share a perspective on job rotation and how it makes better leaders, and how the IT world could take a lesson from the Golden Arches.

One of the hallmarks of the McDonald’s training and staff development program is job rotation. Basically, one cannot manage a store until they know how to do all of the jobs at the facility. In discussing this with a colleague, I’ve learned that the Marine Corps does something very similar in developing command personnel.

I think this job rotation method of staff development does three very powerful things:

  1. Cross training of employees. Team members learn what everyone else does. This can be difficult with knowledge workers, who rely so heavily on conceptual skills, but some experience is invaluable in knowing what goes on in a role. This enables others to pitch in during times of stress or decreased capacity.
  2. Organizational perspective. If you don’t know what part of your organization does, you don’t know a) how they can help you succeed, or b) what you can do to help them succeed for the betterment the organization.
  3. Developing talent for succession planning. It takes a special kind of person to do each of the main IT roles: user support, system administration, and development. People usually enjoy one of these roles, but rarely all of them, depending on their personality tendencies and other internal factors.

    Most often, the entry level position in an IT organization is that of customer support or helpdesk. These positions tend of have really high turnover, as new people come in and get chewed up by the constantly-ringing phone or endless stream of support tickets. (you’re probably saying to yourself: “tell us how you really feel!”). By doing job rotation within an IT organization, you give people a break from the front lines, and can see if their talents or temperment is better suited for another part of the organization.

Finding what excites you is the difference between job satisfaction and misery, but that’s really another post in itself.

August 1, 2008Permalink 2 Comments

Flex Builder Redux: How does this MXML tag work again?

FlexBuilderPackages

I posted last year about how to get help on an MXML tag in Flex Builder, but I have another tip that I’ve been using quite a lot lately.

The source to the Flex framework is actually included with the Flex SDK built into Flex Builder. If you want to view the actual source code to an MXML tag (like RemoteObject) or even an ActionScript class or method, you can hold down Command (on the Mac) or Control (Windows) and hover over the name of the object in Source view. The class should be underlined, and is now a link to the source code of that class.

But it doesn’t stop with the Flex framework: this even works with your own classes. Why is this important? If you have your project source files structured into nice named packages (like com.mycompany.myproject.*), you can get some pretty deep folder structures (see screen shot at right). Eclipse will generally collapse these folders for you if you’re using the Java developer tools, but no such luck with Flex Builder.

By using the Command/Control-Click trick, you can pop anywhere within your source code base fairly quickly. This is really handy when you’re chasing down a bug.

July 18, 2008Permalink 1 Comment