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.

DateLesson DetailsLinks
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):

  • Prepare for the final exam, which will be a cumulative exam from the semester's content. Potential exam topics are a union of the topics listed in Exam I Topics and Exam II Topics.

    Reminder: You must pass the final exam (at least 60%) in order to pass this course.

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):

  • Finish your Final Project, due Wed 8am. Final projects can NOT be submitted late.

    Reminder: You must pass the final project (at least 60%) in order to pass this course.

Week 15: Exam 2 and Open Lab Time

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)
DateLesson DetailsLinks
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):

  • Study for the final exam by completing Final Exam Practice before class on Monday. Two points of extra credit for those that do this!
  • Practically finish your Final Project between now and Monday. You'll only want to fix minor issues on Tuesday, and then submit on Wednesday (8am).

    Reminder: The final project can NOT be accepted late.

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):

  • Study! Exam 2 is Tuesday (April 26th), 7:30-9:00pm.
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
DateLesson DetailsLinks
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):

  • Study! Exam 2 is Tuesday (April 26th), 7:30-9:00pm.
  • Continue working on your Final Project.
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 new and delete.

Tasks to do by Friday (Apr 22):

  • Study for the exam by completing these Exam 2 Practice problems before class on Friday. Two points of extra credit for those that do this!
  • Complete Lab EC (due with extra credit homework).
  • Start Homework EC (due Friday, May 6th, 8am).
  • Continue working on your Final Project (due Wed, 8am). Final projects can NOT be submitted late.

    Reminder: You must pass the final project (at least 60%) in order to pass this course.

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


DateLesson DetailsLinks
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):

  • Finish Lab 12C, if not finished in class.
  • Write full draft of your Final Project Definition.
  • Prepare for Quiz 6 (on Monday)
  • Get a good start on Homework 12
Lab12C
4/13

Lecture 32: Class Compositions

Today we'll chat about objects within objects. Say what??

Tasks to do by Friday (Apr 15):

  • Finish Lab 12B, if not completed in class
  • Do all non-optional zyBook sections for Chapter 10 (10.1 - 10.5 and 10.9).
  • Read through the requirements for Homework 12 and bring questions to class.
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):

  • Finish Lab 11A, Lab 11B, and Lab 11C (due Wed 8am).
  • Finish Homework 11 (due Wed 8am).
  • Finish Lab 12A, if not completed in class; NOTE: you need this lab for the lab on Wednesday
  • Do Sections 9.16 - 9.18 in our zyBook (if you haven't already)
  • NOTE: The Final Project code is due Wednesday, May 4th (not the 5th!)
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


DateLesson DetailsLinks
4/8

Lecture 30: When to const

We will discuss the three contexts of const in today's lecture, at least two of which should be review. We'll also talk about the final project for the class, where you have an opportunity to show off all you've learned this semester in one nicely documented piece of software. Nice!

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):

  • Finish Lab 11B, if not done in class.
  • Do Sections 9.9 - 9.10 in our zyBook.
  • Read specifications for the Final Project
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):

  • Complete Lab 10A, Lab 10B, and Homework 10 (due Wednesday, 8am).
  • Prepare for Quiz 5, on all of Chapter 8 (I/O) and Chapter 9.1-9.5 (start of classes).
  • Finish Lab 11A, if not finished in class.
  • Do Sections 9.6 - 9.8 in our zyBook.
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


DateLesson DetailsLinks
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):

  • Complete Lab 10B (if not finished in class).
  • Read Classes document.
  • Do Sections 9.4-9.5 in our zyBook.
  • Start Homework 10, due Wednesday (4/6), 8am.
  • Note: Next Quiz will be Wednesday, April 6th, on all of Chapter 8 (I/O) and Chapter 9.1-9.5 (start of classes).
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


DateLesson DetailsLinks
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):

  • Complete Lab 09B (if not finished in class).
  • Do Sections 8.6-8.7 in our zyBook.
  • Start Homework 09 (due on Wednesday, 8am).
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):

  • Complete Lab 08A, Lab 08B, and Homework 08 (due Wednesday, 8am).
  • Complete Lab 09A (if not finished in class).
  • Prepare for Quiz 4 (on arrays, strings, and vectors ... and possible one question on SFML)
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


DateLesson DetailsLinks
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):

  • Finish Lab 08A and Lab 08B, if not completed this week.
  • Get a good start on Homework 08 (due Wed, 23rd, 8am).
  • Do Sections 8.1-8.5 in our zyBook.
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!


DateLesson DetailsLinks
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):

  • Complete Lab 07D (if not finished in class).
  • Do Sections 7.7-7.14 in our zyBook.
  • Start Homework 07 (due Wednesday, 8am).
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):

  • Read through Homework 07 (due Wed Mar 9, 8am)
  • Do Section 7.6 in our zyBook.
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):

  • Study!
  • Complete Lab 07C (if not finished in class).
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


