Comprehensive notes: Introduction to the Java course, structure, and core concepts

Course goals and overview

The primary goal of this Java programming course is to teach students how to read, write, test, and document Java programs. The instructor emphasizes starting from a problem description and then moving toward the practical tasks of implementation, testing, and documentation. This approach grounds the learning outcomes in real problem solving rather than isolated syntax.

Teaching team and communication

The course is led by Mansa Varshusas, Associate Professor in the Software Engineering section at ITU, who serves as the course manager and main instructor. A diverse and capable group of teaching assistants (TAs) who themselves were software designer students in this course will provide additional support. Communication with the teaching team is primarily through Microsoft Teams; instructions to join the Team channel are provided in the slides and on the course learning page. You can ask questions via Teams or contact the instructors and TAs via email. If you need a private discussion, you can schedule a private meeting with the instructor.

Course page, materials, and structure

The course page is the hub for course activities, including lectures, exercise sessions, and live coding sessions. Exercise sessions will be held in parallel with lectures, and a live coding session aims to reinforce concepts by solving problems defined in the lectures while students code along with the TA attendants. The teaching approach follows an “object-first with Java” paradigm and uses a Java course book as the core text. Students will work with code that appears in the book; projects and code from the book chapters can be downloaded via a provided link. The first mandatory activity is introduced, followed by practical exercises in the following weeks.

Book, code, and development setup

The course book adopts an object-first approach to teaching Java. The code from the book chapters is used throughout lectures, and students can download the projects via a link referenced in the course materials. For hands-on work, students will use an IDE and a Java Development Kit (JDK). The book’s examples illustrate how to translate real-world objects into Java classes and objects. In particular, students explore how to define a class (e.g., a Circle class) with fields and methods, instantiate objects from that class, and observe how object state evolves through method calls. The lecture demonstrates how, for instance, an instance circleOne can have different field values (like color, diameter, position) than circleTwo, even though both are of type Circle.

Classes, objects, fields, and types: the Circle example

A class is defined with fields that describe the characteristics of the object. For a Circle, fields might include diameter (an int), x and y positions (ints), color (a String), and a visibility flag (a boolean). The type of each field dictates what values can be stored (e.g., int for whole numbers, String for text). To create an object from a class, the syntax is typically:
ext{Circle circleOne = new Circle();}
This instantiates a new Circle object, which has its own copy of the fields. The lecture uses concrete values to illustrate: color blue, diameter 68, visible status, and a center position (e.g., x = 130). When working in an IDE like VS Code, you can set breakpoints and inspect field values as the program executes, witnessing how the object state changes as code runs. The distinction between class (the blueprint) and object (an instance) is crucial: all objects of the same class share the same fields and methods, but the values of those fields are independent across different objects.

Methods, behavior, and method signatures

Beyond fields, a class defines methods that specify an object’s behavior. For example, a Circle class might include methods like makeVisible(), changeColor(String color), and moveHorizontal(int distance). The signature of a method shows its name, its parameters, and their types. For example, a method signature might be:
ext{moveHorizontal(int distance)}
This indicates the method name moveHorizontal and a single parameter distance of type ext{int}. The method body defines the actual effect on the object’s state. When you call changeColor("red") on circleOne, the color field is updated to "red". The process of instantiation and method invocation demonstrates how object state changes while sharing the same type (Circle) across different instances.

Main method and program execution

To run a Java program, you need a main method with the standard signature. The lecture notes that the main method is typically declared as:
ext{public static void main(String[] args)}
This entry point can be placed in any class, though for clarity it is common to put it in a separate class (e.g., MyMain.java). When you run the program, the runtime looks for this main method to start execution. Within the main method, you instantiate objects and invoke methods on those objects to demonstrate their behavior. The explanation also emphasizes that the IDE handles compilation and execution behind the scenes, so you usually just press a Run button, and the IDE compiles the code and executes it if there are no compilation errors.

Types in Java: primitive vs reference and learning emphasis

The course distinguishes between primitive types (e.g., int) and reference types (e.g., Circle). Primitive types begin with lowercase letters, while reference types (class names) begin with uppercase letters. Appendix B in the course book provides a broader overview of Java types. The instructor notes that understanding types is essential and will be revisited in detail in subsequent lectures as students learn about fields, parameters, and the effects of methods on object state. A Circle type is an example of a user-defined reference type; instances like circleOne have their own state, while the class defines the shape of the state and behavior that all circles share.

Development environment choices and practical notes

