What is the right curriculum to achieve the envisioned outcomes for software engineers? I propose that such a curriculum has four interwoven disciplinary threads with the desired professional skills and mindset integrated into their courses. The four threads are:
- Computers as Formal Systems: Programming languages are unlike natural languages in that their statements mean exactly one thing. Any piece of code is a definite specification of operations or “instructions” that the “processing units” of a computer will perform. Instructions are simple arithmetical operations and movements of stored data, but they can be built up into extremely powerful tools. This thread starts with treating a computer like a ‘big calculator’ to crunch numbers to understand the behavior of physical systems in “Modeling and Simulation”, develops with the systematic construction of software, and reaches its completion with the theoretical foundation of what computers can do in “Foundations of Computer Science”.
- Modeling and Simulation, Software Design, Discrete Math, Data Structures and Algorithms, Computer Architecture, Software Systems, Databases, Foundations of Computer Science.
- Computers for Mathematical Analysis: Engineers work with data, and data from the real world is noisy! Processing large volumes of data requires computers. Engineers need to learn how to use computers to collect data, manipulate it, draw inferences from it, and present it to people in a way they can understand. This thread begins with a foundation in Probability, Statistics, and Linear Algebra, progresses through Machine Learning (automated pattern recognition) and serves as the basis for the mindset of experimental design.
- Modeling and Simulation, Linear Algebra, Probability and Statistics, Machine Learning I: Tabular, Data Visualization, Machine Learning II: Computer Vision, Computational Robotics.
- Computers in Integrated Products: We can use computers not only to do math, but also in embedded physical systems that do things in the real world. Once we physically deploy complete systems, the fun of integration challenges begins! This is a sequence of integrated hardware, electrical, and software projects that cultivates the mindset of building full products with computation at their core.
- Real World Measurements, Fundamentals of Robotics, Computational Robotics.
- Human Context of Engineering: Engineers build things for people with other engineers. How do we design the right products for our users, along with them? How do we communicate our mathematical analyses and experimental results? How do we learn from and teach others? And then how do we integrate all of our technical and interpersonal skills into human organizations that build things together? This thread has several courses explicitly within it, but permeates through the curriculum.
- User-Oriented Design, Data Visualization, Teaching and Learning, Venture Management.
While these threads are presented distinctly for clarity of communication, the knowledge and skills they impart are all tied together. This particular example of an “Open Software Engineering Curriculum” (OSEC) has eight “phases” that could roughly correspond to eight semesters, or eight increments of independent study. With eight semesters, there is plenty of room for “distribution requirements”. Each pair of phases (I and II, III and IV, etc.) could be done simultaneously to compress the sequence into two years without other courses included. Each pair contains a course with a substantial team project, highlighted in green. There are seven underlined courses that lend themselves to the creation of projects that are suitable for a “portfolio”.
As described in the “Structured Exploration” and “Mindset” chapters, this curriculum is designed to promote a proactive approach to learning, teamwork, user orientation, and long-term systems thinking. These themes are introduced early in the sequence so that they can be cultivated over time.
OSEC, as a project, is mostly a work of curation and “restyling” existing content to better promote the proposed outcomes. Almost all of the named courses correspond to well-known pedagogical modules which are listed as references. These references will be incrementally reworked and further curated. I have intentionally “tied” certain modules together in the sequence that ought to be taught within a single block. Because software engineers are primarily practitioners, learning of math is tied to application within this curriculum.
The intention of this OSEC is to present a comprehensive and explainable course sequence. Compare this to the MIT Computer Science and Engineering requirements and outcomes documents. Instead of merely listing the content, this is meant to explain how it all fits together.
Courses
- Real World Measurements: Arduino C:
- Imagine a “weather station” that monitors wind speed, rain, humidity, sunlight, etc. and is physically deployed. To put together such a weather station requires integration of microcontrollers and basic circuits, as well as simple mechanical design to enclose it and make it resistant to the elements. The physical system must be maintained through time, over months or even years, and can be progressively improved in response to problems. Once it is deployed as a system and reporting data, the data stream can be processed and uploaded to the cloud. Visualizations can be built on the data stream as a simple website. The data set presents opportunities for analysis and predictive modeling. Multiple stations can communicate as a mesh network. Starting from even a simple measurement device, there are many avenues for problem-based technical depth within software engineering across the product life cycle. The practice of physical and software maintenance within this project helps to prevent a mindset in which “everyone wants to invent the future, but no one wants to be on the future’s on-call rotation”. All of the technical features are built upon the continuous proper functioning of this device and data pipeline.
- This is the central project within this course, but there can be other kinds of sensor integration possible. Its location at the beginning of the curriculum is to introduce ideas of system integration (HW, EE, SW) and long-term maintenance. For the sake of simplicity of management and ensuring good learning for each student, this is not naturally a team project.
- Budget for Arduino, servos, sensors, lights, wires – roughly $200.
- Data can be used as the basis for future courses: Modeling and Simulation, ProbStat, Machine Learning, Data Visualization.
- Emphasized Stages: Explore, Learn, Design, Implement, Operate
- References:
- User Oriented Design
- Students can learn how to care about long-term effects and sustainability of products for the people using them simply by working with them over longer periods of time. Olin’s “Engineering for Humanity” is an introductory design course that pairs students with seniors and has them try to solve problems that they face, often centered on negotiating the physical environment. Working with seniors in this way has many advantages: physical objects are often not easy for them to use, and so there are plenty of opportunities for assisting them. Solutions can be inexpensive. Seniors are often overlooked, generally have a lot of free time, and are happy to talk to young people who want to help them, so they are an ideal user group. By extending this engagement beyond a semester-long course and doing long-term support for these projects, students can gain an appreciation for lasting impacts on users as well as technical sustainability.
- This is located at the beginning of the curriculum to plant the seed of thinking about impact on the end user. Some students enter into engineering just wanting to create something that is cool, and not on the end result, or might be hesitant to engage with people. Seniors naturally want to talk to them, so they are a great group to start with.
- Team Project, Portfolio Project
- Emphasized Stages: Explore, Conceive, Implement, Operate
- References:
- Modeling and Simulation, Probability and Statistics, Linear Algebra
- Topics: Weather Forecasting, Stocks and Flows, Simple mechanics and thermal simulation, Introduction of datasets that require probabilistic modeling, Introduction to Bayesian and Frequentist statistics, Monte Carlo Methods, Transformation of physical systems through time, Introduction of Linear Programming, Optimization Approaches.
- Emphasized Stages: Explore, Learn, Implement
- References:
- Software Design and Discrete Math
- Methodical design of software and learning the mathematical basis of software systems. Object Oriented Design, Modularity within software projects, Introducing time and space complexity analysis. Building a video game as a group to introduce collaborative SW development, simple user experience testing, Model View Control design pattern.
- Discrete Math is often mistakenly taught after the introductory software “design” course, but this is wasteful because all of its concepts are naturally included in learning the theory of software. Software projects can be chosen to illustrate different ideas within Discrete Math. Formal thinking and constructing proofs of mathematical relations introduces students to the idea of computers as mathematical symbolic manipulation machines instead of just tools. It would be wrong to start with the theory and postpone “building things with computers” until after the math.
- Team Project, Portfolio Project
- Emphasized Stages: Explore, Learn, Design, Implement
- References:
- Machine Learning I: Tabular and Data Visualization
- Analysis of datasets and “statistical learning” leading to close examination of the data and its distributions. Emphasis on communication to people in general interest technical writing alongside purpose-driven visualizations. Making a simple website for these artifacts. Understanding how pattern recognition can be automated. Can build upon the weather station data. Creating ML models of physical processes: this is an advancement over the simpler approaches introduced in Modeling and Simulation / Linear Algebra. Includes (review of) necessary Calculus concepts. “Citizen Data Science”: using data visualization and modeling to present an argument about some topic of public interest. This is an exercise in public communication through data. Accuracy of analysis and presentation is key.
- Portfolio Project
- Emphasized Stages: Explore, Learn, Conceive, Design, Implement
- References:
- Data Structures and Algorithms
- Formal analysis of computational processes.
- Emphasized Stages: Learn, Design, Implement
- References:
- The Algorithm Design Manual, Steven Skiena
- MIT Intro to Algorithms
- MIT Design and Analysis of Algorithms
- Fundamentals of Robotics
- Building integrated mechanical, electrical, and software systems in a team. Characterization of motors. Build a simple robot that moves in the world in response to sensor input. After this course, students are well-posed to mentor a high school robotics team.
- Team project, Portfolio project
- Emphasized Stages: Explore, Learn, Design, Implement, Operate
- References:
- Teaching and Learning
- Starting in phase V, transition from foundational learning to specialized learning. Engagement with high school students or earlier learners of this curriculum in a teaching or mentoring capacity. Mentoring is a core engineering skill for the sake of organizational sustainability and learning how to communicate to more junior people is a completely different mindset from communicating to professors who know more about the subject. After the “Citizen Data Science” from “Data Visualization”, communication deepens by teaching others technical subjects.
- Emphasized Skills: Communication, Mentoring, Reflection on Process of Learning
- References:
- “How Learning Works” (Susan A. Ambrose et al.)
- Computer Architecture
- Working up from logic gates and arithmetic logic units to a complete simple computer in simulation. Instruction sets and Assembly language.
- Emphasized Stages: Learn, Design, Implement
- References:
- Machine Learning II: Computer Vision
- Classical computer vision techniques, Convolutional Neural Networks, Transformers. Data augmentation. Object Detection, Segmentation. Animal identification in the wild, which can be integrated into the “weather station”, then relate presence of animals to environmental conditions.
- Portfolio Project
- Emphasized Stages: Explore, Learn, Design, Implement, Operate
- References:
- Software Systems & Databases
- Introduction to: Operating Systems, Web Servers, Networks & Distributed Systems, Database Management, System Performance Analysis. Emphasis on detailed design reviews of peer’s artifacts.
- Emphasized Stages: Explore, Learn, Design, Implement, Operate
- References
- Venture Management
- How do we integrate all of our technical and interpersonal skills into human organizations that build things together?
- As of 2023/09/21: Open question on whether this should attempt a practical component of operating a business. I am more skeptical of this because it is difficult to make actual business operations self-contained within the scope of a course and still be a meaningful management experience. Current plan is that this would primarily include the curation of case studies and readings on management with exercises in opportunity assessment via interviewing hypothetical users and creating a business plan.
- References:
- How do we integrate all of our technical and interpersonal skills into human organizations that build things together?
- Computational Robotics
- An integrated robotic system navigates in its environment to accomplish tasks based on image input. SLAM. Computer vision in the wild.
- Team Portfolio, Portfolio Project
- Emphasized Stages: Explore, Learn, Conceive, Design, Implement, Operate
- References:
- Foundations of Computer Science
- Theory of Automata, Turing Machines, Computability, Functional Programming. Standard approach would be to focus solely on the proofs. Intention in this course is to actually implement ‘automata’ in OCaml.
- Emphasized Stages: Learn, Design, Implement
- References:
Mike's Engineering Blog 