Michigan ENGR 101: Introduction to Computers and Programming
ENGR 101 is the College of Engineering's first-year programming course, teaching MATLAB and C++ through engineering problems: data analysis, image manipulation, and algorithm implementation. It's a core requirement for most engineering majors and assumes no prior programming.
Fennie is independent and not affiliated with University of Michigan. This is an unofficial study guide.
What makes it hard
The mid-semester switch from MATLAB to C++ is the classic stumble. Just as MATLAB starts feeling comfortable, the course changes languages and adds compilation, types, and stricter syntax. Projects are autograded against specs that reward careful reading, and exams test code reading and writing on paper, which is a different skill from getting the autograder green.
What you'll cover
- • MATLAB programming and data analysis
- • Algorithms and flow control
- • C++ fundamentals
- • Functions and program design
- • Arrays, vectors, and file I/O
- • Engineering problem solving with code
The ENGR 101 study guide
How to study for Michigan ENGR 101, step by step.
- 1
Program daily, even briefly
ENGR 101 is most students' first programming course, and the skill compounds with frequency. Twenty minutes a day beats a weekly project binge, especially before the language switch.
- 2
Read project specs twice before coding
The autograder checks exact behavior, and most lost project points are spec misreadings rather than bugs. Make a checklist from the spec and test against it.
- 3
Treat the C++ transition as a restart
When the course switches from MATLAB, slow down and relearn fundamentals in the new syntax. Assuming the MATLAB intuitions transfer directly is the classic mid-semester stumble.
- 4
Practice tracing code on paper
Exams ask what code does without a compiler to ask. Hand-trace loops and functions weekly from the first MATLAB unit onward.
Today's ENGR 101 plan
What a Fennie Daily Plan looks like for ENGR 101. Yours is built from your syllabus and adapts every day to your deadlines and progress.
- Review: Functions and program designReview · 25 min
Work back through the ENGR 101 material on functions and program design. In the app, Fennie builds this from your own notes and syllabus.
- Practice: Arrays, vectors, and file I/OPractice · 20 min
Targeted problems on arrays, vectors, and file i/o, the kind ENGR 101 actually tests.
- Quick quiz: Engineering problem solving with codeQuiz · 10 min
Five generated questions to expose weak spots on engineering problem solving with code before the exam does.
- Preview: MATLAB programming and data analysisPreview · 10 min
A first pass over matlab programming and data analysis so the next session starts from familiar ground.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
Is ENGR 101 hard with no programming experience?
It's designed for exactly that audience, and most students manage it. The risky moments are the C++ transition mid-semester and project deadline weeks. Daily practice and early project starts neutralize both.
Should I take ENGR 101 or EECS 183?
Engineering majors generally take ENGR 101, which satisfies the College of Engineering requirement and uses engineering-flavored problems. EECS 183 serves LSA students and others heading toward the CS sequence. If you're considering a CS major, check which path your program expects.
What language does ENGR 101 use?
MATLAB for the first part of the course, then C++. The MATLAB half builds algorithmic thinking with quick feedback; the C++ half introduces the stricter compiled-language discipline that later engineering and CS courses assume.
More Michigan courses
EECS 183: Elementary Programming Concepts
EECS 183 is Michigan's intro programming course for students with little or no coding experience, taught in C++ and Python. It's the standard entry point into the CS sequence for students who aren't ready to jump straight into EECS 280, and it ends with an open-ended final team project.
EECS 280: Programming and Introductory Data Structures
EECS 280 is the second course in Michigan's CS sequence, covering C++ programming in depth: pointers, dynamic memory, container ADTs, polymorphism, and recursion. It's a prerequisite for nearly everything in the CS major and the course where Michigan students first hit serious multi-week projects.
EECS 281: Data Structures and Algorithms
EECS 281 is Michigan's data structures and algorithms course and the gateway to upper-level CS. Most 400-level EECS courses require it. It covers algorithm analysis, sorting, hashing, trees, graphs, and dynamic programming, with large C++ projects graded heavily on runtime performance.
MATH 115: Calculus I
MATH 115 is Michigan's first-semester calculus course, covering limits, derivatives, and an introduction to integration, required across engineering, science, and economics tracks. It's taught in small sections but standardized across the department, with uniform team-written exams for everyone.