hazybluedot

Early on in my teaching position, before I was directly involved with the maintenance of the LMS, I found myself reworking the content in course that I suspect had become a catch-all for any computer-related skills someone thought first-year engineering students aught to have. There were effectively no course objectives. The official catalog listed something, of course, but I doubt anyone had paid much attention to them in years.

As a new faculty member in a unit that used its own LMS, this was the first time I was making significant content changes, both in content and structure.  The content-management side of our LMS was, and still is lacking, especially for widespread edits across multiple learning topics and moving topics around.  I was looking for a better authoring environment that could publish pages along side existing administrative pages.  I was also looking for some kind of structure to attache the reworked content to. 

I discovered the Morea framework through a CS education listserv that I had forgot I was on. It offered both a way of thinking about curricular content as well as a static-site publishing system built around jekyll. While I appreciated the static-site approach, it did not mesh well out-of-the-box with our existing system and workflow, the way of thinking and structuring content was something I wanted to work with in our own system.

Modules Outcomes Reading Experience Assessment

Morea structures instruction around modules, suggested to be more-or-less self-contained and spanning 1-2 weeks.  Each module has associated outcomes, reading (passive learning material), experiences (active learning material), and assessments. Each type of material is labeled as such and thus a morea course "makes the pedagogy visible" both to learners as well as instructors. This provides a helpful metric for assessing the balance of a curricular unit. i.e. we would want to make sure there is sufficient active content interspersed in any passive content, and we would hope both content and assessments were aligned with published outcomes.

Without using the technical framework, I didn't have the generated summary views to get a sense of how the active and passive content mingled, or the generated tag pages that e.g. would list all content for a particular learning output, but it was still a useful way to think about structuring material.  It is an idea I would like to integrate into our current LMS. I envision having some sort of soft validation/engagement metric that would notify instructors when certain modules might be week in active content, or when published assessments didn't line of with associated outcomes.  The idea of making the fundamental unit of instruction the module also has promise, but we would still need to specify an ordering of modules since much of our current content builds upon earlier content. 

I am not sure to what extent I will have the opportunity to go down this path. As I mentioned in an earlier post, there's a possibility we move away from the content-management side of our current LMS and my work is focused just on the assessment system.  If we do move to the university supported LMS we could certainly still follow the Morea principles, but any kind of automated curricular validation feedback would likely not be feasible.

via Wikmedia Commons

I am typing this on a shiny new laptop, which would probably not be terribly noteworthy except that, strictly speaking I didn't really need a new laptop.  I wanted one, for some fuzzy, hard to pinpoint reason, but the desire for something new but unnecessary, and actually following through with buying it, seems to conflict with my anti-consumerism values. The perfect internal conflict to reflect upon.

The theme that I keep coming back to when trying to unpack the desire for this new tool is identity. For the work I do, both professional and personal, a computer is a critical tool.  My relationships with computers goes back to early childhood when I first became aware and interested in the variety of tools they could become playing on an old Apple IIe and a little program, or set of programs my dad had wrote for me stored on a single 5.25" floppy disk. In all it's green monochrome CRT glory, I was captivated by a demonstration of various sorting algorithms and a rendition of "twinkle twinkle little star" playing over the 8bit speaker.  I seem to remember there also being something that was more like a game, but oddly it's the sorting algorithms and twinkle twinkle that have stuck in my mind.  Now that I'm thinking about it, I'm not really sure what the replay value was, but I definitely fired up that floppy many times.

I first started dabbling in programming on... I want to say a Zenith, but none of the pictures I am finding look like the one I remember, so I may be remembering wrong.  What I do remember, is that this particular model had no included persistent storage and so any program I wrote vanished from the universe when the computer was switched off.  I was oddly intrigued by writting menu-driven conversational agents. Basically extremely rudimentary chatbots consisting of layers of if/then/elses, fixed topic menus, and gotos.  

