Week 16: Last Week of Classes!
Hooray! Your last week of class! This week we will review what we've learned this semester, which will help you prepare for our cumulative final exam.
| Date | Lesson Details | Links |
|---|---|---|
| 12/9 |
Lecture 39: Final Review II Holy cow! Your final class for the semester. Today we will be reviewing what we have learned this semester, as you prepare for the Final Exam. Tasks to do by Friday (Dec 11th):
Tasks to do by Tuesday (Dec 15):
| |
| 12/7 |
Lecture 38: Final Review I We'll have our last quiz today, and begin a review of the semester. Tasks to do by Wednesday (Dec 9):
|
Week 15: Lab Time and Optional Material
We'll start the week with lab time, to help you complete items due with Homework 12 or make further progress on your final project. We'll then move on to the optional topic: pointers and dynamic memory. This optional topic is for you if you (1) plan to take CSCI 262, (2) see yourself programming embedded devices in the future (e.g., EE majors), or (3) want to earn some fabulous extra credit points by doing the pointer homework.
| Date | Lesson Details | Links |
|---|---|---|
| 12/4 |
Lecture 37: References, Pointers, and Memory We'll continue with the optional material today, and
discover what pointers are and how they work. We being our focus on the
fundamentals of pointer syntax, and how to interpret
* and &. We'll then look at dynamic memory, and
how to use Tasks to do by Mon (Dec 7):
|
Lab EC HW EC FinalProj |
| 12/2 |
Lecture 36: Memory, Stack, and The Heap We'll begin today discussing any questions you have from Exam II. Once done, we'll start on the optional material. The focus today is on the difference between the stack (where you store things you know in advance) and the heap (dynamic memory). Tasks to do by Fri (Dec 4):
| FinalProj |
| 11/30 |
Lab Day (no lecture) You have a lot to do over the next 10 days, so class today is open lab. Come and get your questions answered. Tasks to do by Wednesday (Dec 2):
| Lab12A Lab12B HW 12 FinalProj |
Week 14: Exam II and Holiday Break
You've been working hard this semester, so deserve a little break this week (after Exam II). There is no class on Monday, and Wednesday and Friday are official 'no class' days at Mines. Enjoy the break with your loved ones, and return to Mines refreshed (and ready to wrap up the semester).
| Date | Lesson Details | Links |
|---|---|---|
| 11/23 |
Exam 2 No class this week, but we have an exam Monday evening. Check out where on the Resources page. Tasks to do by Monday (Nov 30):
| HW 12 |
Week 13: Recursion and Preparing for Exam II
You've mastered the fundamentals of C++. Sweet! We'll learn recursion this week(functions that call themselves ... say what?). We'll also review the new concepts we've learned since the first midterm exam, and prepare to ace the second midterm exam.
| Date | Lesson Details | Links |
|---|---|---|
| 11/20 |
Lecture 35: Exam 2 Prep Holy cow! It's time to start preparing for the second exam. We'll spend today reviewing recently learned concepts by giving you a taste of what to expect on the second midterm exam. Tasks to do by Monday (Nov 23):
| HW 12 |
| 11/18 |
Lecture 34: Recursion You should be comfortable with declaring functions and calling functions, both global functions and member functions. Today we are demonstrating an important concept in computer science that is certain to melt your brain: functions that call themselves, also known as "recursion." Tasks to do by Friday (Nov 20):
| Lab12B |
| 11/16 |
Lecture 33: Quiz 5 and SFML We'll take our 5th quiz today, and review some important SFML concepts for your last (yes last!) homework assignment. Tasks to do by Wednesday (Nov 18):
| Lab11A Lab11B Lab11C HW 11 Lab 12A |
Week 12: Tips and Tricks for Defining Classes
Take a look: you've now written approximately 30 programs and have learned about programming concepts that almost all modern programming languages provide. And your brain is still intact! This week, we learn how objects and values are stored in memory, why you should usually pass objects by reference, and other tips and tricks with object-oriented programming in C++.
| Date | Lesson Details | Links |
|---|---|---|
| 11/13 |
Lecture 32: When to We will discuss the three contexts of Tasks to do by Monday (Nov 16):
| Lab11C HW 11 |
| 11/11 |
Lecture 31: Class Compositions Today we'll chat about objects within objects. Say what?? Tasks to do by Friday (Nov 13):
| Lab11B |
| 11/9 |
Lecture 30: Helper Functions and Passing Objects Today's lecture focuses on two concepts: avoiding duplicate code and why you should pass objects by reference. Tasks to do by Wednesday (Nov 11):
| HW 10 Lab 11A |
Week 11: Defining Your Own "Things" to the Machine (Intro to Classes)
You have already been introduced to many different types of objects, e.g., strings and vectors. You've learned how to create instances of objects and how to use the "dot operator" to access an object's properties and call its functions. This week you will learn how to represent your own real-world "things" to the machine by declaring classes.
| Date | Lesson Details | Links |
|---|---|---|
| 11/6 |
Lecture 29: Classes Part Deux You now can define a basic class with properties and constructors. Today you will learn (1) the difference between public and private access and (2) the getter/setter pattern. Tasks to do by Monday (Nov 9):
| Lab10B |
| 11/4 |
Lecture 28: Introduction to Classes Now that you know how to instantiate and use objects, today we learn how to define your own types of things through a mechanism we call "class definition". Tasks to do by Friday (Nov 6): | Lab10A |
| 11/2 |
Lecture 27: Classes vs. Objects Today you will learn more about what it means to be "an object" to the machine, why objects help us structure programs, and how we define a "class" to make objects available to our programs. Tasks to do by Wednesday (Nov 4):
| Lab09A Lab09B HW09 |
Week 10: Objects!
Last week you met a simple C++ data structure: the array. This week you will learn how to use more "complex" and meaningful abstractions: objects. We'll first begin with a review of what we know about objects, and then introduce an object-based alternative to the built-in array: the vector class. You will learn how to use vectors through the API they provide this week; next week you will learn how to define your own (more exciting) objects to the machine.
| Date | Lesson Details | Links |
|---|---|---|
| 10/30 |
Lecture 26: strings and vectors While arrays have their place, in many contexts you will want a data structure that is somewhat more flexible. Today you will learn about vectors and how you can use them instead of arrays. Tasks to do by Monday (Nov 2):
| Lab09B HW 09 |
| 10/28 |
Lecture 25: Review and FUN Algorithms Today will mainly be a review on objects. We'll also take a quick look at two important computer algorithms (searching and sorting). Tasks to do by Friday (Oct 30):
| Lab09A |
| 10/26 |
Lecture 24: Multi-Dimensional Arrays cont. We continue our discussion of multi-dimensional arrays today, and show how these 2D arrays in C++ relate to matrices in math. We will also give you an opportunity to ask any questions on your tasks due on Wednesday Tasks to do by Wednesday (Oct 28):
| Lab08A HW 08 |
Week 9: Collections of Things (Hello Arrays!)
The important array concepts this week are how to declare arrays, how to put things in arrays, how to access things that are in the array, and how to send arrays into functions. We'll also cover Chapter 6 in our zyBook.
| Date | Lesson Details | Links |
|---|---|---|
| 10/23 |
Lecture 23: Multi-Dimensional Arrays You should now be fairly comfortable with arrays that store primitive data, such as numbers. What happens when arrays "contain" arrays? Today you will learn about two-dimensional arrays and some common uses and patterns. Tasks to do by Monday (Oct 26):
| Lab 08A HW 08 |
| 10/21 |
Lecture 22: Memory, Variables, and Arrays Like any good car mechanic, we need an understanding of how the machine works in order to be effective. Today we will explore how values are stored in memory. Tasks to do by Friday (Oct 23):
| Lab 07A Lab 07B Lab 07C Lab 07D HW 07 |
| 10/19 |
Fall Break - Relax! Tasks to do TODAY (Oct 19):
|
Week 8: Exam, SFML, and Introduction to Arrays
So far in your programs, you've been dealing with individual pieces of data. This week, we learn how to create collections of data using a simple data structure: the array. But, first, we'll learn about the power of SFML and take our first exam. Woo hoo!
| Date | Lesson Details | Links |
|---|---|---|
| 10/16 |
No class today. Just sleep. Yah! Tasks to do TODAY (Oct 16):
| |
| 10/14 |
Lecture 21: Intro to Arrays A critical element in computer science is the "data structure": something that can store multiple pieces of data together. For example, we might want to create a "list" of football scores, movie ratings, or temperature readings. Today you will be introduced to a fundamental data structure called an array. Tasks to do by next Wednesday (Oct 21):
| Lab 07D HW 07 |
| 10/12 |
Exam I Exam 1 is from 7:30-9:00pm. Go to the Common Exam Times section of the Resource page to see where you need to be. Don't be late! Instructors will post to their group on Piazza once exam scores are loaded into Blackboard. | |
| 10/12 |
Lecture 20: Simple and Fast Multimedia Library Today we will provide an overview of the SFML framework and show you how to draw shapes. We'll also leave time for you to give SFML a test run (OR ask any last minute questions for the exam). Tasks to do by Wednesday (Oct 14):
| Lab 07C |
Week 7: Concept Review
If you've gotten this far and your brain hasn't melted, then congratulations! Learning how to program is not easy, as you are learning a totally new language. We'll finish our discussion of file I/O this week; we'll then begin a review of all the concepts we've learned so far, practice what we've learned, and prepare to ace the first exam.
| Date | Lesson Details | Links |
|---|---|---|
| 10/9 |
Lecture 19: Are you ready for Monday? Today we will finish reviewing our concepts and practice questions, which should give you a taste of what to expect on the first exam. If time, we will provide an overview of the SFML framework and show you how to draw shapes. Tasks to do by Monday (Oct 12):
| |
| 10/7 |
Lecture 18: Prepare to ACE that exam! No new material today - sweet! No class next Friday (Oct 16) - sweet! No homework due next week - sweet! Exam on Monday - awww. But, good news, we'll spend our time together today getting you ready! Tasks to do by Friday (Oct 9):
| Lab 07B |
| 10/5 |
Lecture 17: File I/O - Misc You've learned the basics of reading and writing data from files thus far. Now let's look at some common patterns for looping on data, as well as annoying errors that can occur (and, more importantly, how to correct them). Tasks to do by Wednesday (Oct 7):
| Lab 07A |
Week 6: Data, Input, and Output
You've learned how a program can be "interactive" by accepting keyboard input and printing information to the screen. This week you will take a first step toward automation and persistence, creating programs that can read lots of data from files and write lots of data to files. The important concepts this week (after we finish functions) are how to read and write data from files. We'll also finish Chapter 5, and cover a good chunk of Chapter 8 in our zyBook.
| Date | Lesson Details | Links |
|---|---|---|
| 10/2 |
Lecture 16: File I/O - Writing Have you ever thought about how the information your programs print to the screen just "disappear" once the program ends? What if you wanted to "keep" the output from your program around for later use? Now that you've learned how to read data, today you will create a program that writes information to a text file. Tasks to do by Monday (Oct 5):
| Lab 06C HW 06 |
| 9/30 |
Lecture 15: File I/O - Reading You've learned how to provide the machine information interactively via the keyboard. But what if you need to provide lots of information? How does a program like iTunes read an .mp3 file and generate music? Today you will learn how to create programs that can read data from text files and act upon that data. Tasks to do by Friday (Oct 2):
| Lab 06B |
| 9/28 |
Lecture 14: FUNction Hodgepodge Today we'll learn about scope, i.e., "what happens in braces stays in braces." You will also learn how to use function prototypes above main and definitions below, as well as defining separate header and implementation files. Tasks to do by Wednesday (Sept 30):
| Lab 06A |
Week 5: FUNctions
You have now learned the fundamental concepts needed to write useful programs. This week you will learn a key abstraction in programming: the function. Think about how functions are like "mini programs" that abstract the work that they do. Also consider how meaningful function names help your programs read more like human language and, therefore, let you focus on how to use them (not how they do their work). The important concepts this week are how to use existing functions, how to define your own functions, and what "scope" is all about. We're also covering a good chunk of Chapter 5 in our zyBook.
| Date | Lesson Details | Links |
|---|---|---|
| 9/25 |
Lecture 13: FUNctions cont. (Pass by Reference) There are cases where we want a function to be able to modify the actual piece of data it is passed. Today, learn a little more about memory and how to declare functions that receive their arguments by reference. Tasks to do by Monday (Sept 28):
| |
| 9/23 |
Lecture 12: Introduction to FUNctions You've learned the nuts and bolts of programming; now let's learn how to combine those nuts and bolts into more effective, readable, maintainable programs. Today you will learn how to define functions and how to use them. Tasks to do by Friday (Sept 25):
| |
| 9/21 |
Lecture 11: Functions, Objects, and strings Today you will learn about functions, as well as what it means to be "an object" to the machine. We will also explore string objects and how you can use them more effectively in your programs. Tasks to do by Wednesday (Sept 23):
|
Week 4: Doing Things Repeatedly (loops with while and for)
Computers are very good at doing repetitive tasks. This week you will learn how to tell the computer to do things repeatedly, and how to modify what the computer does during each repetition. The important concepts this week are to understand common loop "patterns", and how to use C++ loop syntax to model repetitive tasks. We are also covering Chapter 4 of our zyBook.
| Date | Lesson Details | Links |
|---|---|---|
| 9/18 |
Lecture 10: Loops continue (or break) Today we'll learn one more repetitive statement choice; the do-while loop is perfect when you need the loop to execute at least once. We'll also learn how to get out of a loop, in case the need arises. Tasks to do by Monday (Sept 21):
| Lab 04C HW 04 |
| 9/16 |
Lecture 9: Loops with for Another useful tool for implementing repetitive tasks is the for loop. Today we'll learn about the similarities between while and for loops and how to convert a while loop to a for loop (and vice-versa). We will also look at the sophisticated increment/decrement operators. Tasks to do by Friday (Sept 18):
| Lab 04B |
| 9/14 |
Lecture 8: Loops with while Today you will learn how to teach the machine to complete repetitive tasks, which computers are incredibly good at doing. We'll also discuss "stopping conditions" to ensure the loop stops at some point (else our dumb computer would be happy to loop forever!) Tasks to do by Wednesday (Sept 16):
| Lab 04A |
Week 3: Making Decisions (Boolean Logic and Selection Statements)
Now that you've learned how to exercise some basic C++ syntax, it's time to do something more useful: teach the computer to make decisions using what it understands about the world. The important concepts this week are to understand that (1) boolean expressions get evaluated and yield a value and (2) selection statements can be used to model logical decision-making. We are also covering Chapter 3 of our zyBook.
| Date | Lesson Details | Links |
|---|---|---|
| 9/11 |
Lecture 7: Switch It Baby Nested if-else statements can be useful, unless they get too complicated. When you have a multiple-selection decision to make, try the simplicity of a switch statement. Tasks to do by Monday (Sept 14):
| Lab 03B HW 03 |
| 9/9 |
Lecture 6: Nested Selection Statements and Logic Ops Today you learn how to model more complex decisions with multiple if-else and nested selection statements. We'll also learn about truth tables, logical expressions, and "short circuiting" (which, surprisingly, has little to do with electricity). Tasks to do by Friday (Sept 11):
| Lab 03A |
| 9/7 |
Lecture 5: Boolean Expressions and Being Random Today we learn about boolean logic and how any decision can, in theory, be reduced to a Boolean expression. We'll also learn about pseudo-random numbers and how to use rand(). Tasks to do by Wednesday (Sep 9):
| HW 02 |
Week 2: Programming Fundamentals (Variables, Operators, Expressions)
The goal of this week is to introduce you to some basic C++ syntax rules, give you experience declaring facts that change, and how to combine various facts with operators to create expressions. The important concepts this week are to know how to declare and use variables and expressions.
| Date | Lesson Details | Links |
|---|---|---|
| 9/4 |
Lecture 4: Hodgepodge In today's class, we'll cover the 'mystery' of mixed type expressions, how to speak like a computer, and the powerful math library that is at your fingertips. Tasks to do by Monday (Sept 7):
| Lab 02C |
| 9/2 |
Lecture 3: Arithmetic Operators Learn about primitive operators such as addition and multiplication. Learn how to combine operators and variables to form expressions. Tasks to do by Friday (Sept 4):
| Lab 02B |
| 8/31 |
Lecture 2: The Basics (continued) Understand the basics of hardware and software, and what an operating system is. Also discover the purpose of variables, and their naming rules. Tasks to do by Wednesday (Sept 2):
| Lab 02A HW 01 |
Week 1: The Start of a Journey
The goal of this week is to dive in and compile your first program. The important concepts this week are to know how to compile and run a program with Visual Studio. We're also getting familiar with our online textbook, as well as gaining a high-level understanding of programs and programming.
| Date | Lesson Details | Links |
|---|---|---|
| 8/28 |
Lecture 1: The Basics Understand C++ program structure, the way we communicate with the computer, and how to maneuver in Visual Studio. Tasks to do by Monday (Aug 31):
| Lab 01 HW 01 |
| 8/26 |
Lecture 0: Welcome to 261! Our first class. How exciting! We'll get to know each other, setup our Visual Studios environment, and discuss the expectations of the course. Tasks to do by Friday (Aug 28):
| Lab 00 |