the next standard in open computing education will be built around javascript. it may not be the ideal beginner language, but a broader look at the requirements for such an open course will show that not only is javascript the only real option, but that it is actually a very good one. With some effort and imagination JS's extreme flexibility, accessible developer tools & integrated ui functionality (DOM) can be put to use making JS an outstanding choice for an entry level course in computational literacy.
What exactly is computational/digital literacy? It's difficult to satisfactorily define, but not for lack of trying (1, 2, 3, 4). What's easier to demonstrate is the type of project that could be expected at the end of such a course:
Without being beyond the reach of a first-year student, this project demonstrates basic mastery of:
- a programming language, testing & documentation, structured development, abstraction, embedding problems for applied computing, recursion, basic data modeling , applications as core data with user interactions, open source software , professional development tools, user interaction & experience
For an idea of how to implement this course, check out the slideshow in this repo.
To be successful, a fully open course in computational literacy should have embedded into it's very essence ...
The next generation of programmers should grow up understanding that while programming is hard it can be understood at face value, and they can understand it.
Prof. dr. Edsger W. Dijkstra says that the only true way to teach computer science is by writing proofs by hand, on paper, approaching cs first as a purely mathematical skill. Only then, he claims, can students truly understand the "radical novelty" of computation. He's onto something, analogies or high-level understanding are appealing and momentarily rewarding but not ideal for true long-term success.
The programming equivalent of dikjstra's method for teaching cs is to have the notional machine be the first learning objective, emphasizing the structure of programming languages & scripts over the role they play or what ends they achieve. This can be done by creating exercises whose primary learning objective is the functioning of the language, later using this as a foundation for exploring computational thinking, algorithms, CS, etc.
To keep things intellectually honest these exercises should include "meaningless" snippets of code with no attempt to connect them to anything outside of their own execution. Taking this notion one step further leads to the idea that not only should the focus of the exercise be simply how the code is executed, but that the 'learning environment' should simply be the runtime environment, and any feedback to students comes directly from the machine, gathered by the machine throughout it's own execution with no intermediary software or interfaces. If successful, such an approach would play the double role of teaching students a practical notional machine and equipping them with the skills necessary to embed such feedback and monitoring into any code they encounter.
The interpreter as learning objective & learning environment
- Explicitly teach a notional machine
- Execution environment is learning environment
- Fully embedded learning resource
The resources students use to learn should themselves be realistically open-source for students, embedding digital agency into the core of their learning experience.
student-accessible open education
- simply-hosted learning materials
- be composed of tools for fully open education
- accessibly open-source learning resources
Students, teachers, communities and families should feel that their education is theirs. That it covers what is needed for them to thrive in their own context, and is delivered in a mode that complements their lives. For this to be possible, educators should be able to adapt this course to fit their needs with no more technical knowledge than is necessary to teach the course.
readily adapted
- modular and easily adjusted course syllabi
- zero-dependancy, non-prescriptive open learning environments
- highly granular repository-based content
the course should build a wholistic understanding of the creative & controlling role programming plays at the center of a digital society.
coding is not about code
- encourage creative and extra-curricular programming
- if hemingway
- JS has html, css & the internet
- explicitly teach an integrative computational literacy
- emphasize applied computing
- understand development as a structured creative process
students completing an introductory course in computational literacy should be better prepared to take the next step in their education, should that be deeper into programming or not.
preparatory
- introduce core theoretical concepts with applied exercises
- deep understanding of language & program design
- exposure to structured solution design
- focus on core computing skills over any tooling or frameworks
- emphasis on the applied, contextual & human nature of software
Janke Learning