ITSE-1329 · Fall 2026

Programming Logic and Design

Instructor: Francisco I. Rodriguez · Email: firodriguez@DallasCollege.edu

Course Information

Problem-solving applying structured techniques and representation of algorithms using design tools. Includes an introduction to programming, testing, evaluation, and documentation. All programming examples and exercises in this class will use the Kotlin programming language, guided by the textbook Atomic Kotlin.

Note on Meeting Times & Locations: Specific hours and campus locations are currently being finalized by the Dallas School District. Francisco will share this information once it is confirmed.

Dallas College Fall 2026 Academic Calendar

Event	Date	Notes
Classes Begin	Monday, August 24, 2026	Semester officially starts.
Labor Day Holiday	Monday, September 7, 2026	College closed (No classes).
Thanksgiving Break	Nov 26 – Nov 29, 2026	College closed (No classes).
Final Exams & Classes End	Thursday, December 10, 2026	Final programming tests due.

Fall 2026 Weekly Course Outline

Week	Dates	Topics & Chapter Readings (Atomic Kotlin)	Assignments & Deadlines
Week 1	08/24 - 08/30	Welcome & Course Overview, Setup IntelliJ & Atomic Kotlin	Discussion Board & Setup (Due 08/30)
Week 2	08/31 - 09/06	Programming Basics: Intro, Why Kotlin?, Hello, World!	Discussion Board (Due 09/06)
Week 3	09/07 - 09/13	Variables (`var`/`val`) & Basic Data Types (Labor Day 09/07)	Discussion Board, Quiz #1 (Due 09/13)
Week 4	09/14 - 09/20	Functions, `if` Expressions	Discussion Board, Coding Lab #1 (Due 09/20)
Week 5	09/21 - 09/27	String Templates, Number Types	Discussion Board, Quiz #2 (Due 09/27)
Week 6	09/28 - 10/04	Booleans, Repetition with `while` loops	Quiz #3, Coding Lab #2 (Due 10/04)
Week 7	10/05 - 10/11	Looping and Ranges, The `in` keyword	Discussion Board (Due 10/11)
Week 8	10/12 - 10/18	Expressions and Statements	Quiz #4, Programming Test #1 (Due 10/18)
Week 9	10/19 - 10/25	Section II: Objects - Objects Everywhere, Creating Classes	Discussion Board (Due 10/25)
Week 10	10/26 - 11/01	Properties, Constructors	Quiz #5, Coding Lab #3 (Due 11/01)
Week 11	11/02 - 11/08	Constraining Visibility, Packages	Discussion Board (Due 11/08)
Week 12	11/09 - 11/15	Testing, Exceptions	Quiz #6, Programming Test #2 (Due 11/15)
Week 13	11/16 - 11/22	Lists, Variable Argument Lists	Discussion Board (Due 11/22)
Week 14	11/23 - 11/29	Sets, Maps (Thanksgiving Holiday 11/26 - 11/29)	Quiz #7, Coding Lab #4 (Due 11/29)
Week 15	11/30 - 12/06	Property Accessors	Coding Lab #5 (Due 12/06)
Week 16	12/07 - 12/10	Final Wrap-Up & Exams Week	Programming Test Final (Due 12/10)

Section I: Basics
Week 2: Hello, World!
Week 3: var/val & Types
Week 4: Functions & if
Week 5: String & Numbers
Week 6: Booleans & while
Week 7: Loops & Ranges
Week 8: Expressions
Section II: Objects
Week 9: Objects & Classes
Week 10: Properties
Week 11: Visibility & Packages
Week 12: Testing & Exceptions
Week 13: Lists & Varargs
Week 14: Sets & Maps
Week 15: Accessors

Week 2: Introduction & Hello World

Welcome to Kotlin! In this lesson, we write our first Kotlin program. The main function is the entry point of every Kotlin application. Code statements are written inside the function block { ... }.

Key Concepts

fun: Keyword used to declare functions.
println(): Built-in function to print text output to the screen, followed by a new line.
No Semicolons: Unlike Java or C++, semicolons are optional in Kotlin and generally omitted.

Code Playground

