CSS Elective Course Descriptions

Computer Science and Systems Elective Course Descriptions

TCSS 343 - Design and Analysis of Algorithms
There are two distinct but related parts to this course. In this class, students will learn techniques in analyzing the running time of an algorithm. Often the technique used to analyze an algorithm depends on the style of algorithm that is used. Students will also learn a number of algorithm design techniques, as illustrated by a large number of common algorithms that have been developed to solve fundamental problems such as searching, sorting, polynomial evaluation, matrix multiplication, and graph traversal. Analysis and design are connected because after developing several algorithms to solve a problem, one must be able to analyze their running times to determine which algorithm is best.
Algorithm design techniques that will be covered in the course include brute force, decrease and conquer, divide and conquer, transform and conquer, dynamic programming, and greedy. In addition, NP-completeness will be briefly introduced. Pseudocode will be the primary way algorithmic ideas will be expressed, but students will implement some of the algorithms discussed in the course. Students will apply their knowledge of data structures and discrete mathematics in this course. By the end of the course, students should be able to take a description of a problem and then formulate it as a computational problem, devise one or more algorithms to solve that problem, and then analyze the algorithms to determine which is best.
TCSS 360 - Software Development and Quality Assurance Techniques
This course will teach you how to build quality software using standard development practices and representations. This course involves writing and using requirements, designing and representing computational units, rigorous program testing, reviews and inspections and working effectively in teams. Prerequisite: a minimum grade of 2.0 in TCSS 342; 10 credits of writing coursework. The course topics include:
  1. Software lifecycle and process models such as waterfall and agile methods.
  2. Effective group work practices, such as mutual accountability and public commitments.
  3. Software development tools such as version control and unit testing frameworks.
  4. Standard representations for requirements, such as user stories and interaction prototypes.
  5. Design generation, design representation, and heuristics for good design.
  6. Dynamic software verification: unit, integration, regression, and acceptance testing.
  7. Static software verification: reviews, inspections.
TCSS 372 - Machine Organization
The prerequisite course for computer architecture is TCSS 371, Machine Organization. In that class students learn the basic structure of a computer, focusing especially on the cpu, its registers, and the machine's memory. They also learn a programming language that gives direct access to registers and memory, namely machine language (or equivalently assembly language). The existence of such a machine is taken for granted and much time is spent showing that even this very simple machine is sufficient to write programs that are arbitrarily complex. In 372, the focus shifts to how such machines are implemented and how they are made to run as quickly as possible. A computer requires a lot of data transfers even to execute a single simple instruction and the control of those transfers is a central topic of 372. The class also considers common enhancements to the standard computer design including pipelines (which allow for work on several instructions to proceed at the same time) and caches (a system for more quickly retrieving data from memory).
TCSS 421 - Compiler Construction
This course will cover the essentials of compiler construction techniques, including lexical analysis (scanning), syntax analysis (parsing), context analysis and code generation and optimization. Compilers are programs that typically translate high-level programming languages (e.g. C or Java) into assembly language. Modern compiler construction involves the specification of the formal structure of the high-level language using a context-free grammar and uses that specification to produce a parser with the help of a compiler generator tool, such as Yacc. That parser is then amplified with semantic operations so that it generates, and possibly optimizes, low-level code. During the course, students will implement a simple but realistic compiler for a high-level programming language (a Java subset).
TCSS 422 - Computer Operating Systems
Operating systems are ubiquitous. Application software relies on an operating system to preform basic hardware and resource management, thus fully understanding how software works requires an understanding of operating system fundamentals. This course examines two important facets of operating systems, their internal operation and their application-accessible features.

 

The study of operating system internals focuses on how different types of hardware resources are managed, e.g., the CPU, RAM, and storage media. This includes how hardware has progressed over the years to support advanced features such as multitasking and virtualization. The study of application-accessible features focuses on the hardware abstractions available to applications, e.g., processes and threads (abstractions of the CPU), address spaces (abstractions of RAM), and file systems (abstractions of storage media). Students will complete work that spans both facets, e.g., modifying/simulating components of operating systems and utilizing basic multithreaded programming. Use of an alternative operating system, such as GNU/Linux, is commonly required in this course.
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.