CS 212 Software Development

This guide will discuss the logistics and possible topics for exam 1. See the Syllabus for details on the exam pass requirement.

Exam Logistics

See below for how the exam will be conducted remotely. Generally speaking, expect the exam to take at least an hour. It will be open book and conducted via Canvas. The questions and possible answers will be randomized to help combat cheating.

Remote Format

The exam will be split into two components: (1) the primary exam conducted within Canvas and (2) a short coding section conducted using Github Classroom. To complete the exam, students must have access to:

Resource	Login Account	Details
Canvas	Login using your USF account.	Used to conduct the exam. Will include the necessary Github Classroom link for the coding section.
Github	Login using your Github account linked to this class.	Used for the coding section. A Github Classroom link will be provided in Canvas that will setup the necessary Github repository. Only code committed and pushed to this repository before the deadline will be used.
Eclipse	N/A	Used to import, run, commit, and push code for the coding section. Other IDEs may be used at the students’ risk. Students should verify all of the relevant lecture code is runnable from within their IDE!

The Canvas portion will not use Lockdown Browser. You will not see your scores or answers after completing the exam until the retake begins.

The exam will be locked with a password. You must join the lecture Zoom livestream to receive instructions and the exam password at the start of lecture time. If you have questions during the exam, you can ask questions privately in chat or raise your hand on the Zoom. If you raise your hand on Zoom, you will be placed in a private breakout room to ask your question and share your screen if needed.

While you have to join the lecture livestream at the start of the exam, you do not have to stay on the Zoom livestream while you take the exam. The Zoom livestream is there to provide you immediate help, not monitor you.

Timing

The exam will automatically unlock and lock at the start and end times of your enrolled section.

The exam should take around 1 hour to complete, but you will have the entire class time of 1 hour 45 minutes to complete the exam.

Question Types

The exam questions may consist of:

• Multiple Choice Questions

• Multiple Answer Questions

• Dropdown Questions

• Short Answer and Code Snippets

The specific questions, order you see questions, and possible answers may be randomized. Most questions will be automatically graded by Canvas. Short answer and code snippet questions will be graded manually by the instructor.

Resources

The exam is open book, with the exception that you cannot ask anyone else (such as another student or user on StackOverflow) to answer a question on your behalf.

I recommend preparing to access to the following official Java documentation during the exam:

• Java 15 API
• Java SE 15 Language Specification
• Java SE 15 Documentation Center
• Java Tutorials
• Java Glossary

You should also be prepared to access any of the class materials, including your homework submissions. You might also want to be familiar with jshell just in case you want to quickly run Java code.

Combating Cheating

There is a 0 tolerance cheating policy for exams. Cheating is fundamentally unfair to you, your classmates, me, and anyone that places value in your degree. When it comes to cheating:

1. You don’t need to cheat; you have many opportunities to meet the exam pass requirement.
2. You don’t want to cheat; the consequences of cheating are worse than failing the exam.
3. You will get caught; I will be looking for it.
4. It is hard to cheat and you do not have the time for it.

I will provide more context for each of the above points during the exam review.

SDS Accommodations

Students may receive exam accommodations, such as additional testing time, through Student Disability Services. I must receive a notification for accommodation from SDS approximately one week before the exam itself.

Contact me on CampusWire to schedule a specific time to take the exam and retake. In most cases, you will start the exam with your section and have additional time past the end of lecture time. I will try my best to actively monitor CampusWire for any exam questions after lecture time ends, but might not be available to answer questions live on Zoom.

Exam Retake

You will have an opportunity to retake the entire exam during the next class period. The final exam 1 score will be the average of the original and retake scores. It is impossible to earn a lower score due to the retake process. If your retake score is lower than your original score, your original score will be used instead of an average.

The retake is conducted exactly the same as the original exam with a couple of exceptions:

1. You will have access to your original attempt. You will see which questions you answered right or wrong (but not the correct answers). Keep in mind, however, that the retake will also use randomized questions. The exact questions from your original attempt might not match those in your retake attempt.

2. The instructor will provide hints in the Zoom livestream on the hardest questions. You must be on the livestream to receive these hints.

The exam retake is optional. If you are happy with your current exam score and received a C or above letter grade, you can skip the retake process. Your original exam score will be used instead.

Exam Topics

