CSS Elective Course Descriptions

Main page content

Computer Science and Systems Elective Course Descriptions

TCSS 430 - Networking and Distributed Systems
Computer networks are behind many of the recent technological revolutions, particularly the Internet. In this course you will learn how to design and analyze computer networks. You will learn how the Internet is organized and how it works, what are its limitations, bottlenecks and possible future developments.

You will be introduced to the layered architecture for studying computer networks and the TCP/IP stack of protocols. The topics covered include: the most common application level protocols (HTTP,FTP, SMTP, etc), transport layer protocols, error control, congestion and flow control, routing, link layer protocols, wireless networks, multimedia, network security and network management. The course will also deal with computer network application development (socket programming) and network simulations.

TCSS 431 - Network Security
This course introduces cryptographic methods and security protocols. In this course, students will learn how public and private key algorithms work, and how cryptographic protocols are used in real world applications. Topics covered include cryptographic algorithms (e.g. 3DES, AES, RSA, SHA), authentication protocols (e.g., Kerberos and X.509), e-mail security (e.g., PGP and S/MIME), web security, intrusion detection, and firewalls. Students will conduct hands-on labs on Internet traffic analysis to understand network threats, vulnerabilities, attacks, and defense techniques.
TCSS 435 - Artificial Intelligence and Knowledge Acquisition
The field of artificial intelligence is concerned with replicating intelligent behavior. The behavior may be very narrow in scope, such as playing Chess, or combine many subtasks, such as autonomous vehicle control. This course explores the combination of perception, reasoning, and action that underlays mechanical intelligence. Students are introduced to a variety of A.I. techniques, e.g., search, symbolic reasoning, genetic algorithms, artificial neural networks, and decision trees. This course emphasizes computational problem solving, which integrates computational modeling, data structures, and algorithms. These techniques are applied to a variety of problems, e.g., planning, game-playing, and prediction, across a number of small programs that students will develop.
TCSS 437 - Mobile Robotics
This course is an introduction to mobile autonomous robots and is focused primarily on the development of algorithms for behavior control. The course does not focus on the mechanical or electronic aspects of robots although some material related to those concepts is presented. In this course students work in small groups to construct robots from kits and program those robots to demonstrate sophisticated behaviors. The course introduces pertinent principles from artificial intelligence and embedded real-time systems.

 

The prerequisites are: TCSS 422. The operating systems course provides an introduction to the concept of concurrency. The robotics course will expand upon this basic understanding. TCSS 360. This course provides practical experience working on software development in small groups. All projects in the robotics course are done in small groups.

Other courses which could help to build a good foundation prior to TCSS 437 are Embedded Systems and Artificial Intelligence. These courses are not required prerequisites; however, student who do have this background will be able to use that background in the robotics course.

Topics covered / aspects of the course • principles of behavior-based robotics and autonomous agents • real-time motor control, real-time signal processing (from noisy sensor input) • options for the physical design of mobile robotics (wheels, tracks, legs, other options) • deliberative control versus reactive control systems • schemes for arbitration among multiple concurrent behaviors • concepts relevant to robotic navigation (mapping, localization, obstacle avoidance, etc.) • concepts of intelligent behavior applied to robots • creative problem solving in teamsTCSS 440: Formal Models in Computer Scienc

TCSS 440 - Formal Models in Computer Science
This course is a course in the classic theory of computation. The overall goal of the course is to introduce students to the idea of formalizing computational processes and reasoning about them through mathematical methods such as precise definition and proof. Students will apply their discrete mathematics skills in sets, logic, and proof techniques. Methods of reasoning about formal models introduced in this class include simulation, diagonalization, and reduction.

 

There are three sections of the course, and each section builds on and is more complicated than the previous. The first part discusses deterministic finite automata, nondeterministic finite automata, and regular expressions. The second part discusses context-free grammars and pushdown automata. The third part discusses Turing machines, decidability, reduction, and NP-completeness. These different models represent different classes of computational complexity. Students will learn about these models and reason about them.

Because the ideas in this course were fundamental in the development of the computer, applications of these ideas include hardware design, natural language processing, compiler design, and software verification, although this class will not directly address those areas.

====

A strong background in discrete mathematics is needed for this course (data structures and machine organization is helpful, too), and an interest in the mathematical ideas behind the modern computer is certainly helpful. The prerequisite is TCSS 342 (data structures).