The computer at home was replaced periodically, always a generation or so behind the state-of-the-art that my data would buy when the university auctioned off old equipment.  When color -- first 4, then an eye dazzling 256 color monitors and the Intel 386 entered the mainstream I got my first does of them at a friend's along with the generation of video games the technology ushered in.

When we first got a dial-up internet connection to the university's network over a 2400 baud modem it opened up a whole new dimension.  Access to online communities and information that before had been out of reach. This was before the world-wide-web, mind you, or at least before WWW capable internet connections, basically a direct connection to the university's gopher server and menu-driven access to resources and bulletin boards.

My first view of a WWW page was at my dad's office, using the Mosaic browser to view pictures of the red planet sent back by the Mars Pathfinder.  Something about the promise of the WWW and carving out a spot on the public web stuck with me and I started getting into web development.  As a form of expression and creativity, there was something about the multimedia capabilities, and relative ease of publishing that appealed to me. I don't ever recalling having something in particular I wanted to say, it was more the idea that I could say something, if I wanted to.  It was truly a case of the medium is  the message, for me.

There was even a stint in the late 90s when a high school friend and I started a webdesign business.  We had exactly 2 clients -- both personal/family connections because who else would pay money to kids in high school to design a website -- for which we essentially wrote a CMS in perl.

Fast forward a good chunk of time to a few years into grad school when I began teaching an Introduction to Unix course.  I had been a casual user of the Linux operating system off and on for a while, and a more consistent user when I began grad school.  None of that really gave me the qualifications to teach a course, but it was one of those low-priority "just follow the provided material, you'll be fine" situations.  Of course, I'm never one to "just follow the provided material" and I began learning more about this history of Unix and notable figures like Dennis Ritchie, Ken Thompson, and Richard Stallman. I came across (or maybe it had been referenced in the "provided materials" The Art of Unix Programming, by Eric Raymond and began assigning chapters for the course I was teaching.  It was this piece that really got me thinking about programming and web authorship as an art and thinking about the philosophy of software design.  I was drawn in to the connections between the evolution of software patterns and how they were influenced by the cultural history of commercial and open source computing. Code and more, specifically software architectures, was more than just an abstract sequence of instructions, it was a declaration of group identity, and cultural currency connecting the software and author to a larger community.  

Where am I going with this? That's a good question. As with many of my ramblings, I have somewhat spiraled away from what I had originally had in mind.  The Unix course stands out as a pivotal moment in my life, as the moment I first began to view teaching as a viable profession, and also the start of my passion for the socio-historical-cultural underpinnings of technology and how it influences what we do, how we think, and how we interact with one another. Tools are an extension of ourselves, and thus an extension of our identities. It was probably around this time that I bought my first System76 laptop. It was, and still is, one of the few companies that sell laptops with Linux pre-installed and a supporter of the open source community. Some years later, in 2017 I had high hopes when buying a laptop from Purism, a company built around a more dogmatic connection to open source and computing freedom. Sadly, I was underwhelmed by several aspects of this “pure” manifestation of the computing ideal: the build quality being the main one. Granted, I think they were only on their “version 2” of the hardware at the time, but I realized that ideological purity did not outweigh a relatively smooth user experience for me. There were issues with the purism locking up randomly to a point that I didn’t trust it enough to use for my PhD defense, instead going back to the old System76 which had to be plugged in as its battery no longer held a charge, but none the less was the more reliable option.

Both of these laptops were more or less retired once I started working and had a work-provided laptop. That, and the pandemic contributed to a workflow that didn’t really require mobile computing outside of work. My tendency to be a homebody contributed to mostly staying in and making use of a desktop gaming machine (that purchase is another story…) even after pandemic related restrictions were lifted. Lately, however, I have been more proactive about getting out of the house on the weekends. I have been living downtown for years but for a long time didn’t feel like I was really taking advantage of the convenience of various coffee shops and other locals that can serve as public spaces to engage in creative endeavors. Last weekend, I dusted of the old purism laptop and visited a few of my favorite places. I got a little hobby/LMS work done, wrote a blog post, did a little online and offline reading. It got the job done but… it just didn’t feel as good as it could have. For one thing, the 13” screen is on the small side to do web development work (I tend to split the screen code on one side, site preview on the other), not to mention the persistent display artifacts that have been plaguing it since nearly the beginning. That and it just felt rickety. It make creaking protests every time I opened and closed the lid. I just wanted something new.