Modify the name in the print statement and click Run to test your changes!

fun main() { println("Hello, World!") println("Welcome to ITSE-1329!") }

Week 3: var, val, and Data Types

Kotlin variables are declared using either var (mutable/modifiable) or val (read-only/immutable). It is highly recommended to use val by default to prevent unexpected changes.

Key Concepts

var: Mutable variable. Its value can change over time.
val: Immutable variable. Once assigned, its value cannot be re-assigned.
Type Inference: Kotlin automatically determines the type (e.g. Int, String, Boolean) based on the assigned value.

Code Playground

fun main() { val course = "ITSE-1329" var score = 95 // Assigning a new value to var score = 100 // Uncommenting the line below will cause a compile error because 'course' is val // course = "ITSE-1301" println("Course: $course") println("Score: $score") }

Week 4: Functions & if Expressions

Functions allow you to reuse blocks of code. if in Kotlin is an expression, meaning it returns a value that can be assigned directly to a variable.

Key Concepts

Parameters: Inputs must specify their types (e.g. a: Int).
Return Type: Declared after a colon following the parameters list (e.g. : Int).
If-Expression: In Kotlin, there is no ternary operator (a ? b : c). We use if (a) b else c instead.

Code Playground

// Function definition fun getMax(a: Int, b: Int): Int { return if (a > b) a else b } fun main() { val x = 42 val y = 27 val maxVal = getMax(x, y) println("The maximum value of $x and $y is $maxVal") }

Week 5: String Templates & Number Types

Kotlin supports complex numeric operations and string templates to build dynamic text combinations easily.

Key Concepts

String Templates: Use $variableName or ${expression} inside double-quotes.
Numbers: Integrals are Int, Long, Short, Byte. Decimals are Double and Float.

Code Playground

fun main() { val pi = 3.14159 val radius = 5.0 val area = pi * radius * radius println("Radius: $radius") println("Area of circle: ${String.format("%.2f", area)}") }

Week 6: Booleans & Repetition with while

Booleans control program flow. The while loop repeatedly executes a block of code as long as its boolean condition remains true.

Key Concepts

Boolean operators: && (AND), || (OR), ! (NOT).
while loop: Evaluates condition first, then runs block.

Code Playground

fun main() { var count = 5 println("Launching loop...") while (count > 0) { println("Count = $count") count-- } println("Loop completed!") }

Week 7: Looping and Ranges

Ranges allow you to define sequences of values. The for loop iterates over loops, ranges, and collections. The in keyword checks if a range contains a value.

Key Concepts

Range formats: 1..5 (1 to 5 inclusive), 1 until 5 (1 to 4), 5 downTo 1 (descending).
in: Checks memberships, returns Boolean.

Code Playground

fun main() { println("Counting up:") for (i in 1..4) { print("$i ") } println("\nMembership check:") val check = 10 in 1..20 println("Is 10 in 1..20? $check") }

Week 8: Expressions and Statements

An **expression** evaluates to a value. A **statement** does not produce a value and exists only for its side-effects.

Key Concepts

Almost everything in Kotlin (e.g. if, try, when) is an expression.
Saves verbose boilerplate code compared to older languages.

Code Playground

fun main() { // 'if' expression evaluates to String and assigns it val isEven = if (10 % 2 == 0) "Even" else "Odd" println("Number 10 is $isEven") }

Week 9: Objects Everywhere & Creating Classes

Kotlin is an Object-Oriented language. A class is a blueprint for creating objects. Objects bundle state (data) and behavior (functions).

Key Concepts

Class Declaration: Declared using the class keyword.
Instantiation: Create objects by calling the class name like a function (no new keyword required).

Code Playground

class Dog { fun speak(): String { return "Woof!" } } fun main() { val myDog = Dog() // Create object println("The dog says: ${myDog.speak()}") }

Week 10: Properties & Constructors

Constructors initialize objects. Fields inside classes are called **properties** and automatically generate getters and setters.

Key Concepts

Primary Constructor: Defined directly in the class header.
Properties: Defined in the header with val or var.

Code Playground

class Student(val name: String, var grade: Int) fun main() { val student = Student("Francisco", 98) println("Student: ${student.name}, Grade: ${student.grade}") // Modify grade property student.grade = 100 println("Updated Grade: ${student.grade}") }

Week 11: Constraining Visibility & Packages

Visibility modifiers control who can access your classes, methods, and properties. Packages group related classes together.

Key Concepts

public: Default. Accessible anywhere.
private: Accessible only inside the class/file.
protected: Visible in subclasses.
internal: Visible inside the same compile module.

Code Playground

class BankAccount(private var balance: Double) { fun deposit(amount: Double) { if (amount > 0) balance += amount } fun getBalance(): Double = balance } fun main() { val account = BankAccount(100.0) account.deposit(50.0) // Uncommenting next line fails because balance is private // account.balance = 1000000.0 println("Balance: $${account.getBalance()}") }

Week 12: Testing & Exceptions

Kotlin handles runtime errors using Exceptions. Use try, catch, and finally blocks to manage exceptions gracefully.

Key Concepts

throw: Fires an exception.
try-catch: Catches a specific error type to prevent crashes.

Code Playground

fun checkAge(age: Int) { if (age < 18) throw IllegalArgumentException("Underage student!") } fun main() { try { checkAge(15) } catch (e: IllegalArgumentException) { println("Caught error: ${e.message}") } finally { println("Validation check complete.") } }

Week 13: Lists & Varargs

Lists represent ordered collections of items. Kotlin separates them into read-only and mutable lists.

Key Concepts

listOf(): Creates a read-only list.
mutableListOf(): Creates a modifiable list.
vararg: Allows passing a variable number of arguments to a function.

Code Playground

fun printAll(vararg words: String) { for (w in words) print("$w ") println() } fun main() { val fruits = mutableListOf("Apple", "Banana") fruits.add("Cherry") println("Fruits: $fruits") printAll("Kotlin", "is", "awesome!") }

Week 14: Sets & Maps

Sets store unique elements. Maps link key-value pairs.

Key Concepts

Set: Duplicate items are ignored.
Map: Keys are unique. Value retrieval is quick.

Code Playground

fun main() { val letters = setOf("A", "B", "A", "C") println("Unique letters (Set): $letters") // Duplicates removed val scores = mapOf("Alice" to 95, "Bob" to 88) println("Alice scored: ${scores["Alice"]}") }

Week 15: Property Accessors

Properties can have custom getter and setter functions to dynamically compute values or intercept modifications.

Key Concepts

get(): Triggered when reading the property.
set(): Triggered when assigning to the property. Use field to access the backing store.

Code Playground

class Temperature(var celsius: Double) { val fahrenheit: Double get() = celsius * 9 / 5 + 32 } fun main() { val temp = Temperature(25.0) println("25.0°C in Fahrenheit is: ${temp.fahrenheit}°F") }

Kotlin Programming Sandbox

This is a blank compiler workspace. You can write your custom code templates or solve the programming exercises below. Use the drop-down to load boilerplate code for specific Coding Lab assignments.

Select Assignment Template:

fun main() { println("Kotlin sandbox ready!") // Write your code here }

ITSE-1329 Programming Exercises (Coding Labs) Outline

Coding Lab 1: Functions & Ifs (Week 4)

Goal: Implement a grading helper function using an if expression that translates numeric grades to letter grades.

A grade of 90-100 returns "A"
A grade of 80-89 returns "B"
A grade of 70-79 returns "C"
Anything else returns "F"

Coding Lab 2: Repetition with While (Week 6)

Goal: Write a program that takes a positive integer and prints a countdown to 1, followed by "Blastoff!", using a while loop.

Coding Lab 3: Properties & Constructors (Week 10)

Goal: Create a class Product with a primary constructor specifying name (immutable String) and price (mutable Double). Instantiate several products and print their details.

Coding Lab 4: Sets & Maps (Week 14)

Goal: Write a function that counts word frequencies in a given list of strings, returning a map containing word keys and their integer count values.

Coding Lab 5: Property Accessors (Week 15)

Goal: Build a class representing a Rectangle with width and height properties. Implement a custom property accessor getter for area that calculates and returns width * height.