Proficiency Exam Information
Illinois CS 128 Proficiency Exam Information
Howdy and welcome to the Illinois CS 128 Proficiency Exam Information website! Before continuing, it is imperative that you first familiarize yourself with the content on the Illinois CS Proficiency Exams website. In addition to critical information about the proficiency process at Illinois, dates, times, and locations of the CS 128 proficiency exam will be posted there.
Since this is a proficiency exam, we will only release a topic list for your review. We will not provide additional study materials. If you have substantial experience with C++ and have taken a CS 1.5 equivalent course/experience, you should find the proficiency exam straightforward.
To make CS 128 lessons available and accessible to everyone, we publish each lesson to Learn C++ Online (learncpp.online).
The CS 128 Proficiency Exam is a three-hour comprehensive exam that covers all content covered in CS 128 over the course of a typical semester. The exam can consist of multiple-choice, matching, fill-in-the blank, and free-response questions that you will have a single opportunity to answer correctly. There will also be programming questions, which you will be able to attempt as many times as you want for full credit. We will provide documentation for libraries at our discretion inside the exam environment.
The exam must be completed in a sterile environment. No water bottles, etc. will be allowed in the environment where you choose to take the exam. You will be required have your own computer and set-up a secondary device so that we may monitor you. Absolutely no outside resources will be allowed during the exam. This includes notes, the internet, etc. Simply put, if we did not provide it, you cannot use it. All code will/must be written inside the exam environment. Using anything else to author your solution will be an academic integrity violation. You may not download anything from the exam instance, including your own code. Due to the Zoom proctoring, no scratch paper or an electronic equivalent will be allowed.
To register for the exam, you will be required to assert the following: “I will not give nor receive any received unauthorized aid on this academic work. In particular, I certify that I will not receive or give any assistance that is contrary to the letter or the spirit of this proficiency exam.” If you are caught cheating or found complicit in cheating, you will (without question) fail the exam, receive a FAIR violation, and will immediately fail CS 128 upon your enroll in the course. You will be required to agree to this and affirm any other academic integrity policies we have in place upon registering for the exam. Do not even think about cheating. We are serious about this, and ask you to be serious about learning.
Please see the Illinois CS Proficiency Exams website.
You will be required to author your responses to our programming questions using an in-browser instance of Microsoft Visual Studio Code. You can access a practice workspace by visiting PrairieLearn and enrolling in “CS 128: Introduction to Computer Science II, Proficiency Exam Environment Practice”.
- B- and above: Pass. Do not take CS 128.
- C+ and below: You did not pass the proficiency exam. We look forward to having you in CS 128!
You should be able to navigate the command line using basic bash shell commands
You should be able to manage, organize, compile C++ projects of simple complexity using Unix-based tools:
- Version control (git)
- Build systems (make)
- Clang C++ compiler
You should be familiar with basic editing and debugging tools, including:
- Microsoft Visual Studio Code
- GNU debugger (GDB)
- Clang AddressSanitizer (ASan)
- Clang MemorySanitizer (MSan)
- Unit testing with catch2
You should be familiar with the following libraries:
Using the C++ programming language, you should be prepared to:
- Write computer programs that solve a variety of problems in the C++ programming language
- Decompose a problem, identify its important features, and design/implement a computer program that solves that problem; articulate rationale for various design and implementation decisions
- Read, write, and understand iterative, declarative, object-oriented, and recursive computer code – determine intention, trace runtime behavior, and identify bugs and errors that might occur
- Use behavioral-driven design and test-driven development to derive/write programs from specifications
- Use basic visual editing and command-line debugging tools to develop and debug programs
- Detail the differences in the representation of the primitive types and implications thereof
- Use character-based io and binary-based io streams to read from standard input and files; to write to standard output and files; use stream states to recover from formatting errors
- Apply object-oriented programming concepts: objects, classes, inheritance, polymorphism, and encapsulation
- Implement and understand generic programming solutions using function templates and class templates
- Distinguish the regions of a program’s address space and understand their affordances on object lifecycles
- Show satisfactory understanding of memory management of dynamically allocated objects in classes, including the rule of zero, rule of three, rule of five, memory leaks, and dangling pointers
- Using dynamic memory, implement the data structures covered in this course – including vectors, lists, trees, and graphs
- Illustrate a proper understanding of elementary concepts in functional programming and their applications in the C++ language
- Design basic database schemas and translate to SQLite; write code that interfaces with these databases using appropriate adapters in their applications
- Setup a basic web server using cpp-httplib, implement routes that process different types of HTTP requests to specified endpoints; provide valid JSON responses constructed with nlohmann::json to the client
- Show familiarity with binary trees and trees with unbound branching
- Implement a binary tree that respects the binary search tree property using dynamic memory; define traversal, queries, and other algorithms that operate on a BST
- Show familiarity with graph structures; an understanding of graph terminology
- Implement directed/undirected graphs using adjacency lists and adjacency matrixes; write algorithms that allow graph exploration in either of these representations
- Define what design patterns are and how they are useful
- Satisfactorily describe and/or implement the following patterns: factory, iterator (for linear and non-linear data structures), mediator, observer, and strategy
- Detail what smart pointers are and how they address some of the perceived “problems” associated with raw pointers, with particular concern to resource ownership
- Compare and contrast std::unique_ptr, std::shared_ptr, and std::weak_ptr; std::make_unique and std::make_shared
- Implement a naive std::unique_ptr, std::shared_ptr, and/or std::weak_ptr
- Using smart pointers, implement the data structures covered in this course – including vectors, lists, trees, and graphs