I think the purchase was symbolic in a way too, marking a new beginning. It felt similar to when I bought a new commuter bike and retired the Schwinn I had originally purchased to get to my first job as a lifeguard the summer after high school. For my first “real” job after graduation it felt fitting to have a new mode of transportation to get there (which of course is now just relegated to trips to the food coop since I moved closer and a walking commute is convenient). It was a fresh beginning, a time to reinvent myself and get connected with my local community.

So did I need a new laptop? No. Have I necessarily justified the purchase with this story? Probably not. But System76 will recycle my old laptops, so I feel slightly better about it than if they were headed toward a landfill. Plus, one of the employees at System76 was a student in my Intro to Unix class way back when, so I think that makes it mostly ok to be a bit wasteful and buy a new thing.

I have recently reevaluated my goals related to the LMS.  The start of the semester was a stressful time and I realized I was trying to accomplish too much, too fast, in a high-stakes environment.

 A Little Background

The system I inherited dates back over 15 years.  It is written in php, and php has evolved a lot over the time the system has been in use.  The legay code uses no OOP, and no organizational framework, most of the work is done by several very large (1000s of lines) include files containing many, many functions, most without any kind of documentation.  Functions such as user authentication, page authorization, view logging, and page rendering are all done more-or-less inline via an included header file.  Globals are used extensively to provide services such as database connections and the current user to variouse functions.  Most -- but not all -- content files are flat php files in the webserver's public path. There are several discrete, semi-integrated subsystems that proide the current set of functionality:

• A low level filesystem browse/edit system to author certain pages as raw HTML or markdown
• A frame-based editing environment to author "learning pages" that make up the most of our content. Editing itself is still raw HTML and markdown with bunch of php functions for content that interacts with the data store, such as embedded assignments.
• A quiz system that has it's own, separate raw authoring and rendering environment.  Embedding quizzes on learning pages is done through iframes. The quiz system can only handle numeric, multiple choice, and MATLAB code responses, hense the need for
• A file upload system with a tightly coupled rubric authoring/grading system and
• A survey form system for authoring, rendering and viewing results of form-based input
• A PDF annotator and grading interface primarily used to grade scanned exams.

The quiz, file upload, and survey systems all use their own slightly different method for specifying due dates.  Most non-content authoring editing is done through direct database table edits via a very light-weight wrapper around table based CRUD operations.

The system is used to run separate class sites for each of our classes. As an added complication, many of the class sites use several local PHP files for certain features, such as certain student submitted forms and other pages making their own local database connections and queries.

First Attempts

My original goal was to replace the massive included header file and jumble of associated logic with a standard router-middleware-emitter pattern using the the Slim microframework. In theory this would move things like establishing database connections, user authentication, session managment, page view logging, etc. to more recognizable services and middleware, decoupling the page loading and rendering making it easier to provide a consistent API to all pages.  By pushing in this direction, I figured I would learn the different parts of the legacy codebase to gain a better understanding of how the pieces fit together, while defining more clear boundaries between them. The problem was that the existing codebase was in such a tangled form that trying to separate even a sliver out required multiple changes across multiple files and even then things seemignly unrelated would break. I had been reading some development blogs about refactoring legacy code bases and even their "you might have a code base that looks like this..." example of poorly organized structure still had more of a structure than what I was dealing with.