TCSS 450 - Mobile Application Programming
Mobile application programming covers application lifecycle, user interfaces, data management, using web services, locations, graphics, and localization focusing on Android devices with some discussion on other platforms. In this course, students propose their own project that meets the different criteria provided by the instructor and develop an app in two phases using software engineering methodologies. 1) Write use cases and design class diagrams 2) Use version control system in a collaborative environment (Git) 3) Java coding conventions and Documentation 4) Testing the apps and using JUnit as well as Automated test tools for Mobile apps 5) Present the final app in class (In person or Video capture)
TCSS 452 - Human Computer Interaction
Interaction design concerns the deliberate shaping of digital tools for use by people to satisfy their needs. Because these tools exist within social settings, they become resources from which people construct their social, political, economic, and moral lives. In this course, we will do interaction design, we will be interaction designers. The basic activities of this enterprise will involve understanding users’ needs, sketching, making design tradeoffs, choosing from among design alternatives, representing, communicating, and critiquing designs, prototyping, usability testing, and reflecting on design activity. More than anything else, undertaking these activities means cultivating the ability to envision. We will envision the design of technologies that do not yet exist but, if realized, will result in net benefits for the people affected.
TCSS 458 - Computer Graphics
This course presents software-based techniques for image creation. Whereas a camera uses light coming from real objects to produce an image, a computer graphics system uses geometrical descriptions of imaginary objects to produce images. These images are more or less photo-realistic (similar to what a camera would produce) but since the objects appearing in them depend only on mathematical descriptions, computer graphics offers creative possibilities that go far beyond a conventional camera. Before you use a computer graphics system to visualize the world, you first have the opportunity to create that world. This involves assembling geometric shapes (e.g. triangles) by magnifying, rotating, and moving them to desired locations. The "picture producing" part of the graphics system (called a renderer) takes this complex description and produces the thousands of colored dots (pixels) that together make up an image. The creation of an image is partly inspired by how light behaves in the real world, therefore a renderer does many geometric calculations that compute the appearance of an object viewed at a particular angle from a given location. These calculations involve some trigonometry and are usually described as a series of matrix operations. In some ways computer graphics is simply the application of programming and algorithms to geometry. The course includes the development of a simple renderer but also introduces an industry standard graphics library such as OpenGL as well as exploring simple animation (a series of images in which objects move and change).
TCSS 461 - Advanced Software Engineering
This course is an introduction to advanced concepts in Software Engineering. Topics include: System Re-engineering, Domain-Specific Languages, Generative Development, System Design and Service-Oriented Architecture. System Re-engineering will teach students how to integrate and maintain new systems with legacy systems. Domain-Specific Languages will use Object Management Group (OMG) standards and the Eclipse Modeling Framework (EMF) to familiarize students with model-driven software development. Generative Development will teach students the role of Unified Modeling Language (UML) modeling in automating code generation. System Design teaches students to understand how models can reflect an abstract architecture of software systems. Service-Oriented Architecture (SOA) will teach students to create and understand descriptions of SOA using both high level UML models and XML-based languages. [Prerequisite: TCSS 360]
TCSS 465 - Embedded Systems
Almost all modern system contain microprocessors that sense the outside work, process that information, and then send control signals out to manage the system. This course is an examination of particular theory and practice in designing software embedded in electronic devices and controllers. Includes clocks, threads, multitasking, critical sections, monitors, scheduling, on chip and external interfacing, communications, and fault tolerance. Many students often use this course as testbed for a subsystem of their senior design project. The course starts out with several demonstrative embedded systems for background and experience. Students then progress towards a team final project. A design contest judged by other faculty is the culminating event.
TCSS 480 - Comparative Programming Languages
This course is a study of three different programming paradigms: imperative, functional, and logic based. In imperative programming, computation is achieved by the sequence of steps that change the state of variables. Functional programming focuses on the more abstract, mathematical notion of a function that takes an argument and returns a value without modifying the state of a variable. As such, computation is expressed as the evaluation of functions and relies on recursion rather than iteration. Logic programming is based on predicate logic and performs computation using facts, rules, and an inference mechanism. Facts and rules express information about some problem domain, while an inference engine deduces the outcomes.

 

Most of mainstream programming nowadays focuses on the imperative model. However, both functional and logic programming hold a strong position within the field as well, and have influenced mainstream language development over the years. Learning different programming paradigms changes how one thinks about coding and computing in the first place, increases one's ability to express ideas, and in the end results in enhanced problem solving skills.

While the specific languages used in the course vary by instructor, at least three different languages that represent each of the programming paradigms listed above are covered in the course.

TCSS 491 - Computational Worlds
This course introduces the student to concepts necessary in deploying a full-scale virtual world as required in computer animation, gaming and simulation applications. Topics and focus may include: 2D/3D graphics modelling and rendering, discrete and continuous game engine design, multi-user networking, and artificial intelligence for computer controlled agents.