Software Engineering
Modern software design requires engineers to understand high-level languages, systems programming, techniques, and theory.

Demonstrate your ability to solve problems, contribute ideas, and offer solutions by earning a professional graduate certificate in software engineering.

What will I learn?
You will gain understanding, knowledge, and fluency in:

The art of programming, including abstraction, algorithms, data structures, and web development.
Software engineering fundamentals, such as functional and object-oriented styles of programming and models of computation.
Core tenets of computer systems programming, machine organization, and performance tuning, such as program optimization, memory hierarchy, caching, concurrency, and networking.
How to design large programs to make them readable, maintainable, efficient, and elegant.
Is this right for me?
This professional graduate certificate is for individuals currently working in or working toward deepening their skills and expertise for these types of roles:

Application developer
Database administrator
Software analyst
Software engineer
Mobile application developer
Courses
You take five courses to obtain a professional graduate certificate in software engineering.

Required courses:

SE01 Intensive Introduction to Computer Science
SE02 Abstraction and Design in Computation
SE03 Unix/Linux Systems Programming
SE04 Systems Programming and Machine Organization
SE05 Systems Development for Computational Science
SE06 Programming Microsoft .NET
SE07 Software Design: Principles, Models, and Patterns
SE08 Managed Environments for the Execution of Programs
SE09 Data Structures and Algorithms
SE010 Programming Languages

 


Earning the certificate
No application is required. Simply choose the courses you’d like to take first and register for graduate credit. Most students take one or two courses a term.

Will all the courses listed be offered every year?
The required courses are offered, but the elective offerings do change slightly from year to year due to instructor availability and new offerings.

Certificate requirements:
Take all courses for graduate credit.
Earn at least a B in all courses.
Complete all courses within three years.
Monitor your progress
You may monitor your progress by logging in to online services and choosing the Certificate Course Tracker and Request Form. This form will confirm the courses that count toward the certificate, the courses for which you are currently registered, and the courses that you’ve completed.

Requesting the certificate
When you have completed the final certificate course with the required grade, you may request your certificate by logging in to online services and completing the Certificate Course Tracker and Request Form. Be sure to request the certificate within 30 days of when grades are posted online (see calendar for dates).

After your request is reviewed and approved, you will receive an e-mail with a link to your electronic certificate, which you may print. Also, certificates, printed on parchment paper and suitable for framing, are mailed out at the end of the fall, spring, and summer terms.

The certificate will state:

 

The certificate, along with the courses and the grades, are noted on your official Canterbury University Extension School transcript.

Considering a master's degree?
This is a standalone credential, but you may be able to count some or all the certificate courses toward the Information Technology Graduate Program depending on the concentration or track you choose. Visit the degree course search to find out how certificate courses apply toward the degree.

If you want to earn the master’s degree, apply to the degree program first, and earn the certificate along the way. If you prefer to leave your options open, keep degree program requirements in mind as you begin to take courses. For either the certificate or degree, you can start out with one course, then decide.

Have questions?
We are happy to answer general questions about the certificate.

Read our common questions about certificates.
Connect with an enrollment coach. We’ll help you determine how the certificate can help you meet your goals. Share your contact information, and we’ll contact you soon.

This course is an introduction to the intellectual enterprises of computer science and the art of programming. It teaches students how to think algorithmically and solve problems efficiently. Topics include abstraction, algorithms, data structures, encapsulation, resource management, security, software engineering, and web development. Languages include C, PHP, and JavaScript plus SQL, CSS, and HTML. Problem sets are inspired by real-world domains of biology, cryptography, finance, forensics, and gaming. They cannot count all three toward a degree. The recorded lectures are from the Harvard School of Engineering and Applied Sciences course Computer Science 50. (4 credits)
Prerequisite(s): prior programming experience in any language recommended.

This course covers abstraction and design in computation. Topics include functional and object-oriented styles of programming, software engineering in the small, and models of computation. The goal is to understand how to design large programs to make them readable, maintainable, efficient, and elegant. Exercises are conducted in OCaml.. (4 credits)

As an introduction to the fundamental structure and services of the Unix and Linux operating systems, this course combines theory with programming at the system call level. Topics include files and directories, device control, terminal handling, processes and threads, signals, pipes, and sockets. Examples and exercises include directory management utilities, a shell, and a web server. (4 credits)

This course covers the fundamentals of computer systems programming, machine organization, and performance tuning. It provides a solid background in systems programming and a deep understanding of low-level machine organization and design. The course centers on C/C++ programming, with some assembly language. Topics include (but may not be limited to) program optimization, memory hierarchy, caching, virtual memory, dynamic memory management, concurrency, threads, and networking. 

This is an applications course highlighting the use of computers in solving scientific problems. Students learn the fundamentals of developing scientific software systems including abstract thinking, algorithmic development, and assessment of computational approaches. They use a series of open source tools and libraries for data analysis, modeling, and visualization of real scientific problems.

The first half of this course covers the .NET framework in some detail. Covered topics include the type system, exceptions, garbage collection, threading, and reflection. The second half surveys the additional functionality built on top of the .NET framework. Topics include WCF, WPF, Azure, Windows Phone, and others to be selected based on class interest and availability of guest speakers. Extensive programming homework required. (4 credits)
 familiarity with either the C# or VB.NET languages; at least one year of industrial experience in object-oriented programming.

This course approaches object-oriented software design from three perspectives: the software engineering principles that enable development of quality software, the modeling of software components using the Unified Modeling Language (UML), and the application of design patterns as a means of reusing design models that are accepted best practices. These patterns include both the original software patterns as well as more recent modularization patterns for software construction. There is at least one significant modeling exercise and a set of programming assignments that require the application of design principles and good programming technique. Students are expected to write a detailed description of the design for each of their programs, incorporating UML models as appropriate. Students implement their programs in the Java programming language. In addition, there is at least one significant assignment that requires designing and documenting a software subsystem without prior implementation. (4 credits)

The majority of modern programming languages assume some degree of runtime support to allow for a simplified abstraction, which leads in turn to increased developer productivity and a more robust end product. For example, automatic memory management removes the need for developers to manually track and release memory, eliminating entire classes of bugs and simplifying the interfaces between components. This course examines the technologies that make up a modern runtime environment, such as interpretation, JIT and selective compilation, memory management and garbage collection, and native interface design. Students develop components of a virtual machine, and learn about the design trade-offs required to build a high performance runtime environment. (4 credits)

Design and analysis of efficient algorithms and data structures. Algorithm design methods, graph algorithms, approximation algorithms, and randomized algorithms are covered. 

This course is an introduction to the theory, design, and implementation of programming languages. Topics covered in this course include formal semantics of programming languages (operational, axiomatic, denotational, and translational), type systems, higher-order functions and lambda calculus, lazy evaluations, continuations, dynamic types, monads, objects, modules, concurrency, and communication.