Over the summer, I spent a lot of time building up a middleware pipeline that would hopefully load and emitt legacy page content. I wanted the pipeline established so that any new features and functionaly could be written in a clean, organized fashion from the start. Ultimately though, there were too many edge cases to deal with trying to take content pages that had been written as stand-along PHP applications handling them with a consistent pipeline. I made enough progress to gain optimisim but as the summer came to an end it became clear that this was not something that would be ready for the Fall semester.  The last week before classes started, continuing into the first week, I shifted gears to just trying to integrate a somewhat parallel middleware structure for new features into the legacy code base so that I at least had one git repository to work with.  This eventually did come together, with the old legacy pages still being handled with the legacy code with new pages being handled by the new code, but not without some breakage due to missing or moved include files that I hadn't know about until various pages and subpages were accessed by colleagues trying to get class pages setup.  This is what lead to the stress, doign last-minute fixes to now-live code when frustrated colleagues would bring a broken page to my attention. I worried that all the time and effort I had put into the codebase over the summer was esentially out the window with not much to show for it and that all my colleagues saw were broken features that had been working before.  

Attainable Goals

On top of the general stress that came from feeling like I was failing the people that depended on me, the frustration also had the effect of taking something that I had enjoyed, the tinkering with and implementing data pipelines and modeling data transformations, and coupled that with negative emotions.  It started to feel not only like a job, but a job I hadn't really signed up for (because I hadn't) and was not fining at all fun. This as troublesome because since I've remembered I had always had an intrinsic interest with web development and data processing. It had been a passion that was now being choked to submission by external demands. It was keeping me up at night and I only was getting a few hours of sleep each night the first week of classes.  When the major broken pieces were finally functional again and I had a moment to breath I realized my approach had to change.  I realized a system-wide overhaul was never an atainable goal for a one person team over the course of a summer.  Instead, though it hurt my head to read through and patch up the tangled mass of spagetti code instead of re-write it, that was the more reasonable approach to maintaining the existing system while narrowing my focus for the new pipeline to specific features that would get rewritten piece by piece. This would allow me to have fun with the development again working on upcoming features that did not have any particular timeline for going live, while performing minor maintenance to the existing code base.

So that's where I'm at now.  As a unit we are set to have a discussion soon about the future of our LMS and whether it makese sense to move our course content over to Canvas, the University's choice of LMS.  Even if we do that, we know that the assessment system is one thing that we depend on, so I am looking into extracting it out as a LTI 1.3 tool that can be integrated into cavas.  This gives me a focused project to work on, that still has all the pieces of the full web application: a content managment system, data management, user submission handling, etc. but with more well defined boundaries.  I have been sleeping much better since this shift in expectations.

The past few years I have been getting more involved with a web development project at work. I find it interesting to note that ever since the advent of the world wide web I have been dabbling in web development, at some points in time more "officially" than others.  Lately it has become an official component of my work as the person who had built and maintained a custom learning management system (LMS) at work retired and I have taken over the responsibility of maintaining and updating the system.  I've had a lot of thoughts about this, and decided it could be therapeutic to write them here.  Maybe others will find them useful, or triggering, depending, or find them helpful like I have found many the web development blog myself.

Philosophically and ethically, I am a firm believer that educators should have complete control over the technology they use in the classroom.  What this looks like may vary of course, and this doesn't mean that all educators must be software developers, but it frustrates me when we make decisions that affect students not because they are the best we can offer the students, but because they are the best we can offer within the limitations of the commercial software we have come to depend on.  Suffice it to say, when I was interviewing for teaching positions, the fact that the unit I am not part of supported a home-grown LMS piqued my interest and was definitely a perk for me.

I’m not quite sure if there will be a super organized structure to these posts, but my plan is to reflect chronologically as a new faculty member coming in as a user of the system, working with it to develop content for a class, the challenges I ran into and some of the attempts I made to develop additional functionality on top of the system without being able to modify the system itself, to attempts at developing parallel systems that could work in tandem, and finally to my current attempts at wrestling with a legacy code base and figuring out how best to bring the system up-to-date while developing new features and improvements with the realization that I can’t overall/replace all ~200k lines of existing code in one Summer, and yet I don’t want the updates I’m working on to be constrained by the structure of the original system.  These posts will likely contain both technical and pedagogical content as well as reflective rambling/rants at times.  I hope that they bring some organization to my own thoughts, and if they help others in some way too that is a bonus.

#webdevelopment #lms #highered