What’s the deal with CMSC 141 / CMSC 142?
Table of contents
Overview
CMSC 141 and CMSC 142 are part of new introductory course sequence for computer science, collectively called Program with Purpose (PWP). This sequence is being offered as an alternative track into the field of computer science that is offered alongside our existing intro track: CMSC 131 and CMSC 132, Object-Oriented Programming (OOP).
The idea is that CMSC 141 and 142 will fulfill all of the same degree requirements as CMSC 131 and 132 and provide an equivalent level of preparation for students to take upper-level CS courses. The PWP courses have a different design rationale and approach than OOP, which we motivate and explain below.
Data-Centric and Purposeful
PWP is a complete redesign of the Computer Science introductory course sequence to take a data-centric and experiential approach to computing in the first year. The redesign focuses on developing critical thinking and problem solving skills, applied to a broad range of data sets that connect students to a range of human interests and weaves together several goals:
- Provide students a compelling, socially-minded introduction to the field of computing.
The PWP approach takes data-centricity as its primary approach to introductory computing. This means that the course is oriented around using computation to answer questions of data sets that cover a broad span of human interests. Doing so gives students an authentic experience of what modern computer science is: a field that engages with humans and the world.
To read more about the data-centric design philosophy, see S. Krishnamurthi and K. Fisler: Data-Centricity: A Challenge and Opportunity for Computing Education, Com-munications of the ACM, Vol. 63 No. 8 (2020).
- Develop students’ computational skills for understanding and improving the world around them.
PWP emphasizes a systematic problem solving skills that provide students with concrete steps to go from a blank page to a well-formulated and validated solution to problems.
To read more about the approach to the systematic design of programs taught in this course, see M. Felleisen, R. B. Findler, M. Flatt, and S. Krishnamurthi: The Structure and Interpretation of the Computer Science Curriculum, Journal of Functional Programming, (2004).
- Provide an experiential learning experience grounded in project- and interdisciplinary-based learning drawn from real-world problems.
Course projects are collaborative, team-based, and interdisciplinary efforts that deal with real-world data sets. Discussion sections are interactive and collaborative sessions lead by TAs to illustrate important concepts from data science and computing, applied to topical, current, real-world data.
- Build a rigorous introduction the fundamentals of programming.
The explicit manipulation of aggregated data requires and motivates a solid foundation in the fundamentals of program design, data structures, recursion, data transformation functions, and algorithmic complexity analysis, thereby laying a sound foundation for further study in computational disciplines.
- Introduce ethical considerations in the application of computer science.
When using synthetic, mechanism-oriented curriculum, incorporating ethics is difficult. However, with courses grounded in real data it is natural to concretely illustrate the social consequences and perils of data-driven decision making and ethical considerations are weaved throughout the courses. Integrating ethics into the introduction of computing advances the UMD grand challenge of Ethical, Fair & Trustworthy Technology. Currently, ethics is not covered in any of the required CS major courses.
- Create a level playing field, regardless of prior experience with programming (or lack thereof).
The course uses pedagogical programming languages that students are very unlikely to have experience with before arriving at UMD. This has strong educational advantages, but also should lead to improved DEI outcomes and establish a more welcoming and accessible first-year environment for students.
We hope these changes lead to a new, more diverse generation of students with a stronger sense of community that will be able to communicate across disciplines in the language of computation.
Who should take PWP instead of OOP?
PWP is targeted to students with a broad diversity in backgrounds and interests and assumes no previous exprience with programming, so in principal, PWP is appropriate for anyone interested in computer science. Whether to take the PWP or OOP sequence really is a matter of personal preference. To make an informed decision on which is right for you, we outline some of the differences between the two courses.
TBD.
Learning objectives for CMSC 131
- Understand foundation concepts of computer systems such as binary and hexadecimal representation and how these can connect into higher level languages and help identify causes of certain software errors.
- Gain experience in developing a mindset of computational thinking, and apply that to taking detailed, multi-level, program requirements and create software solutions that behave exactly as needed.
- Learn about and make use of programming fundamentals such as variables, operators, expressions, statements, methods, and text I/O to be able to implement software solutions with multiple functional requirements.
- Learn about and apply computational tools such as logic and conditional statements to software goals where there are multiple levels of nesting to the logic, and conditions that are compound with as many as three or four related requirements.
- Learn about and apply iteration using at least two different types of loops, implementing software solutions that need to be able to iterate based on things such as the length and properties of the input.
- Learn about data structures such as arrays, multi-dimensional arrays, and Collections including but not limited to the ArrayList, and be able to utilize these tools to dynamically create required data structures at run time and be able to process the information in both one-dimensional and two-dimensional data structures.
- Understand how information is stored in the various types of computer memory in Java, and how the stack and heap are properly utilized when choosing appropriate variables and data structures.
- Learn the principles of object-oriented programming that support modular design and implementation, and polymorphism to allow a single data structure to hold multiple types of related data through programming structures such as interfaces.
- Understand unit testing, how to design unit tests, and how to implement specifications in a detailed-oriented manner that supports testing and verification through unit testing.
- Learn a variety of debugging skills and tools, in support of being able to implement projects with multiple interconnected classes and line of code counts in the 250-500 range for student code (excluding starter framework).
- Learn how recursion is an additional form of iteration with a different mindset from loops, and apply it to appropriate coding challenges.
- Understand the importance of, and some basic determination of, algorithm efficiency on top of algorithm accuracy.
Learning objectives for CMSC 141
- Learn how to solve problems systematically using computational thinking.
- Write and debug programs using a high-level programming language.
- Understand the concept of algorithms and the importance of algorithm design in computer science.
- Learn to write programs to process both tabular and structured data.
- Apply statistical methods to analyze data and draw meaningful conclusions from it.
- Work with real-world data drawn from a diverse set of domains outside of computer science.
- Learn how to assess programs both experimentally and theoretically.
- Understand ethical considerations related to computing.
- Collect, clean, and manipulate data using common tools and programming languages.
- Learn how to specify and test behaviors of programs.
Acknowledgments
These courses were designed in 2022 and 2023 with financial support from a UMD Teaching and Learning Transformation Center grant: A Data-Centric and Experiential Introduction to Computing.
We thank Kathi Fisler and Joe Gibbs Politz for providing feedback and materials during the design process.