Main Content
GC-SDE Course List and Brief Descriptions
*Please note that topics covered in these courses may be subject to change.
TCSS 501 - Analysis of Algorithms and Data Structures (Autumn Quarter)
Course Description: Introduces techniques used in algorithm analysis and data structures. Includes review of basic algebra, time space complexity, big O notation. Covers fundamental data structures and algorithms with an emphasis on implementing them in high-level programming languages. Emphasis on data structures such as array lists, linked lists, queues, stacks, trees and hash tables and algorithms such as sorting, selection, binary search and application of recursion in data structures.
Class credits and workload: 3 credits
Learning objectives
Upon successful completion of this course, the student will be able to:
- Apply fundamental concepts of algorithm design and analysis.
- Evaluate the trade-offs between different data types and their implementations, including algorithm efficiency
- Design and implement abstract data types (e.g. lists, stacks, queues, and trees) and algorithms (e.g. sorting, selection) using a high-level programming language.
- Name and describe standard search and sorting algorithms and analyze the differences in their time complexities.
- Analyze the worst-case time complexity of basic data structures and algorithms.
- Compare and contrast time/space characteristics of different implementations of the same abstract data type.
Topics covered
- Big-O notation, Analysis of algorithms, Code analysis.
- Review of arrays: basic operations and resizing
- Introduction linked lists.
- Introduction to recursion and their usage in data structure implementation.
- Abstraction, arrays, lists, stacks, queues
- Stack and queue implementation
- Efficiency of searching algorithms: Sequential & binary search algorithms.
- Efficiency of sorting algorithms: e.g. insertion sort, selection sort, bubble sort, mergesort.
- Introduction to trees: Implementation and common operations
TCSS 502 - Object Oriented Programming (Autumn Quarter)
Course Description: Introduces object-oriented programming (OOP) skills and best practices in software design including concepts of inheritance, encapsulation, abstraction, polymorphism, and software design patterns. Algorithm analysis techniques and data structures from TCSS 501 will be leveraged in projects.
Class credits and workload: 3 credits
Learning objectives
Upon successful completion of this course, the student will be able to:
- Use fundamental concepts of object oriented design to write modular, extensible code.
- Use common design patterns and to increase readability and maintainability.
- Apply skills to systematically test and debug applications
- Use lists, hashes, and trees in real applications
- Use the space time/characteristics of different search and sorting algorithms to choose the appropriate methods to implement.
Topics covered
- Review of language basics.
- Review of OOP ideas inheritance, encapsulation, abstraction, polymorphism
- Common design patterns (will be dependent on the programming language)
- Recursive and iterative implementations of search algorithms
- Implementation and proper use of different sorting methods - examples
- Implementation, common examples and use cases for heap, trees, hash tables
TCSS 503 - Algorithms and Problem Solving for Software Engineers (Winter Quarter)
Course Description: Introduces advanced data structures and key algorithmic techniques used in solving software engineering problems, such as trees, graphs, breadth/depth first searches, divide and conquer, greedy algorithms and dynamic programming. Learn how to analyze a problem and incorporate advanced data structures into the software implementations.
Prerequisite: TCSS 501 and TCSS 502 or equivalent.
Class credits and workload: 3 credits
Learning objectives
Upon successful completion of this course, the student will be able to:
- Describe key concepts of algorithmic design and analysis.
- Apply critical problem solving skills related to software engineering
- Identify data structures, algorithms and implementations that a developer would use in solving real problems and defend the appropriateness of these choices.
- Utilize advanced data structures (e.g. trees, graphs) and associated algorithms (e.g. breadth/depth first searches, greedy algorithms)
- Recognize and apply different algorithm design techniques (e.g. divide-and-conquer, dynamic programming, greedy approaches).
- Design, implement, and document a medium-sized program that uses algorithms presented in class.
Topics covered
- Review of trees
- Binary trees, binary search trees, priority queues
- Introduction to graphs and graph algorithms:
- Representations of graphs (e.g., adjacency list, adjacency matrix)
- Depth- and breadth-first traversals
- Use of graph representations in greedy graph algorithms such as shortest-path algorithms (Dijkstra’s), minimum spanning tree (Prim’s and Kruskal’s algorithms)
- Introduction to divide-and-conquer and illustrate this algorithmic design technique with example algorithms such as insertion sort, selection sort, mergesort, binary search
- Introduction to dynamic programming and illustrate this algorithmic design technique with example basic 1-dimensional algorithms such as job selection, longest common subsequence, longest common substring
- Introduction to greedy algorithms and illustrate this algorithmic design technique with example algorithms such as coin changing, Prim's algorithm, Kruskal's algorithm, Dijkstra's algorithm
TCSS 504 - Software Engineering and Development Techniques (Winter Quarter)
Course Description: Presents the principles and theory of software engineering and development including: requirements analysis, design and prototyping, system analysis, testing, project and version management, software and system metrics, and software development processes and lifecycles.
Prerequisite: TCSS 501, TCSS 502 or equivalent.
Class credits and workload: 3 credits
Learning objectives
Upon successful completion of this course, the student will be able to:
- Identify and contrast traditional and contemporary software development process models including waterfall and evolutionary models.
- Identify tradeoffs among software development process models to determine an appropriate process for given software development challenge(s).
- Identify software requirements and compose design specifications that accurately capture customer requirements.
- Create and apply software tests to verify the implementation of functional requirements in software systems.
- Apply metrics to assess the quality of alternative software design prototypes in meeting functional requirements.
- Explain concepts of software architecture, for example service-oriented architectures involved in the creation of software services in service-oriented applications.
- Apply and demonstrate the use of computer-aided software engineering (CASE) tools and version management systems through tutorials and practice.
Topics covered
- Software lifecycle and process models such as waterfall and agile methods
- Software development tools such as version control and unit testing frameworks
- Standard representations for requirements, such as user stories and business rules
- Design generation, design representation, and heuristics for good design
- Dynamic software verification: unit, integration, regression, and acceptance testing
- Static software verification: reviews, inspections
- Software and system metrics
- Fundamentals of software architecture with a focus on service oriented architectures
TCSS 505 - Systems Programming (Spring Quarter)
Course Description: Examines the fundamental concepts of modern operating systems and how they function. Topics covered include processes, threads, memory management, process scheduling, file systems, virtual machines and software containers. Covers the basics of the Linux operating system, bash commands, scripting, and systems programming.
Prerequisite: TCSS 503, TCSS 504, or equivalent
Class credits and workload: 3 credits
Learning objectives
Upon successful completion of the course, the student will be able to:
A primary objective for this course is to learn the fundamentals of modern computer operating systems to understand resulting implications for modern software development. The course will cover key tradeoff spaces involved in operating system design, and how operating system implementations impact computer system performance. Upon completion of the course students will be able to:
- Contrast tradeoffs in operating system design with respect to core concepts: scheduling, memory management, and I/O device management
- Explain the key structures and components of modern operating systems
- Create programs that leverage multiple processes and threads
- Create programs that leverage monitors (i.e. locks and conditions) to achieve concurrency while avoiding deadlock
- Describe operating system data structures used for file systems, memory, and process management
- Contrast differences between virtual machines and containers
Topics covered
- Concepts of OS design and operations
- OS Components and Structure
- Processes and Threads
- Concurrency, Synchronization, Monitors, and Deadlock
- Scheduling
- Memory Management
- Virtual Memory
- I/O Device Management
- Filesystems
- Virtual machines vs. containers
TCSS 506 - Practical Full Stack Development (Spring Quarter)
Course Description: Features an extended software engineering team project creating a web-based or service-oriented application. Includes topics such as databases, cloud computing, web services architectures and development.
Prerequisite: TCSS 503 and TCSS 504 or equivalent.
Class credits and workload: 3 credits
Learning objectives
Upon successful completion of the course, the student will be able to:
- Apply software engineering methods to support a larger team-based software development project
- Identify key goals and attributes important to the success of software projects
- Leverage version management for collaborative programming
- Use cloud resources to set up a simple web server and database
- Use effective group work practices, such as mutual accountability and public commitments.
- Participate effectively in a team to orchestrate software development using appropriate tools (eg. Agile) for facilitating teamwork.
Topics covered
The course is designed to provide students hands-on experience with a team-based software development project. Students will make use of all the concepts and techniques introduced throughout this certificate program.
Depending on the theme of the software development projects in this course, topics covered will be adapted accordingly. An example set of topics includes the following:
- Basic principles of cloud computing including account setup and management
- Setup and use group collaboration tools (GitHub)
- Basics of setting up a web server (authentication, HTML, CSS)
- Setting up a webserver on the cloud using a simple framework (eg. flask)
- Introduction to basic database queries and management using a cloud-based database service
