Professor Tainã Coleman • taina.coleman[at]lmu.edu • Fall 2026
CMSI 2120 is a 4-Unit intermediate-level programming class that teaches students how to craft efficient and space-conscientious applications by analyzing and then choosing the “right” data organization for a task. Although Java is the course’s language of focus, students will learn core concepts that permeate all programming languages, as well as language-agnostic tools to analyze and think deeply about implemented algorithms.
Learning Outcomes
By the course’s end, students will:
- gain experience with an enterprise programming language (Java), advanced topics in object-oriented programming, and software development best practices, logistics, and test-driven development.
- understand analytic programming concepts such as asymptotics, time-complexity, and space-complexity — that not all programs are created equal; two programs that perform the same task may not do so with the same efficiency or cleanliness.
- be introduced to a wide range of Data Structures and Abstract Data Types (ADTs), learning which are best suited for which tasks, including: lists, stacks, queues, heaps, priority queues, hash tables, sets, maps, trees, search trees, tries, and graphs.
- gain a deeper understanding of class hierarchies and inheritance, object-oriented programming, and both implementing and applying data structures programmatically.
- learn the interfaces for popular Java collections, and how to use them in a variety of non-trivial programming tasks.
- identify beneficial and detrimental interactions between ADTs and algorithms that operate with them.
Prerequisites
Prerequisites
Before taking this course, you must have strong foundations in the fundamentals of programming (CMSI 185).
This class uses Java for its concrete examples, homework, and exams. We will spend the first few weeks of the course covering the Java necessary to succeed in the course and beyond, though we will not dwell on basics like how or when to use iteration or conditionals.
If you require additional practice, you may learn through our textbook (see next section) and any number of online tutorials — a list of which can be found on this LMU CMSI resources page.
Git and GitHub
Additionally, you should be comfortable with the fundamentals of Git, and managing GitHub repositories.
We will be using GitHub Classroom for assignment distribution and collection, so advance comfort with these tools will make your life easy.
Need a refresher? Take a look at the GitHub Tutorials here.
Texts
We will be “using” two optional textbooks for the course, which will primarily cover or dive deeper into the theoretical material than we have the time to during lecture:
Although these specific texts are not mandatory for the course, they contain all concepts that we will be covering in great detail, and your exams will expect that you deeply understand these concepts.
These are also popular textbooks with many editions; any edition will likely match what we cover in the course, so you may purchase whichever you like (if any).
Additionally, I will provide abbreviated course notes for our lectures on my course page (see Notes tab)
Resources will be provided throughout the course detailing any additional topics that are not sufficiently contained in the above text. These resources will be free and publicly available.
Lecture Attendance
Although not mandatory, lecture attendance is strongly advised since you’ll be missing out on lecture content that will not be posted online, classwork (see below), and hints for homework and exams. If you miss a lecture, the important points will be sketched in our course notes posted on this site’s Notes tab.
Lectures are participatory in nature, often with exercises and group-work to facilitate learning. Laptops are discouraged for note-taking, but encouraged for working on in-class problems.
Workload Expectations
As this is a 4-Unit class, it is expected that you will be allocating an average of 9 hours outside of lectures per week working on course assignments, reading, and studying. Some weeks will have less material to keep you busy, and others more, but be aware that this is a work-intensive course that may require you to spend a lot of time programming!
Slack Messaging
Alongside email exchanges, you may reach me via the Slack messaging service (Slack is a chat client that can be downloaded here) in the LMUCS channel (lmucs.slack.com).
Office Hours
- Tuesdays: 10:30am - 11:30am - Zoom: https://ucsd.zoom.us/j/92613916049?from=addon
- Thursdays: 3:30 pm - 4:30pm - DOO 210
- By appointment for other times (contact me via email or Slack)
Attending on Zoom
Please message me on email or Slack to let me know you are attending office hours on Zoom.
Tentative Schedule of Topics
The following constitutes the tentative schedule for topics to be covered in the course. This is largely an approximation for what we will cover each lecture, and is subject to change.
Exam Topics
Exam topics may differ from this schedule; see the Materials tab of our course site for each exam’s stated topics.
Assignment Deadlines
Homework deadlines are not listed on this page as they are sensitive to the pace of the lectures — see the Homework tab on the main course page for these. Classwork dates are listed under Assignments & Grading below.
| Item | Date | Topic |
|---|---|---|
| Lecture 1-1 | Tue Sep 1 | Course introduction, Java vs. Python, development environment setup |
| Lecture 1-2 | Thu Sep 3 | Primitives, arrays, and Strings |
| Lecture 2-1 | Tue Sep 8 | Control flow, method design, and test-driven development |
| Lecture 2-2 | Thu Sep 10 | Unit testing with JUnit: assertions, fixtures, and finding edge cases |
| Lecture 3-1 | Tue Sep 15 | Java class design and object-oriented programming |
| Lecture 3-2 | Thu Sep 17 | Inheritance, overriding, and the Object superclass |
| Lecture 4-1 | Tue Sep 22 | Abstract classes, interfaces, polymorphism, and access modifiers |
| Lecture 4-2 | Thu Sep 24 | Memory architecture: stack vs. heap, references, and garbage collection |
| Lecture 5-1 | Tue Sep 29 | ArrayLists: dynamic arrays, implementation, and the debugger |
| Lecture 5-2 | Thu Oct 1 | Abstract Data Types vs. data structures; generics and the Java Collections Framework |
| Lecture 6-1 | Tue Oct 6 | Linked lists, nodes, and iterators |
| Lecture 6-2 | Thu Oct 8 | Stacks and queues |
| Lecture 7-1 | Tue Oct 13 | Exam I review |
| Lecture 7-2 | Thu Oct 15 | Exam I |
| Lecture 8-1 | Tue Oct 20 | Asymptotics: total cost functions, big-O notation, runtime analysis |
| Lecture 8-2 | Thu Oct 22 | Analysis practice: complexity of list, stack, and queue operations |
| Lecture 9-1 | Tue Oct 27 | Sorting and searching: analyzing the classic algorithms |
| Lecture 9-2 | Thu Oct 29 | Trees I: vocabulary, structure, n-ary trees, and traversals |
| Lecture 10-1 | Tue Nov 3 | Trees II: binary search trees, insertion, search, and balance |
| Lecture 10-2 | Thu Nov 5 | Tries and ternary search trees |
| Lecture 11-1 | Tue Nov 10 | Graphs: properties, node-based vs. adjacency map representations |
| Lecture 11-2 | Thu Nov 12 | Graph traversals: breadth-first, depth-first, and applications |
| Lecture 12-1 | Tue Nov 17 | Heaps and priority queues: structure, insertion, removal, re-heapifying |
| Lecture 12-2 | Thu Nov 19 | HeapSort and PriorityQueue applications |
| Lecture 13 | Tue Nov 24 | Hash tables: hash functions, collisions, load factor, and rehashing |
| No class — Thanksgiving Holiday | ||
| Lecture 14-1 | Tue Dec 1 | Maps and Sets: Entries, HashMaps, HashSets, and TreeSets |
| Lecture 14-2 | Thu Dec 3 | Choosing the right structure: a tour of the Java Collections Framework |
| Lecture 15-1 | Tue Dec 8 | Catch-up and a look ahead at advanced topics |
| Lecture 15-2 | Thu Dec 10 | Exam II review |
| Final | See the LMU Final Exam Schedule | Exam II (non-cumulative) |
Assignments & Grading
Grade Decomposition
Grades will be assigned based on the following weighted coursework:
- [25%] Classwork: Small classwork assignments will be given throughout each week, with in-class time allocated for their completion. Though you will have the opportunity to finish these in groups and with my assistance during class, you are not required to attend lectures, and so may submit these electronically by their listed due dates. Your lowest classwork grade will be dropped.
- [45%] Homework: Larger assignments with heavy coding required. Programming style and comments are graded as well. All homework assignments are weighted equally. Expect roughly 5-6 assignments in total, apportioned once every ~2.5 weeks. Your lowest homework grade will be dropped.
- [30%] Exams: There will be 2 exams (a midterm and final). Your best exam score will constitute 2/3 of the exam grade, with your worse score constituting the remaining 1/3. For example, if your 2 exam scores were 60 and 90, then your weighted exam score for the course will be 80.0 (= 60*(1/3) + 90*(2/3))
Classwork Schedule
Each classwork is introduced in the lecture that covers the material it needs, with in-class time set aside to start it, and is then due at 11:59 PM one week later. Bonus classworks are optional and add points to a Homework grade rather than to your classwork average.
| Classwork | Assigned | Due (11:59 PM) |
|---|---|---|
| Classwork 1 | Tue Sep 1 | Tue Sep 8 |
| Classwork 2 | Thu Sep 10 | Thu Sep 17 |
| Classwork 3 | Thu Sep 17 | Thu Sep 24 |
| Classwork 4 | Tue Sep 29 | Tue Oct 6 |
| Classwork 5 [Bonus] | Thu Oct 8 | Tue Oct 13 |
| Classwork 6 | Tue Nov 3 | Tue Nov 10 |
| Classwork 7 [Bonus] | Tue Dec 1 | Tue Dec 8 |
Classwork 5's shortened window
Classwork 5 is due on the Tuesday before Exam I rather than a full week out, so that graded work and solutions are back in your hands in time to study from them.
If we fall behind
These dates follow the tentative schedule above and shift with it. If we do not reach a classwork on the date listed, its deadline slides accordingly and the Classwork page is updated — that page is always the authoritative one.
Final Grades
Final letter grades are given based on the university scale of grade percentages:
- A: 93 - 100
- A-: 90 - 92
- B+: 86 - 89
- B: 83 - 85
- B-: 80 - 82
- C+: 76 - 79
- C: 73 - 75
- C-: 70 - 72
- D: 65 - 69
- F: 64 and below
Fractional grade percentages at 0.5 or over will be rounded up, so an 89.5% will be considered a 90% (A-), but an 89.4% will be considered an 89% (B+) on the above scale.
That said, these are only the guaranteed grade assignments: if your “final” grade is an 82%, you are guaranteed a B- or better, but you might still get an A if 82% is the top score.
Extra Credit
Extra credit opportunities will be sporadically available during lectures / exams; if you are present and can hand in an attempt at the extra credit opportunities, you will receive bonus points!
If you receive all extra credit opportunities, you can gain a maximum +2% on your final grade. These bonuses are applied post-curve, so no student will be punished for not attending lectures relative to their peers.
Submission Standards
Each of your submitted homeworks and projects are subject to the following constraints:
-
Assignment posting: all assignments (classwork, homework, or otherwise) will be announced in class and posted on this site with due dates. You are responsible for checking this site / your email for any updates to assignments and their associated deadlines.
-
Late Policy: assignments are due at exactly the time indicated by the method specified. Assignments that are late will not be considered for grading. There are no exceptions to this rule.
-
Individual Work: students are encouraged to talk and think about problems in groups, but each submission should be their own, containing no code that has been copy-pasted from another student. We take plagiarism very seriously, and each submission will be run through a similarity-checking mechanism to ensure fairness. Code or homework which we believe to be shared innapropriately between students or copied from the internet is subject to severe disciplinary action (not that you would, just sayin’). The following are examples of unacceptable behavior in this course:
If you plan to copy anything from the internet, ask first!
- Copying non-trivial amounts of code from the internet into an assignment (excluding small things from StackOverflow like how to use Java Streams to simplify some code).
- Copying another group’s solutions on a classwork exercise (sharing between group members is encouraged… that’s what it means to… you know… group up).
-
Style: assignments which are sloppily submitted without proper formatting, style, and comments are subject to penalties. We will discuss what constitutes such offenses in class, though you should be familiar with clean coding standards from your introductory courses.
-
Development Environment: I will be using IntelliJ IDEA for in-class demonstration; for your work, you are free to use whatever development environment you wish, and the class will not force you to choose one or another, though at minimum you are expected to be able to develop iteratively using JUnit tests and GitHub Classroom for your version control.
Academic Integrity
Students are encouraged to talk and think about problems in groups, but each submission should be their own, containing no code that has been copy-pasted from another student. No matter who you got help from, by the time you submit your assignment you should be able to explain every line of code in your submission! We take plagiarism very seriously, and each submission will be run through a similarity-checking tool. We are very methodical about reporting academic honesty violations and do not hesitate to escalate any suspected cases through official university channels.
Danger
All forms of plagiarism will result in severe disciplinary action.
The following are examples (not a comprehensive list!) of unacceptable behavior in this course:
- Copying non-trivial amounts of code from ANY other source into an assignment (excluding small things from StackOverflow like how to use list comprehension to simplify some code). This includes code found on the internet or through the use of a generative AI model like ChatGPT.
- Copying code from another student’s submission.
- Copying another student’s solutions on a classwork exercise.
- Re-using or copying work or solution sets from a previous semester, even if it is your own work from when you previously took the course.
Danger
If you plan to copy anything from the internet, ask first!
On Responsible AI usage
Academic honesty includes the appropriate use of technology as an aid for learning and productivity. This includes but is not limited to LLM-based generative artificial intelligence tools such as Claude, ChatGPT, Gemini, and Copilot.
Modern GenAI provides fast solutions to a variety of computing problems but must be used responsibly to get the most out of your education. GenAI will not always be helpful, especially when asked to write code for scenarios it cannot recognize. It cannot independently validate the code that it produces, and will frequently produce bugs and security vulnerabilities, making things worse for you. It will not be available for job interviews. As a student and future software professional, you have a moral and ethical responsibility to deeply understand every line of the software you author and should therefore employ GenAI in your coursework sparingly, especially when its use might rob you of the stretch-zone learning that comes from crafting programs on your own.
That said, there are several acceptable use cases of GenAI in programmatic assignments, including:
- Generating short documentation strings and type hints.
- Finding examples and explanations for syntactic forms [e.g., how to use the spread operator; how to assign variables directly from an array or object; how to construct a dictionary comprehension; how to unwrap an optional, and so on]. Prompt the AI for the how-to’s, not your final code.
- Interpreting error messages, as these might be pretty cryptic! Sometimes the AI can be a useful tutor when explaining things it is familiar with.
- Generating unit tests for edge cases. When it finds something you overlooked, make a mental or written note so you can find these cases on your own next time.
- Brainstorming new ideas for applications.
Warning
Remember your four As: you MAY use technologies such as GenAI to Augment ✅, Amplify ✅ and Accelerate ✅ your learning; NEVER use technology to Avoid ❌ learning.
Danger
If you DO use GenAI for any of your work, that must be indicated somewhere in your documentation with an AI use disclosure: “This portion of the work was developed with assistance from [tool and version, e.g., Claude Opus 4.5]. I used it to [briefly describe the task: e.g., generate an initial implementation of the sorting module, draft this section of the design document, debug the authentication flow]. I have reviewed, tested, and understand all AI-generated content included here, and I take full responsibility for its correctness and its fit with the rest of the project.”
Text authored by Dr. Johnson (Thank you!)
Resources
Student Rights and Responsibilities
Just as I have certain expectations of you in this course, you may have certain expectations of me. Here is a high-level list of each:
My Responsibilities
- Provide you with an educational experience superior to that which could be gleaned from a textbook or online source alone.
- Answer your questions and curiosities in office hours, over Slack, and via email with a turnaround of at most 36 hours.
- Give you feedback on your submissions and individualized instruction on how to maximize your gain from this class.
Your Responsibilities
- Be responsible with use of your time, class time, office hours, email, and the Keck Lab TAs. Last minute pleas for help on assignments or exams are the opposite of this.
- Be respectful of classmates.
- Don’t cheat or plagiarize on exams or assignments.
Tips for Success in this Class
Here are a few tips for succeeding in this class (and college, in general); they’re not meant to sound patronizing, but rather, are simply pearls of wisdom to hand down from someone who has recently trodden your path!
- Ask questions: if there is one piece of advice I can impart unto you, it’s to ask questions when you have them. Chances are good that if you have a question, someone else has the same one, you won’t be left behind wondering about something that was covered minutes ago (and which future material might employ), and I promise not to judge you for whatever you ask (well, not too hard at least). At the very least, if you have a question, write it down and then ask it on Slack after class (which can be done anonymously if you so please). The heart of academic inquiry is just that: inquiry!
- Fear not the specter of error: in college classes, there tends to be a crippling aversion to being wrong, especially publicly! I’m here to tell you that there is no better time to be wrong than in class, particularly in one as interactive as ours. There are a variety of silver-linings to being wrong: you won’t forget what you were wrong about (one fewer thing to cram for later), it’s better to learn from being wrong when it doesn’t matter (i.e., in discussion) than when it does (i.e., on a test or during an interview), and I will respect you for your courage. There is only one circumstance in which you should fear error: when you fail to learn from it (at which point, see tip above for remedy).
- Indulge your curiosity: and no, that’s not some tagline stolen from a Vegas day-spa (actually, it might be, don’t quote me on that), but the wisdom is sound… in class, we will cover a variety of topics with accompanying exercises that highlight the main take-away messages of the lesson, but that does not mean that your learning should stop there. Indeed, computer science is one of those beautiful disciplines wherein experimentation and exploration are so trivially entertained. Curious about what would happen if you changed the value of a variable? Do it! Curious about what other methods exist for certain data types? Google them! There is no reason why your learning should be constrained to what I (strategically) offer you; we have only limited time in class, and I’ll prioritize the most important topics, but your interests can spread their own wings. Go forth and explore!
University Resources
Here are some LMU links for University Resources that might be of interest:
- Academic Degree Requirements and Policies: Pay particular attention to honor code and process.
- Disability Support Services (DSS)
- Student Codes and Policies
- Academic Resource and Learning Center
- Computer Science Department