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 |
---|---|---|
5/4 |
Lecture 39: Final Review II Holy cow! Your final class for the semester. Today we will finish reviewing what you have learned this semester, as you prepare for the Final Exam. Tasks to do by Friday (May 6, 8am):
Tasks to do by Wednesday (May 11, 7pm):
| |
5/2 |
Lecture 38: Final Review I We'll go over Exam II today, and then we'll admire how much you have learned this semester through a review (which will also help prepare you for the cumulative final!). Tasks to do by Wednesday (May 4):
|
We'll start the week finishing our preparation for Exam 2. We'll also have LOLt (Lots Of Lab time), to help you complete your Final Project (and, perhaps, the optional Extra Credit lab/homework).
Exam 2: Tues Apr 26th (7:30-9pm) |
---|
Date | Lesson Details | Links |
---|---|---|
4/29 |
No Class - woo hoo! We'll take a day off due to the common exam on Tuesday. Use your extra time wisely and work on your final project. | |
4/27 |
Lab Day (no lecture) You have a lot to do over the next week, so class today is open lab. Come and get your questions answered. Tasks to do by Monday (May 2):
| FinalProj Lab EC HW EC |
4/26 |
Exam II Exam 2 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! FYI: our goal is to get all exams graded by Monday. Instructors will post to their group on Piazza once exam scores are loaded into Blackboard. | |
4/25 |
Lecture 37: Exam 2 Prep cont. We'll finish reviewing recently learned concepts, to fully prepare you for the second midterm exam. We will also have some time to answer any questions you have on your Final Project Tasks to do by Tuesday (Apr 26):
| FinalProj |
Week 14: Optional Material and Preparing for Exam II
We'll cover the optional CSCI 261 material this week: 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. On Friday, we'll review the new concepts we've learned since the first midterm exam, in order to prepare you for the second.
DUE: Wed Apr 20th (8am) | Lab 12A    
Lab 12B    
Lab 12C    
HW 12 |
---|
Date | Lesson Details | Links |
---|---|---|
4/22 |
Lecture 36: 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 (Apr 25):
| FinalProj |
4/20 |
Lecture 35: References, Pointers, and Memory We'll continue with the optional material today, and
discover what pointers are and how they work. We begin 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 Friday (Apr 22):
|
Lab EC HW EC FinalProj |
4/18 |
Lecture 34: Memory, Stack, and The Heap We'll start on the optional material today. The focus today is on the difference between the stack (where you store things you know in advance) and the heap (dynamic memory). We'll also have LOLt (Lots Of Lab time) to help you wrap up what is due on Wednesday. Tasks to do by Wednesday (Apr 20):
| Lab12A Lab12B Lab12C HW 12 |
Week 13: 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 about composition (objects within objects ... say what?). We'll also learn about recursion (functions that call themselves ... say what?). Yep, it's gonna be a crazy week! We'll start easy, with a short review of SFML.
DUE: Wed Apr 13th (8am) | Lab 11A    
Lab 11B    
Lab 11C    
HW 11 |
---|
Date | Lesson Details | Links |
---|---|---|
4/15 |
Lecture 33: 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 Monday (Apr 18):
| Lab12C |
4/13 |
Lecture 32: Class Compositions Today we'll chat about objects within objects. Say what?? Tasks to do by Friday (Apr 15):
| Lab12B |
4/11 |
Lecture 31: SFML Review and Animation We'll review some important SFML concepts for your last (yes last!) homework assignment. Lecture will be short, giving you time to work on Homework 11 or recruit a partner for the Final Project. Tasks to do by Wednesday (Apr 13):
| Lab11A Lab11B Lab11C HW 11 Lab 12A |
Week 12: 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.
DUE: Wed Apr 6th (8am) | Lab 10A    
Lab 10B    
HW 10 |
---|
Date | Lesson Details | Links |
---|---|---|
4/8 |
Lecture 30: When to We will discuss the three contexts of Tasks to do by Monday (Apr 11):
| Lab11C HW 11 |
4/6 |
Lecture 29: 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 Friday (Apr 8):
| Lab 11B |
4/4 |
Lecture 28: 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 Wednesday (Apr 6):
| Lab11A |
Week 11: I/O continued ... and Objects!
You've previously met a few simple C++ data structures, e.g., the array. This week we'll start our discussion on more "complex" and meaningful abstractions, i.e., objects. Then, next week, you will have the opportunity to start defining your own (more exciting) objects to the machine. Before starting Chapter 9, however, we'll first finish Chapter 8 in our zyBook (delayed due to the snow storm!).
DUE: Wed Mar 30th (8am) | Lab 09A    
Lab 09B    
HW 09 |
---|
Date | Lesson Details | Links |
---|---|---|
4/1 |
E-Days ... no class ... no joke!
| |
3/30 |
Lecture 27: 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 Monday (Apr 4th):
| Lab10B |
3/28 |
Lecture 26: File I/O (Misc) and Classes vs. Objects 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). We will also re-visit 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 (Mar 30):
| Lab 10A HW 09 |
Week 10: 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 are how to read and write data from files. We'll also cover Chapter 8 in our zyBook.
DUE: Wed Mar 23rd (8am) | Lab 08A    
Lab 08B    
HW 08 |
---|
Date | Lesson Details | Links |
---|---|---|
3/25 |
Lecture 25: File I/O - Writing (QUIZ TODAY) 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 (Mar 28):
| Lab 09B HW 09 |
3/23 |
Snow day - woo hoo!
| |
3/21 |
Lecture 24: 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 Wednesday (Mar 23):
| Lab 09A |
Week 9: 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. We'll then learn about the power of SFML. After spring break, you will learn how to define your own (more exciting) objects to the machine.
DUE: Fri Mar 11th (8am) | Lab 07A    
Lab 07B    
Lab 07C    
Lab 07D    
HW 07 |
---|
Date | Lesson Details | Links |
---|---|---|
3/11 |
No Class - woo hoo! We'll start Spring Break early, a day off thanks to the common exam last week. Tasks to do by Monday (Mar 21):
| |
3/9 |
Lecture 23: SFML 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 on the tasks due Friday). Tasks to do by Friday (Mar 11): | Lab08B |
3/7 |
Lecture 22: strings and vectors While arrays have their place, in many contexts you 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 Wednesday (Mar 9): | Lab08A |
Week 8: Exam 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. We'll also take our first exam. Woo hoo!
DUE: Wed Mar 2nd (7:30pm) | Examination preparation! |
---|
Date | Lesson Details | Links |
---|---|---|
3/4 |
Lecture 21: 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 (Mar 7):
| Lab 07D HW 07 |
3/2 |
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! FYI: our goal is to get all exams graded by Monday. Instructors will post to their group on Piazza once exam scores are loaded into Blackboard. | |
3/2 |
Lecture 20: Memory, Variables, and Arrays Today we will explore how arrays are stored in memory and how we call functions with array parameters. We'll also have plenty of time for any last minute exam Q&A. Tasks to do by Friday (Mar 4):
| HW 07 |
2/29 |
Lecture 19: 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 Wednesday (Mar 2):
| 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. The main goal of this week is to review all the concepts we've learned so far, practice what we've learned, and prepare to ace our first exam.
DUE: Wed Feb 24th (8am) | Lab 06A    
Lab 06B    
HW 06 |
---|
Date | Lesson Details | Links |
---|---|---|
2/26 |
Lecture 18: Are you ready for Wednesday? Today we will finish reviewing our concepts and practice questions, which should give you a taste of what to expect on the first exam. Tasks to do by Monday (Feb 29):
| Lab 07B |
2/24 |
Lecture 17: Prepare to ACE that exam! No new material today - sweet! No class Friday before Spring break (Mar 11) - sweet! No homework due next week - sweet! Exam next Wednesday (Mar 2) - awww. But, good news, we'll spend our time together today getting you ready! Tasks to do by Friday (Feb 26):
| Lab 07A |
2/22 |
Lecture 16: Catch up! You have a lot due this coming Wednesday, and some of us are feeling a bit behind. We'll start today with a brief review of what we've learned so far, complete our third quiz, and then spend time catching up. Tasks to do by Wednesday (Feb 24):
|
Week 6: Structs and Strings
You already know how to define many different types of variables, e.g., int and char. This week you will learn how to define a new type that can be used to group data together (e.g., hour, minute, and second makes a variable called time). We will also explore string objects and how you can use them more effectively in your programs. Chapter 6 in our zyBook is our focus this week.
DUE: Wed Feb 17th (8am) | Lab 05A    
Lab 05B    
HW05 |
---|
Date | Lesson Details | Links |
---|---|---|
2/19 |
Lecture 15: strings Today you will learn a bit more about 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 Monday (Feb 22):
| |
2/17 |
Lecture 14: structs We'll learn how to define and use structures in today's lecture. We'll also cover how powerful structures can be when we return one from a function. Tasks to do by Friday (Feb 19):
| |
2/15 |
No class today! Woo hoo! Enjoy President's Day! |
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.
DUE: Wed Feb 10th (8am) | Lab 04A    
Lab 04B    
Lab 04C    
HW04 |
---|
Date | Lesson Details | Links |
---|---|---|
2/12 |
Lecture 13: 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 (Feb 17):
| |
2/10 |
Lecture 12: 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 Friday (Feb 12):
| |
2/8 |
Lecture 11: 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 Wednesday (Feb 10):
|
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.
DUE: Wed Feb 3rd (8am) | Lab 03A     
Lab 03B     
HW03 |
---|
Date | Lesson Details | Links |
---|---|---|
2/5 |
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 (Feb 8):
| Lab04C HW04 |
2/3 |
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 (Feb 5):
| Lab04B |
2/1 |
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 (Feb 3):
| Lab04A |
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.
DUE: Wed Jan 27th (8am) | Lab 02A     
Lab 02B     
HW02 |
---|
Date | Lesson Details | Links |
---|---|---|
1/29 |
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 (Feb 1):
| Lab03B HW03 |
1/27 |
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 (Jan 29):
| Lab03A |
1/25 |
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 (Jan 27):
| HW02 |
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.
DUE: Wed Jan 20th (8am) |         
Lab 01     
HW01 |
---|
Date | Lesson Details | Links |
---|---|---|
1/22 |
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 (Jan 25):
| Lab02C |
1/20 |
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 (Jan 22):
| Lab02B |
1/18 |
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 (Jan 20):
| Lab02A HW01 |
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.
DUE: Sat Jan 16th (11:59pm) |         
Lab 00 (optional) |
---|
Date | Lesson Details | Links |
---|---|---|
1/15 |
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 (Jan 18):
| Lab01 HW00 HW01 |
1/13 |
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 (Jan 15):
| Lab00 |