Object-Oriented Programming with Java
CMSC 120 (old name: COMPSCI 121)

An introduction to object-oriented programming in Java for students with no prior programming experience. It is the first course for computer science majors at Bloomsburg University and provides a solid foundation for the more advanced software courses in the computer science curriculum.

Java is a programming language used by millions of developers worldwide to create applications for everything from mobile devices and desktop computers to large-scale distributed systems and supercomputers. The design and implementation of a software system can be a massively complex process, like building a skyscraper, with teams of developers working for years to design, code, test, debug, configure, and deploy the various components of the system. This complexity can be managed through the use of object orientation, a philosophy of programming based on the creation of abstract bundles of data and behaviors that model meaningful entities in the problem domain.

Students successfully completing the course will be able to:

• write properly documented Java code using a professional IDE.
• express object-oriented concepts using appropriate terminology.
• create and use objects defined by classes in the standard Java library.
• solve programming problems of moderate complexity using loops and arrays.
• apply general principles of good programming to write clear and modular code.

Java Cats

Graphical User Interfaces in Java
CMSC 130 (old name: COMPSCI 122)

This course continues the introduction to object-oriented programming initiated in CMSC 120, focusing on the foundational concepts of inheritance and polymorphism.

Students successfully completing the course will be able to:

• implement custom classes.
• use core collection interfaces.
• implement interfaces for event handling.
• use nested classes and lambda expressions.
• create useful new types through inheritance.
• design and implement graphical user interfaces.
• handle exceptions and perform I/O with text files.

Mobile Device Application Development
CMSC 345 (old name: COMPSCI 345)

An introduction to Java and Kotlin-based application development for the Android platform.

Students successfully completing the course will be able to:

• build, test, and debug Android applications using Android Studio.
• create responsive and visually appealing user-interfaces.
• implement application logic in Java and Kotlin.
• implement custom UI components.
• design and build apps with graphics and animation.
• design and build apps that respond to touch gestures.
• design and build apps that use hardware features such as accelerometer and camera.

Analysis of Algorithms and Data Structures
CMSC 375 (old name: COMPSCI 355)

Data structures are organized containers of information designed for efficient access and updates. This course provides a comprehensive introduction to the analysis and implementation of important data structures, and to the algorithms used in their construction and maintenance.

Students successfully completing the course will be able to:

• implement non-linear data structures as class templates in C++.
• solve problems using dynamic programming and recursive backtracking.
• determine the asymptotic complexity of iterative and recursive algorithms.
• analyze and implement standard sorting, tree balancing, and graph algorithms.
• choose correctly among different algorithms and data structures to solve a given problem.
• reason about the tradeoffs implicit in different implementations of an algorithm or data structure.

Operating Systems
CMSC 380 (old name: COMPSCI 386)

It would be practically impossible for most people to use a computer if they first had to understand the technical details of the underlying hardware. An operating system is an interface that hides those details, presenting high-level abstractions of the hardware to users and user applications. It is also a resource allocator: processes and threads have conflicting needs for access to system resources like the CPU, main memory, disk storage, and network sockets. This course examines the foundations of modern operating systems and provides practical experience with systems programming, process management, and multithreading.

Students successfully completing the course will be able to:

• design and implement a shell in C
• use pipes, filters, and I/O redirection
• write C applications using POSIX threads
• use synchronization primitives in C and Java
• implement a simple virtual memory manager
• implement standard CPU scheduling algorithms
• implement standard disk scheduling algorithms

Mathematical Thinking
MATH 101

If you have studied arithmetic and geometry in your K-12 years and decided that mathematics is uninteresting, you are in the majority. But that is like studying spelling and grammar to the point of boredom and deciding that literature is uninteresting. Spelling and grammar are important, but they tell you nothing about novels and poetry. In the same way, your early exposure to practical arithmetic and geometry was important, but it probably did not reveal to you anything about the scope and character of modern applied mathematics. That is exactly what this course is about. Mathematical thinking is explored in this course through a variety of interesting ideas from different areas of applied mathematics. For example, we learn about common voting methods and see how each can lead to paradoxical outcomes. We also study methods for the fair division of goods among parties with conflicting interests. And we discover that the movement of objects through a network can be modeled mathematically in order to investigate everything from the efficient routing of delivery trucks to the propagation of rumors through social networks.

Precalculus
MATH 113

Prepares students for success in the study of calculus. Topics include linear and quadratic relations, trigonometric functions and their graphs, trigonometric identities and equations, polynomial and rational functions, and exponential and logarithmic functions.

Internet Programming
CMSC 460 (old name: COMPSCI 461)

I taught this course in ancient times, but has been revised substantially in recent years. I no longer teach it.

Artificial Life
Honors 110

Experimental course taught for the Honors Program in 2011.

Artificial Life is an area of computer science devoted to the study of living systems through the use of computers to simulate biological phenomena. It was initiated in the late 1940s by John von Neumann, one of the giants of 20th century science and mathematics, who worked out the logical form of a self-replicating machine. One of the central ideas of Artificial Life is emergence. An emergent property of a system is a complex pattern or behavior that arises from the local interactions of autonomous components. This happens everywhere in nature: individual ants, for example, self-organize into highly sophisticated ant colonies without any external guidance or centralized control. Emergence is a common theme in biology, chemistry, ecology, economics, physics and other areas.

We experiment with a number of free and open source software packages for generating lifelike behavior in simulated populations of locally interacting components. These components may adapt, reproduce, or evolve over computer-simulated time. For example, we study the emergence of complex behaviors in Conway's Game of Life, the fight for survival among mechanical structures evolving in a virtual ecosystem, and algorithms that find solutions to computational problems by mimicking the processes of natural selection. We also survey ideas about artificial life that philosophers have considered, such as the prospect of genuine life emerging from artificial systems.

Drue Coles
Department of Mathematics, Computer Science, and Digital Forensics
Bloomsburg University of Pennsylvania