Traditionally BlueJ was recommended as an introductory IDE, but the course suggests moving away from BlueJ as you progress, since it does not scale well for larger projects. The course primarily uses VS Code, though the exact IDE choice is flexible. The key point is that the IDE should provide syntax highlighting, allow running and debugging, and support basic compilation and execution. The book’s exercises are Java programs and are not tightly coupled to a specific IDE, so you can open the provided project in VS Code or another IDE and start modifying and running the code.

Project workflow and code submission policies

Assignments are submitted through CodeGrade. When you submit the first attempt, a suite of tests runs against your code and you receive immediate feedback. If all tests pass, your submission is approved. If some tests fail, you receive hints about why, and you can update and re-upload as many times as you wish before the deadline. A successful scan is indicated by a green checkmark; a failing run presents failure messages and hints to guide debugging. There is no stated limit on the number of submissions. If you cannot submit a complete solution by the deadline, you may have access to a second exam or a resubmission window (a “critical attempt” is allowed if you have at least tried). Extension opportunities exist, typically toward the next week, but the exact policy is clarified by the instructor.

The course also emphasizes academic integrity: mandatory activities do not count toward the final exam grade, but students are expected to write their own solutions. The use of large language models like a ChatGPT-style tool for coding is discouraged for the core assignments. It can be acceptable to use such tools later for high-level guidance after you have learned the underlying programming concepts yourself. The exam and midterm are designed to assess intended learning outcomes, so consistent, independent practice throughout the semester is essential to performing well.

Practice platforms and extra resources

For extra practice beyond the weekly assignments, the course encourages using the CATCHIS platform, which contains many problem descriptions and immediate feedback on solutions. It is described as a popular platform at ITU for programming practice across languages. There is also mention of CAPEX (a large platform for problems across languages) and occasional coding competitions (e.g., Fridays) that students can participate in through ITU’s channels.

Midterm, group project, and exam structure

The midterm is scheduled for Week 43, right after the fall break, on a Thursday during lecture time. The format will be announced months in advance. The midterm includes a second attempt option—if a student does not pass on the first attempt, there will be an additional opportunity about two weeks later. The final four weeks of the course are dedicated to a group project (groups of 3–4 students) focused on building a medium-sized search engine. This project is intended to mirror real-world collaboration in a team setting. Submissions for the project occur four weeks after the last lecture. If the project is not passed, a second attempt is offered, though the timeline is tight to avoid delaying the final exam.

To be eligible for the January exam, students must pass the three mandatory activities: the weekly assignments, the midterm, and the group project. If a student fails any mandatory activity, the instructor may arrange a replacement activity or other remedies, depending on the specific situation and the nature of the failure (e.g., whether the entire group or an individual member failed). The policy is designed to preserve fairness while ensuring that students still reach the required learning outcomes. The overall time commitment is estimated at about 23 hours per week, with roughly 10 hours of that time scheduled by course activities (lectures, exercises, and live coding). The current plan also contemplates a possible use of bar spool for the midterm, though this is not part of the mandatory activities at present.

Intended learning outcomes and why they matter

ITU courses define intended learning outcomes (ILOs) that articulate the competencies students should have after completing the course. These outcomes are described in the course description and explain the purpose of the course: to enable you to apply Java programming skills to real problems, produce well-structured and maintainable code, and work effectively in a software development lifecycle. The emphasis on object-oriented design, modularity, testing, and documentation aligns with industry practices and prepares students for subsequent coursework and real-world software development.

Java fundamentals recap and significance

Java is presented as an object-oriented, high-level language with a syntax designed to be easy to learn and read. It is platform-independent, meaning Java programs can run on any machine with a compatible JDK and runtime environment. Java originated in 1991 (initially under a different name, with “O” as an early name). In this course, Java 11 and later versions (e.g., 11 and 17) are considered compatible with the concepts taught, though the exact version used for the project may vary and students should be prepared to switch versions if required.

Practical implications for students

The course emphasizes: building a foundational understanding of objects, classes, fields, and methods; recognizing how to instantiate objects and call methods to change state; understanding how a program is executed from main; using an IDE for productive development; and practicing with a structured workflow that mirrors real-world software development. Students are encouraged to engage with the live coding sessions, make use of the course book’s code, explore the Circle example in practical detail (and similar class examples), and gradually internalize best practices around place of main, type safety, and method signatures. The overall objective is to reach the intended learning outcomes through consistent practice with assignments, live coding, and project work.

Practical wrap-up and next steps

The first lecture closes with reminders about the exercise sessions (today from 12:00 to 14:00, subject to room availability) and encourages students to seek help from TAs in those rooms for setup issues (e.g., installing VS Code, Java). The instructor signs off with the expectation that students will engage with the first assignment and participate actively in the live coding and exercise sessions. The session ends with a reminder to check the course page for the next steps and resources.