The exam will cover topics on all of the lecture slides, homework assignments, quizzes, and additional resources covered thus far in class. This includes:

Topic and Code	Lecture Slides	Practice Quizzes	Homework
Files and Exceptions (Code)	Exceptions • Paths and Files	Paths and Files	TextFileStemmer • TextFileFinder
Data Structures (Code)	Basic Types • Collections Framework	Data Structures • Using Maps	ArgumentMap • SimpleJsonWriter • TextFileIndex
Object Oriented Programming (Code)	Terminology	Static vs Instance • Instance vs Identifier • Mutability, Part 1 • Mutability, Part 2	ArgumentMap • TextFileStemmer • TextFileIndex
Inheritance (Code)	Relationships • Abstract Classes and Interfaces • Object Class • Final Keyword • Collections Revisited • Casting • Nested Classes • Generics	Collections Revisited • Keywords • Nested Classes • Casting	TextFileIndex
Lambda Expressions (Code)	Java History • Lambda Expressions	Java Features • Lambda Expressions	TextFileFinder
Stream Pipelines (Code)	Basics • Pipelines	Stream Pipelines	TextFileFinder
Debugging (Code)	Assertions • Logging	Assert Statements • Logging

Note that homework is often associated with multiple topics and appears multiple times in the table.

See the Schedule for links to the many videos and recordings made for this content.

Example Topics

The following are some example topics that you may want to make sure you understand. This is a non-comprehensive list. Some of these topics may not appear on the exam and some topics not covered here may appear on the exam.

• You should understand what each keyword in Java means, including: public, private, static, final, class, abstract, and interface.

• You should understand the difference between a primitive type and an object.

• You should understand how to use different control-flow statements, such as if, else if, else statements, for and enhanced for loops, while and do-while loops, switch statements, and how to use related keywords such as break, continue, and return.

• You should understand how to create and use String objects.

• You should be familiar with the Object class and all of its methods.

• You should understand how to use the new keyword and its significance when it comes to memory allocation and the final keyword.

• You should understand the difference between mutable versus immutable objects, and when it is safe to pass a reference of an object.

• You should understand the difference between the abstract data types list, set, and map.

• You should understand how and when to use different built-in data structures, such as ArrayList, LinkedList, HashSet, TreeSet, HashMap, and TreeMap.

• You should understand how to create, access, and efficiently iterate through a nested data structure, and understand how to compare the pros/cons of different approaches to iteration.

• You should understand how to create and use classes, including the meaning of terms like constructors, methods, and members.

• You should understand how to design a class to be both generalized and encapsulated.

• You should understand how to overload and override methods.

• You should understand the difference between identifiers and instances.

• You should understand how to catch and throw exceptions.

• You should understand how to use a try-with-resources block, as well as a traditional try/catch/finally block.

• You should understand the difference between a relative path and absolute path.

• You should understand how to read and write to files line-by-line and traverse directories using the Java “new IO” package and the Path, Paths, Files, BufferedReader, BufferedWriter, and DirectoryStream classes.

• You should understand inheritance-related terms such as superclass, subclass, direct, and indirect, as well as keywords such as this and super.

• You should understand the difference between an interface and an abstract class.

• You should understand how to create a nested class, and the difference between different types of nested classes.

• You should understand how to create an anonymous inner class, and the inheritance relationships that class has to its outer class and its superclass.

• You should understand concepts such as upcasting and downcasting, as well as how they are useful.

• You should understand how to extend the Comparator and Comparable interfaces to allow for custom sorting using Collections.sort().

• You should understand how to create functional interfaces using the @FunctionalInterface annotation.

• You should understand how to create and use lambda expressions, and the difference between lambda expressions and anonymous inner classes and interfaces.

• You should understand how to create and use streams and stream pipelines, and the differences between a stream and a collection.

• You should understand terminology with respect to stream operations, including intermediate versus terminal operations, lazy versus eager operations, and what it means for an operation to be non-interfering, stateless, and without side-effects.

• You should understand how to use assertions in Java using the assert keyword, and where it is (or is not) appropriate to use.

• You should understand how to configure and use Log4j2 for logging and debugging. If given a configuration file, you should be able to determine where log messages will go (file or console), which level log messages will be output (all, info, debug, etc.), and in what format.