Overview of the Accounting for Flatiron School's Software Engineering Curriculum
At the beginning of this document, I proposed that an accounting lets curriculum managers organize their teams, express logical dependence of learning goals and operate more effectively. I’ll give a brief taste of how AirTable helps us do exactly this at Flatiron Schol.
Map Products to Learning Goals
Airtable’s UI features a “stacking” user interface. Thus you can navigate from Learning Goals to the Product (a collection of two intermediate macro objects, Lessons and “Bricks”) and vice versa. Here we are going from macro-level to the micro:
Demonstration of tunneling through an AirTable-stored accounting macro-to-atomic
Here we see a Brick, “Recognizing and Processing Nested Data Structures to Insight” that is one of several comprising the Product “Prework.” If we hit space and tunnel into the Brick, AirTable overlays another modal-like “card” and we see all the data about this record but also see that it’s associated to multiple Lessons. Two of these are about “Nested Arrays.”
We’ll “step into” the record about the “Nested Arrays Iteration Lab.” Again the “curvy white line” suggests what we’ve “tunneled” into.
You can see how the records are “stacking” on top of each other. AirTable UI feels like you’re “tunneling” across this vast directed graph. In this view, we can see the Learning Goals of this particular lab. As a coach or instructor, we could answer “What’s the point of this.” quite easily. We can see this lab has 3 core Learning Goals.
We can even step into a given Learning Goal and find out interesting meta-data about it. Where it fits in Bloom’s taxonomy or some other psychometric meta-datum.
Map Learning Goals to Products
While we can drill from macro to atomic Learning Goal, we can also
reverse. Where does a given Learning Goal fit within the whole of the
curriculum? This is a good question for admissions staff or for teachers in the
advanced modules who are surprised that maybe a Learning Goal isn’t as
well-mastered as they might expect. Let’s consider where students might learn
the CTRL-C or SIGINT signal.
Demonstration of tunneling through an AirTable-stored accounting atomic-to-macro
We can step into its detail view:
From the detail view, we can find out which Brick it’s part of (again, note the “stacking” of the records in the UI).
Within the Brick we can see other Learning Goals to which CTRL-C is a
sibling:
And we can even find out which Product the Brick fits into, in this case, “Prework:”
Astonishingly, we can keep track of whether this Learning Goal is assessed as part of a quiz:
Build Review Flows
I don’t want to expose any of my fellow contributors, but it should be apparent that with such richness we can keep track of who “wrote” and who “reviewed” a piece. We can link to the content’s versional control repository as well.
If you use an LMS for distribution, AirTable’s API could be tied such that when you publish a new version of a product, a “hook” of code fires to pull the latest instance of all the constituent lessons and paste them into the LMS' API.
Also notable, despite not having used it, notifications can be automated in AirTable using Zapier.
Build Custom Reviews for Key Stakeholders
At the beginning of our research, we made some commentary about needing to be able to show our data in a “less technical” or more summary view. AirTable has a technology known as “Blocks” which are add-ons that re-display or augment your “base.” I used one of these to generate summary views that we can place with our Admissions staff. Here’s a sample:
Conclusion
As you can see, we have a navigable, shareable, rich accounting of the material in our software engineering curriculum. We didn’t exactly know what the right thing to do was at every step and we even had to do a few re-workings, but overall our accounting is a key component in running our team. Some of the better ideas will be presented in the next document on AirTable Best Practices.
Next: AirTable Best Practices