DateLesson DetailsLinks
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):

  • Complete Lab 07B (if not finished in class). This lab is due AFTER the exam, but do it BEFORE (as it's good exam practice).
  • Study for the exam by completing the previously given exam that is posted on the resource page. (NOTE: we covered file input/output instead of structs on this example exam. File input/output questions are crossed out.)
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):

  • Complete Lab 07A (if not finished in class). This lab is due AFTER the exam, but do it BEFORE (as it's good exam practice).
  • Study for the exam by completing Exam 1 Practice - File 2 before class on Friday. Two points of extra credit for those that do this!
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):

  • Complete Lab 06A and Lab 06B (due on Wednesday, 8am).
  • Complete Homework 06 (due on Wednesday, 8am).
  • Start studying for the exam by completing Exam 1 Practice - File 1 before class on Wednesday. Two points of extra credit for those that do this!

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


DateLesson DetailsLinks
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):

  • Complete Lab 06B (if not finished in class, to be submitted with HW06).
  • Make good progress on Homework 06 (due Wed 8am)
  • Prepare for Quiz 3 (on Monday), which covers functions, structs, and strings.
  • Do Sections 7.1 - 7.5 in our zyBook.
Lab06B
HW06
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):

  • Complete Lab 06A (if not finished in class, to be submitted with HW06).
  • Do Sections 6.3 - 6.9 and 4.8.1 in our zyBook.
  • Start Homework 06
Lab06A
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


DateLesson DetailsLinks
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):

  • Complete Lab 05B (if not finished in class, to be submitted with HW05).
  • Complete Homework 05 (due Wed 8am)
  • Do Sections 6.1 - 6.2 in our zyBook.
Lab05B
HW05
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):

  • Complete Lab 05A (if not finished in class, to be submitted with HW05).
  • Do Sections 5.12 - 5.16 in our zyBook.
  • Start Homework 05
Lab05A
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):

  • Complete Lab 04A, Lab 04B, and Lab 04C (due on Wednesday, 8am).
  • Complete Homework 04 (due on Wednesday, 8am).
  • Do Sections 5.8 - 5.11 in our zyBook (NOTE: 5.11 is optional).
HW04

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


DateLesson DetailsLinks
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):

  • Complete Lab 04C (if not finished in class, to be submitted with HW04).
  • Do Sections 5.1 - 5.7 in our zyBook.
  • Prepare for Quiz 2 (on Monday), which covers Chapters 3 and 4.
  • Get a good start on Homework 04
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):

  • Do Sections 4.8 - 4.11 in our zyBook (4.10 is optional).
  • Complete Lab 04B (if not finished in class, to be submitted with HW04).
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):

  • Complete Homework 03 due Wed (2/3) at 8am. Submit with Lab 03A and Lab 03B.
  • Do Sections 4.5 - 4.7 in our zyBook.
  • Complete Lab 04A (if not finished in class, to be submitted with HW04).
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


DateLesson DetailsLinks
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):

  • Complete Lab 03B (if not finished in class, to be submitted with HW03).
  • Do Sections 4.1 - 4.4 in our zyBook.
  • Continue Homework 03.
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):

  • Complete Lab 03A (if not finished in class, to be submitted with HW03).
  • Do Sections 3.6 - 3.10 (3.8 optional) in our zyBook.
  • Start Homework 03.
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


DateLesson DetailsLinks
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):

  • Prepare for Quiz (Monday), which covers material in Chapters 1-2 in zyBook.
  • Complete Lab 02C (if not finished in class, to be submitted with HW02).
  • Do Sections 3.1 - 3.2 in our zyBook.
  • Start Homework 02.
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):

  • Complete Lab 02B (if not finished in class, to be submitted with HW02).
  • Do Sections 2.8 - 2.17 in our zyBook.
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):

  • Complete Lab 02A (if not finished in class, to be submitted with HW02).
  • Complete Homework 01, due Wed (1/20) at 8am.
  • Do Sections 2.4 - 2.7 in our zyBook.
  • Do LightBot puzzles (or similar flavor; see Piazza post made Jan 11th).
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)


DateLesson DetailsLinks
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):

  • Complete Lab 01 (if not finished in class).
  • Submit Homework 00 by Saturday evening (optional, but good to test).
  • Do Sections 1.5 - 2.3 in our zyBook
  • Start Homework 01. Homework 01 should be started after completing the zyBook assignment. Homework 01 will be due Wed (1/20) at 8am.
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):

  • Read all pages on this site (see the sidebar). Be sure to check out all the pages under Resources.
  • Make sure you can access this class on Blackboard. Contact instructor if not.
  • Enroll in this class on Piazza (you should have received an email invitation).
  • Get an ADIT account, if needed (see syllabus).
  • Buy our electronic textbook.
  • In your new zyBook, under "Need Help?" (which is found under the three dots in the upper right corner), click on "Click here" (center of page), click on "Using zyBooks" (left of page), and then do both Section 1.1 and Section 1.2.
  • Now, go back to the Chapters for the text and do 1.1 - 1.4 in Chapter 1: Introduction.
  • Complete Lab 00 (if not finished in class).
Lab00