MPCS Course Catalog

In this course students will get an introduction to the field of computer science by learning to program in Java. Students will write roughly two or three programs of significance each week to learn foundational programming principles and practices for writing clean, readable code, and learning how think and solve problems like a computer scientist. Along with basic principles like procedural abstraction, recursion, and handling input and output, an emphasis will be placed on theories and principles of Object Oriented software design, analyzing algorithms and choosing appropriate data structures to solve problems.

This course in an introduction to discrete mathematics oriented toward computer science. The course emphasizes mathematical proof and problem solving, employed on a variety of useful topics: logic; proof by induction; counting, factorials, and binomial coefficients; discrete probability; random variables, expected value, and variance; recurrences; graphs and trees; basic number theory; asymptotic notation, and rates of growth. On completion of the course, students will have been trained to think about and absorb mathematical concepts, to solve problems requiring more than standard recipes, and express mathematical notions precisely. They will be able to use ideas and techniques from discrete mathematics in subsequent courses in computer science, in particular courses in the design and analysis of algorithms, networks, numerical methods, software engineering, data analysis, and data mining.

Advanced Programming fulfills the MPCS Core Programming requirement, but is intended for students who are joining the program with an existing degree in Computer Science, or with substantial experience in programming. This course will be taught primarily in C, including an accelerated introduction to the C language for students who have not used C before. The course will cover advanced data structures and topics in concurrent and multicore programming not covered in the Java Programming or C Programming courses.

This is an accelerated introduction to the C (not C++) Programming Language designed for students with prior programming experience. C is in many ways the lingua franca of computing, and a broad range of programming languages and related technologies derive from the basic principles of C memory management, control flow, and abstraction. Though there are many subtleties, C is not a big language, and it is expected that students will leave the course with a relatively deep understanding of the key concepts, which will then form a solid foundation for studying higher-level technologies. At the same time, C itself remains a very practical language, particularly so in areas such as scientific programming, high-performance computing, application level library design, systems programming, network programming, multi-threaded programming, etc. Students who successfully complete the course will be well prepared for subsequent MPCS courses in these areas. The course studies both fundamental and advanced C language constructs in the abstract and reinforces them through a range of exercises in the design of basic and advanced data structures, rudimentary algorithms, and API design.

This is a fast-paced first course in Java for students with some prior programming experience, though not necessarily Java or any other object-oriented language. A strong emphasis will be placed on understanding basic fundamentals of OO design--inheritance, polymorphism, composition, etc. and more generally on applying sound principles of contemporary software engineering and tools to real-world problems. In the latter half of the course, we will cover threads, OO design patterns, as well as certain Java libraries such as Swing. For their final-projects, students will develop a multi-threaded, arcade-style game. The course format is both lecture and lab. We will use be using git to facilitate our learning and to manage our projects. By the end of the quarter, students will have a working knowledge of git and know how to manage both local and remote repositories.

Python is a general-purpose programming language that is used in many application areas, including web development, scientific computing, graphical user interfaces, systems programming, gaming, rapid prototyping, data mining, and more. This course provides a thorough overview of the Python 3 language with an emphasis on writing idiomatic code in Python and object-oriented design patterns and is suitable for students with some prior programming experience. We will develop an understanding of the core features of the languages and gain exposure to commonly used standard-library and third-party modules.

Python is a general-purpose programming language that is used in many application areas, including data science, machine learning/AI, web development, scientific computing, graphical user interfaces, systems programming, gaming, rapid prototyping, and more. This course provides a thorough overview of the Python 3 language with an emphasis on writing idiomatic code in Python and object-oriented design patterns and is suitable for students with some prior programming experience. We will develop an understanding of the core features of the languages and gain exposure to commonly used standard-library and third-party modules.

Advanced Algorithms is a second course on the design and analysis of efficient algorithms, with emphasis on developing more powerful techniques for algorithmic design. Topics include data structures, discrete and continuous optimization, NP-hardness and methods of dealing with intractability, and computational geometry, with applications in computing, science, and engineering.

Engaging weekly homework assignments will involve designing new algorithms in pseudocode and implementing selected algorithms in a programming language. Course goals include equipping students with skills necessary to rigorously analyze code, recognize algorithmic and optimization problems in the real world, and apply suitable methods to solve them.

The course is an introduction to the design and analysis of efficient algorithms, with emphasis on developing techniques for the design and rigorous analysis of algorithms rather than on implementation. Algorithmic problems include sorting and searching, discrete optimization, and algorithmic graph theory. Design techniques include divide-and-conquer methods, dynamic programming, greedy methods, graph search, as well as the design of efficient data structures. Methods of algorithm analysis include asymptotic notation, evaluation of recurrences, and the concepts of polynomial-time algorithms. NP-completeness is introduced toward the end the course. Students who complete the course will have demonstrated the ability to use divide-and-conquer methods, dynamic programming methods, and greedy methods, when an algorithmic design problem calls for such a method. They will have learned the design strategies employed by the major sorting algorithms and the major graph algorithms, and will have demonstrated the ability to use these design strategies or modify such algorithms to solve algorithm problems when appropriate. They will have derived and solved recurrences describing the performance of divide-and-conquer algorithms, have analyzed the time and space complexity of dynamic programming algorithms, and have analyzed the efficiency of the major graph algorithms, using asymptotic analysis.

The study of algorithms is considered at the heart of computer science, and is consistently voted as the single most useful subject in a computer science curriculum. This course covers topics in design and analysis of algorithms for students who have already taken a course in introductory algorithms.
The primary themes are dynamic programming, network flows, computational intractability, and NP-completeness, approximation algorithms, linear programming, and randomized algorithms. All of these algorithmic techniques have a wide range of practical applications, particularly in modern computer systems and large-scale data analysis. This course focuses on some of teh more advanced applications, and includes a few fairly complex proofs.
Throughout the course, students practice how to take a real-world problem, formulate the algorithmic problem at its core, identify an appropriate design technique, describe unambiguously the resulting algorithm, and finally, prove its correctness and analyze its running time. The problems are drawn from a variety of application areas, including computer systems and networks, artificial intelligence, computer vision, data mining, and computational biology.

This course focuses on computer achitecture from the perspective of a
high performance programmer. It is aimed at students looking to
demistify the process of coding, profiling, and optimizing algorithms,
with a particular focus on systems geared toward performance intensive
computing: clusters, Multicore CPUs, GPUs, RISC-V, ARM, TPUs, etc. The
fundamental principles of computer architecture will be covered in
depth, but an equal emphasis will be given to hands-on experience in
learning how measure, tune, and report performance on common HPC
resources. While a key outcome of the course is the ability to write
more efficient code, the more enduring goal is to educate students to
"see their code" from the hardware's perspective, broadening and
deepening their understanding of programming with potential benefits
across a broad range of disciplines.

Topics include:

-history of HPC architectures
-efficient programming for cache-based serial processors
-MIMD and cache coherency
-efficient programming for multicore processors
-SIMD and vector instructions
-GPU memory and cores
-TPUs, matrix engines, systolic arrays
-ARM
-RISC-V 

Students who have taken MPCS 52010 Computer Archtiecture can not take this course.

This course focuses on studying modern computer systems from the point of view of a programmer, with an emphasis on topics which help you improve the performance, correctness or utility of user-level programs.

As such, this is intended to be a practical, hands-on study of contemporary computer systems. We will focus on the X86-64 architecture (as implemented by Intel/AMD 64 bit processors). Topics include:

• Representing and Manipulating information: unsigned and two's complement representation, IEEE floating point and corresponding arithmetic.
• Machine level representation of programs: x86-64 assembly, control instructions, translation of basic C control constructs (such as loops and switch statements), a study of common code security vulnerabilities (such as buffer overflows).
• Processor architecture: study of a pipelined out of order processor.
• Code optimization
• Memory hierarchy: persistent storage(magnetic spinning disks, SSD), RAM and ROM, and caches.
• Virtual Memory

The objective of this course will be to (i) expand the knowledge by covering new topics that represent the state-of-the-art in database management systems and distributed systems, and (ii) to build upon foundations developed in MPCS 53001 - Databases by covering topics in greater depth.

This class teaches the theory and practice of how to write a compiler, including lexical analysis, grammars, lexers and parsers, type checking, and code generation. For decades, compilers have been the most dynamic and challenging branch in computer science. The main part of this class will focus on providing the basics of the different phases of compilation. Through the course, students will develop appreciation for the implementation strategies behind making an efficient and robust compiler.

The objective of this class is to learn:

• the implementation of a real compiler from scratch

•  the answers of how programming language works

• the technical challenges that compilers face

• the basics of reaching performance

Computer architecture is the science and art of selecting and interconnecting hardware components to create a computer that meets functional, performance and cost goals to run software.  With the recent switch from uniprocessor to multicore microprocessors, it has become more important for the programmer to understand the hardware which will run their software.  For programs to run fast now, they must become parallel.  What this means to the programmer varies depending if they are dealing with an imbedded system, mobile smart phones, laptops or cloud servers.  This class will introduce students to the architectural knowledge they need to write high performance software for modern systems.

The class will start with a review of modern computer architecture using a freshly updated classic book, Patterson and Henessy’s Computer Organization and Design.  There will be written homeworks the first few weeks and a midterm.  This material will give the programmer and system architect a through grounding in modern computer architecture.

The second part of the class will focus on creating a cloud driven distributed microcontroller project.  We will use the wi-fi enabled Electric Imp (https://electricimp.com ) microcontroller.  Students will write cloud server software and microcontroller software which will interact to create a distributed system for the management of local devices over wi-fi and the Internet.  Since the security of the Internet of Things is looking as bad as everyone is expecting, we will also discuss the special security issues associated with such distributed systems.

Students will learn database design and development and will build a simple but complete web application powered by a relational database. We start by showing how to model relational databases using the prevailing technique for conceptual modeling -- Entity-Relationship Diagrams (ERD). Concepts covered include entity sets and relationships, entity key as a unique identifier for each object in an entity set, one-one, many-one, and many-many relationships as well as translational rules from conceptual modeling (ERD) to relational table definitions. We also examine the relational model and functional dependencies and their application to the methods for improving database design: normal forms and normalization. After design and modeling, students will learn the universal language of relational databases: SQL (Structured Query Language). We start by introducing relational algebra -- the theoretical foundation of SQL. Then we examine in detail the two aspects of SQL: data definition language (DDL) and the data manipulation language (DML). Concepts covered include subqueries (correlated and uncorrelated), aggregation, various types of joins including outer joins and syntax alternatives. Students will gain significant experience with writing and reading SQL queries throughout the course in the detailed discussions in class, online homework, and the real-world individual project.

This class teaches the theory and practice of how to design a distributed system.

Cloud computing, drive services, online collaborative working environment, massively multiplayer online gaming, airline reservation systems, e-commerce are examples of distributed systems. Because of a continuous growing number of independent and diverse connected devices, the need of managing heterogeneous architecture became prominent. We will learn how to create a reliable system being easy to use but handling the complexity of having all these machines work collectively.

The objective of this class is to learn distributed system by studying:

• Communication mechanisms

• Synchronization

• Scalability

• Consistency / Replication

• Fault tolerance

This course presents the functional programming paradigm, based on the idea of functions as first-class values that can be computed and operated on like other data. Functional languages provide great power of expression while maintaining simplicity, making it easier to write correct and maintainable software. Functional programming has gradually found new applications in areas like finance, telecommunications, and graphics. The essential feature of treating functions as values has also been added to a broad range of conventional languages, such as Python, C++, Java, Apple's Swift and Google's Go language. The course will use the Haskell language based on its representing a purely functional language and its large community support that helps with writing Haskell programs easily. After learning the basic elements of these languages, we will explore functional programming techniques that can be exploited in many areas of application. In particular, we will examine how FP features are used in more modern languages and libraries such as C++, Java, Elm, and React libraries and how they are used in real-world settings. We will briefly compare the functional paradigm with the related paradigm of object oriented programming. If time permits then we will explore more advanced topics including concurrent functional programming and functional reactive programming.

This course introduces computer security principles and practices. Topics will range from classic cryptography to recent web application security risks listed in the OWASP Top 10. The course will emphasize both offense (i.e., attacker mindset) and defense (i.e., designing and building secure systems).
Topics:

• Threat modeling
• Cryptography
• TLS and HTTPS
• Web application security
• Network security
• Authentication and access control
• Memory safety and isolation
• Trusted computing
• Side channels
• Anonymity and web privacy
• Underground economy
• Human factors
• Security ethics
• Cryptographic policy

This course is all about constructing your own knowledge of computer systems by building a general-purpose computer system from the ground up. The objective is to integrate key ideas from algorithms, computer architecture, operating systems, compilers, and software engineering into one unified framework. Along the way, we'll explore ideas and techniques used in the design of modern hardware and software systems, and discuss major trade-offs and future trends. Throughout this journey, you'll gain lots of cross-section views of the field of computer science, from the bare-bone details of switching circuits to the high-level abstraction of object-based software design. By the end of the course, you will have written a computer game in an object-oriented programming language; compiled that program into machine language using the compiler, the virtual machine language translator, and the assembler that you wrote; and run your program on (virtual) hardware that you designed.

This course aims to introduce to the fundamental concepts, principles, and abstractions that underlie the design and architecture of Unix systems. Students will learn how a Unix system works from the hardware level all the way up to the application level. The course will also focus on teaching students develop a command of the Unix shell environment by ensuring a basic understanding of Unix commands and utilities, and networking capabilities.  Students will also be able to learn about the fundamentals of systems programming in Unix. 

After taking this course, students will develop a more-depth understanding of Unix and be able to use this knowledge to better implement programs on a Unix operating systems such as Linux or OS X.

Broadly, this course will focus on the history, theory and implementation of computer networks. We will discuss the low-level technologies that move bits around (such as Ethernet and WiFi), the high-level applications that are part of our everyday 21st-century lives (such as email, the Web, and mobile phones), and everything in between (security, TCP/IP). At the completion of this quarter, you will (or should!) be able to explain, in detail, how data makes it way around the Internet when you click on a web link, how you can drive around at 80 MPH talking on a cell phone without the call dropping, how you can make a streaming video call over a lousy wireless link without frame dropping or jitter. In short, we'll pull back the curtain on what can be a somewhat mysterious and magical part of working with computers.

This is an introductory course on operating systems. Students will learn the fundamentals of how modern operating systems are built, from the interface with hardware up through the kernel-userspace boundary. Important topics include the relationship between processes and threads, synchronization, inter-process communication, memory management, file systems, scheduling, I/O, virtualization. These concepts will be reinforced through several large-scale programming projects (in C++), whereby students will implement various sub-components of a real operating system. Prior experience with C and/or C++ required. As appropriate, we’ll use the Linux operating system (written in C) as an example of operating systems design. As time permits, we will also delve into current hot topics in the field (such as multi-core systems, security, and cluster/grid computing).

Parallel computing is found everywhere in modern computing. Multi-core CPUs and GPUs, supercomputers, and even mobile devices such as smartphones all provide ways to efficiently utilize parallel processing on these architectures and devices. The goal of this course is to provide an introduction to the foundations of parallel programming and to consider the performance gains and trade-offs involved in implementing and designing parallel computing systems. Specifically, this course will place an emphasis on concepts related to parallel programming on multicore processors.

In this continuation of the MPCS 51044 course, we go beyond the basics to cover the powerful and surprising techniques that C++ experts use to write libraries that simultaneously provide the optimum in ease-of-use, abstraction, and performance. If you use C++ in your daily life, you and your team will see substantial benefits from understanding and using C++ at a deeper level.

In this course we will study the algorithms and the associated distributed computing systems used in analyzing massive datasets, or big data, and in large-scale machine learning.
We focus on two fundamental ideas for scaling analysis to large datasets: (i) distributed computing, and (ii) randomization. In the former, we study how to design, implement, and evaluate data analysis algorithms for the distributed computing platforms MapReduce/Hadoop and Spark. In the latter, we explore techniques such as locality sensitive hashing, Bloom filters, and data stream mining. These fundamental ideas are applied to applications such as finding similar items, market-based analysis, clustering, and building recommendation systems--all on massive datasets. They are the foundation of modern data analysis in companies such as Google, Facebook, and Netflix.
A major component of the course is a quarter long project in which students build a prototype system for solving a real-world data analysis problem. Examples of past student projects include analyzing sentiment in tweets and restaurant reviews, determining risk of crime when using public transportation, diagnosing eye disease from retina images, predicting a film's critical success based on the script, and analyzing NBA data for the "hot hand phenomenon."

Advances in mobile technologies are changing the way that individuals and businesses use computing devices. This course will explore real-world issues with developing robust, high-performance iOS applications for iPhone, iPod Touch and iPad. The course will consist of lectures, hands-on coding exercises and discussion. Weekly programming assignments will be used to create a portfolio of applications using advanced iOS frameworks and tools, such as Xcode, Interface Builder and Instruments. Throughout the course, students will design and develop an application as a final project. Students may opt to work in collaboration with local companies or emerging start-ups for their project. These opportunities will be discussed during the first week of class and may vary by quarter.

Python is a general-purpose programming language that is used in many application areas, including data science, machine learning/AI, web development, scientific computing, graphical user interfaces, systems programming, gaming, rapid prototyping, and more. This course provides a thorough overview of the Python 3 language with an emphasis on writing idiomatic code in Python and object-oriented design patterns and is suitable for students with some prior programming experience. We will develop an understanding of the core features of the languages and gain exposure to commonly used standard-library and third-party modules.

This course extends the ‘Introduction to Computer Security’ course to cover more advanced security topics, particularly from a security practitioner point of view.  This includes a range of threats and defenses, organizational readiness concepts and best practices, and use of security tools.

After a quick introduction to mobile computing, competing platforms, Android architecture, market projections, and social and economic implications, we will dive directly into developing several reference implementations. Alternating between theory and practice, and progressing cumulatively, will cover every major feature of the Android platform, including; audio, graphics, internet connectivity, wifi, mapping/geo-positioning, notifications, sms, structured feeds, persistence, threads, states, and inter-process communication, among others. Students will choose a final project, then envision, design, develop, test, and deploy an application to the Android marketplace.

This course will introduce secure development practices for networked applications. Application vulnerabilities will be studied to motivate the mitigations presented in the course. Particular emphasis will be placed on Web applications and the OWASP Top Ten. Programming assignments will involve exploiting vulnerabilities and implementing defense mechanisms. Topics include:

• Memory corruption

• Code injection

• Web vulnerabilities

• Authentification and authorization

• Session management

• Containment and isolation

• Cloud security

• Secrets management

• Threat modeling

• Code auditing, testing, and patching

This course provides a self-contained introduction to computational data analysis from an applied perspective. It is intended as a standalone course for students who do not want to pursue the full data analysis sequence in the MPCS. As such, students who have taken or are taking MPCS 53111 Machine Learning cannot register for this class. Students who have taken MPCS 53110 Foundations of Computational Data Analysis must obtain MPCS administration approval before registering for this class.
The course will cover topics in basic probability theory, statistical inference, and basic machine learning models typically used in data analysis. Each topic will be accompanied by example illustrations using computational packages and software. Many of the topics covered form the basis of almost all algorithms and machine learning methods used in big data analysis. Emphasis will be given on using these techniques for problem solving. All work will be done in R (https://www.r-project.org/about.html).

Applied Financial Technology (FinTech) is an applied, survey-based course into the concepts and technology underpinning financial innovation today.  Themes covered include US equities and trading algorithms, bond valuation, payments APIs, and asset tokenization and are based on the instructor's active and broad experience as a FinTech entrepreneur and passion for finance and economics.

Students will be expected to do some amount of coding in Python or Javascript each week.  Work will be group-based throughout the quarter with the exception of an individual final.

Readings also will play a key role in understanding elements of finance which are not specifically related to technology.  These foundational concepts will provide the student with a solid appreciation of sound financial innovation across time and avoid some of the trappings of speculative manias that financial innovation can produce.

We will have a weekly, current topics sessions where we do a quick dive into different themes that are timely and in the news.  Previous discussions have included cryptocurrencies, stablecoins, inflation, interest rate changes, and more.  These enable us to balance a set curriculum with some of the items that emerge unexpectedly each week and also enable us to draw on our growing knowledge of FinTech.

In this course, we will explore practical techniques to solving modern software challenges. Topics include:

• Software quality control

• Test-driven development

• Doman-driven design

• Measuring software quality

• Architectural design patterns

• Edge-free programming

• Event streams, logging, and audit trails

• Source control techniques for small teams with Git

• Security and cryptography essentials

• Continuous integration & deployment

This course is an intermediate approach to applied software design and development methods for use in creating efficient, reusable, and modular software.  This course is offered annually but content and focus change from year to year.  Methods we investigate include: classes, inheritance, and polymorphism; design patterns; advanced programming techniques using microservices, event-driven architecture, Hybrid Transactional/Analytical Processing; software frameworks and container-based software development; and advanced techniques including multi-threading.  A heavy focus is on design and creativity and what constitutes creative design.

The breakneck adoption of mobile computing as a platform has transformed how businesses and users interact with their data. The expectations of being able to access your data anywhere and anytime has become the second pillar of mobile application design and development. New models, patterns and workflows are needed to connect applications to their server based data. In addition, other considerations such as privacy, scalability and cost must be balanced to meet the demands of all application stakeholders.

In this course, we will cover both the theory and practice of Big Data. To support practical experience with genuinely big data, we have arranged that all students will receive a substantial credit on the Google Cloud Platform courtesy of generous support from Google. To develop a sound understanding of the theory of Big Data, we will use Marz and Warren's Big Data textbook providing a conceptual architecture for Big Data systems. We will also cover important additional topics that invariably arise in real world applications of Big Data, such as like cleaning scraped data meant for human consumption to meet the needs Big Data systems. Students are required to bring a laptop to class every week.

This course aims to introduce computer scientists to the field of bioinformatics. The vast amounts of data produced in genomics related research has significantly transformed the role of biological research. High-throughput automated biological experiments require advanced algorithms, implemented in high-performance computing systems, to interpret their results. We will focus on analyzing complex data sets in the context of biological problems. Students will design and implement systems that are reliable, capable of handling huge amounts of data, and utilize best practices in interface and usability design to accomplish common bioinformatics related problems. While this course should be of interest for students interested in biological sciences and biotechnology, techniques and approaches taught will be applicable to other fields. This course will present a practical, hands-on approach to the field of bioinformatics. The topics covered in this course will include: software, data mining, high-performance computing, mathematical models and other areas of computer science that play an important role in bioinformatics. Existing methods for analyzing genomes, sequences and protein structures will be explored, as well as computing infrastructure that support their efficient utilization. Students will be introduced to all of the biology necessary to understand the applications of bioinformatics algorithms and software taught in this course.

This course covers the major features of C++ in an accelerated fashion suitable both for experienced C++ programmers and programmers who are new to C++ as described in the prerequisites below. The course teaches how to get the most out of the current C++11 language, which Bjarne Stroustrup, the inventor of C++, says "feels like a new language." It also discusses how to workaround in old versions of C++. A dominant theme of the course is how to use the unique features of C++ to operate at a high-level of abstraction to support powerful design idioms and improve maintainability while also achieving the kind of performance and low-level control usually associated with lower-level languages such as C and even assembler language.

Cloud computing is being widely adopted by enterprises of all sizes due to the low initial investment required, attractive operating costs, and elastic capacity that can best serve the highly variable demands of modern applications. Software engineers must be familiar with cloud computing technologies since many new applications they develop will be deployed “in the cloud”, and existing applications will often require integration with cloud-hosted services to take advantage of new capabilities. This course provides an introduction to cloud computing with specific consideration for application development in two contexts: highly scalable (or so-called “web-scale”) web applications, and enterprise applications in a hybrid environment comprising both on-premises and cloud infrastructure. We will focus primarily on infrastructure and platform services, and will introduce software-as-a-service from the perspective of a consuming application. The course will emphasize practical applications of cloud computing technologies, with sufficient exploration of their theoretical underpinnings to inform architectural, design, and implementation decisions.

The core theme for the Entrepreneurship in Technology course is that computer science students need exposure to the broad challenges of capturing opportunities and creating companies. Most of the skills required for this process have nothing to do with one’s technical capacity.  We’ll explore creating a story, pitching the idea, raising money, hiring, marketing, selling, and more.  Real-world examples, case-studies, and lessons-learned will be blended with fundamental concepts and principles.  The course will involve a business plan, case-studies, and supplemental reading to provide students with significant insights into the resolve required to take an idea to market. Class discussion will also be a key part of the student experience.

The course covers statistical methods for exploring, summarizing, and visualizing data sets, for modeling data using probability distributions, for making inferences about a population from samples, for testing hypotheses related to such inferences, and for describing relationships using linear and logistic regressions. It then examines in detail techniques from machine learning used for solving fundamental problems in data mining: classifying data through decision trees, nearest-neighbors, and Bayesian techniques; clustering data through k-means, hierarchical approaches, and density-based techniques; and performing association analysis through the Apriori algorithm. Students use Python for implementing algorithms and Python libraries such as NumPy, SciPy, matplotlib, and pandas for analyzing and visualizing datasets.

Full Stack Software Engineering will focus on integrating applications thoughout the entire stack using Android, AWS, Docker, Vaadin, Spring, and Quarkus. Throughout the course, students will develop projects of progressive complexity using the tools and technologies introduced in the course. Students will create their own AWS accounts and deploy Quarkus microservices, AWS-lambdas, and Vaadin-Spring applications to their own AWS instances, and ultimately integrate them. Students will learn best practices in developing full-stack applications which is an essential skill for any engineer aspiring to be a software architect. 

Parallel computing allows multiple processing units to work together simultaneously on a common task. For certain types of applications, parallelization can increase execution time in proportion to the number of computers or processors used. This is a huge advantage for applications which have performance and/or memory bottlenecks, such as one typically encounters in financial modelling, physics, engineering, or other applied science domains. This is a fast-paced applied programming course aimed at students with significant development experience in either C, C++, or FORTRAN (Java, Matlab, or Python are also possible, but not ideal). No prior knowledge of parallel computing is assumed. Students should, however, have both an interest and some previous experience in either algorithmic development, numerical methods, applied mathematics, or perhaps any physics or engineering-type discipline. A brief overview of parallel computing will be presented at the outset, but the course will be less on overview of HPC architectures and much more a focus on algorithmic implementation and performance tuning. The goal of the course it to give students experience in developing efficient, scalable (distributed memory) parallel algorithms appropriate for any system running an implementation of the Message Passing Interface (MPI). Assignments will be designed with some flexibility to allow students to explore applying parallel techniques to applications in their own field of interest.

This course explores the cognitive psychology and physiology behind humans’ interactions with their environment and how this translates to “good design” of computer-based systems, interfaces, and machines. Emphasis is placed on the value of intentionally observing and analyzing the reciprocal relationship between humans and the design of systems in various contexts from a designer or engineer’s perspective. From a practical standpoint, the course addresses the role human-computer interaction (HCI) plays in enhancing the day-to-day human experience and the value of a product to society, while increasing the bottom line for stakeholders. Topics include perception, memory, attention, mental models, accessibility, user/interaction research methods, interface design principles, and design communication strategies.

This course is a comprehensive technical introduction to relevant topics in the wider ecosystem surrounding blockchain. Our technological focus will include substantive topics in fundamental problems that blockchain is attempting to solve (and is generating), including algorithms, cryptography, security and trust, autopoietic peer-to-peer networking, distributed ledgers, double spending, proof of work and ownership issues, decentralized applications, smart contracts, and supporting technologies. With that said, this is not a course in economics or monetary theory, trading cryptocurrencies, nor is it a course on regulatory or legal issues surrounding blockchain, although we will touch on many of these topics throughout the course. We will also cover broader applications of blockchain technology beyond cryptocurrencies and ICOs including use cases from finance, insurance, science, healthcare, pharmaceuticals.
We will cover cryptocurrencies and bitcoin and mining as well as ethereum initially as our introduction to the problem space, but will quickly move on to building our own blockchain application. Students may leverage a number of technologies including containerization (Docker), as well as the MEAN stack or Ruby on Rails for the more ambitious. Students may work in whatever languages they know best and make the most sense in context. These may include Java/javascript, C++, python, ruby, C#, and others.
Laboratories will be offered each week to reinforce a fundamental understanding of the core topics.
A final student project will be delivered by teams of students targeting a specific blockchain use case of the team's choice (teams will be given options).

This course aims to introduce students to important concepts in scientific computing. Students will survey topics in variety of disciplines and explore how rigorous computation is transforming the way that research conducted, experiments are executed, and data is analyzed across all scientific disciplines.

The course will focus on applying a variety of strategies to solve research problems with a focus on scalable, reproducible, and collaborative work. This will include the creation, manipulation, and analysis of data sets and the application of complex algorithms. Students will design and implement systems that are reliable, capable of handling vast amounts of data, and utilize best practices in interface and usability design.  Students will also learn to how to effectively communicate the results of their work to different audiences through written materials and presentation and to develop and provide resources for other researchers to use.

While this course should be of interest for students interested in sciencetific research, techniques and approaches taught will be applicable to other fields.

Writing first-class software requires top-notch architecture, design and coding skills, but successful software project execution--from identifying the need to providing support--depends on many factors besides technical prowess. This course surveys the key practices and processes that help ensure successful projects. It provides an introduction to central activities of software engineering other than just coding, such as planning, requirements, testing and management. It balances this discussion of typical engineering activities against the development process models in which they take place -- specifically, it addresses the tension between traditional plan-driven approaches and adaptive agile techniques. By examining the underlying principles of major development models, it shows how those principles address (or fail to address) the various problems encountered by project teams. Students who complete this course will gain a solid understanding of both plan-driven and agile software development principles and how to negotiate between them in different contexts.

Advances in mobile technologies are changing the way that individuals and businesses use computing devices. This course will instruct students on the fundamentals of mobile application development using Apple's iOS SDK. An introduction to the Objective-C programming language, including memory management, object-oriented design, and the model-view-controller pattern, will be covered. Using iOS APIs and tools, such as Xcode, Interface Builder and Instruments, students will be able to create fully-featured iPod Touch, iPhone, and iPad applications. User interface and application design considerations specific to mobile technologies will also be explored. The course will consist of lectures, hands-on coding exercises and discussion. Weekly programming assignments will culminate into the development of a fully functioning iOS application. As a final project, each student will design and implement an application of their choice to be presented in class. Each student will also be required to present a case study featuring an app from the Apple’s App Store. The studies will include a technical decomposition of the implementation (i.e. features, functionality, design, etc.) and a market analysis (i.e. competition, pricing, positioning, etc.) for the app. These case studies are designed to encourage students to gain an appreciation for the decisions companies and developers face when entering the app market.

This course introduces the fundamental concepts and techniques in data mining, machine learning, and statistical modeling, and the practical know- how to apply them to real-world data through Python-based software. The course examines in detail topics in both supervised and unsupervised learning. These include linear and logistic regression and regularization; classification using decision trees, nearest neighbors, naive Bayes, boosting, random trees, and artificial neural networks; clustering using k-means, expectation-maximization, hierarchical approaches, and density-based techniques; and dimensionality reduction through PCA and SVD. Students use Python and Python libraries such as NumPy, SciPy, matplotlib, and pandas for implementing algorithms and analyzing data.

This course examines software engineering skills through the lens of mobile development. Students will leave with more confidence in their ability to debug, decipher complex software systems, test their code, navigate documentation, leverage version control, and learn new programming languages. We'll exercise these skills with both the Android and the iOS framework, but the goal isn't to become fluent in a mobile stack; the goal is to practice the skills. The course also capitalizes on the unique history of mobile handsets and tablets to talk about about accessibility, data privacy, sourcing ethics, and to what degree it is our responsibility as engineers to understand and prioritize these things.

Can we predict how people will vote based on their twitter conversations? Can we identity pairs of researchers who will benefit from collaborating with each other based on their published articles? In this course we will study techniques for automatically detecting patterns and learning hidden structures in text data. Such techniques are of tremendous value due to the explosion in the amount of available text data, and their potential benefit to social sciences and businesses.
We will learn the fundamental steps in the natural language processing, such as syntactic parsing or understanding the structure of a sentence, and semantic analysis or understanding the meaning of a sentence from the meanings of the words in it. These will help us build sophisticated models for text classification, such as for detecting sentiment or identifying fake news.
We will see that the primary challenge is that natural languages are ambiguous. For instance, the sentence I made her duck can be interpreted in five different ways! So our models are probabilistic, and we resolve the ambiguity by training on large amounts of text corpora.
We will study a variety of models in the context of text processing including Markov and hidden Markov models, naive Bayes, logistic regression, and neural networks.
All through the course we will use Python and libraries such as the Natural Language Toolkit (NLTK) for processing real-world data.
A tentative list of topics follows:

• Text processing applications, ambiguity in natural languages
• The Natural Language Toolkit
• N-gram language models
• Information Retrieval
• Text Classification, Naive Bayes
• Logistic Regression
• Neural Networks
• Part-of-Speech Tagging
• Syntactic and Statistical Parsing
• Semantic Analysis
• Information Extraction

This is a practical programming course focused on the basic theory and efficient implementation of a broad sampling of common numerical methods. Each topic will be introduced conceptually followed by detailed exercises focused on both prototyping (using matlab) and programming the key foundational algorithms efficiently on modern (serial) architectures. The ideal student in this course would have a strong interest in the use of computer modeling as predictive tool in a range of disciplines -- for example risk management, optimized engineering design, safety analysis, etc. The numerical methods studied in this course underlie the modeling and simulation of a huge range of physical and social phenomena, and are being put to increasing use to an increasing extent in industrial applications. After successfully completing this course, a student should have the necessary foundation to quickly gain expertise in any application-specific area of computer modeling.   A familiarity with or strong interest in basic concepts of calculus and linear algebra will be helpful.

This course concentrates on three major themes: Software Architecture, Object Oriented Analysis and Domain-Driven Design, and Methodology. The bulk of the course will involve advanced concepts in Object-Oriented Analysis and Design and Domain-Driven Design (OOAD/DDD). The methods we will study include Object-Oriented Analysis and Design, Domain-Driven Design, and the Unified Modeling Language (UML). While the focus of teh course is on current best practices in designing object-oriented software, the general theme of the course is coming to terms with complexity in software systems and domains.
This course focuses on principles, concepts, processes, methods, and best practice models that are implemented with (most) any object-oriented programming language. Code examples that illuminate key concepts in OO design will be provided in various OO languages (Java, C++, C#, Smalltalk, Python, Common Lisp Object System (CLOS)) in order to further illuminate the concepts being discussed. For example, we will see how Python, Java, C++, and CLOS, implement, say, polymorphism, with distinctive hermeneutical and pragmatic significance. However, it is the concepts that are central, not their particular language implementations. A primary focus of the course will be to come to terms with many common patterns in software design, which provide proven and repeatable templates on which to base implementations.
Students will have labs assigned which will reinforce the concepts covered.

This course gives hands-on experience in architecture and design and the communication of such designs in the form of patterns. There are no formal prerequisites except solid familiarity with Java and optionally familiarity with C++. The course is designed to give students a fundamental introduction to design and architectural patterns as they are implemented in large scale system architectures currently used in industry. Students will be encouraged to explore the various implementation possibilities afforded by these patterns. Trade-offs in terms of performance, development time, maintenance impact, etc. will also be discussed. Students will gain exposure to several industry-leading tools including Apache ActiveMQ and ServiceMix.

Product management is a cross-disciplinary endeavor that sits at the intrersection of software engineering, marketing, and the user experience. Product managers are expected to create products in support of business objectives, ensuring that products deliver value to customers and are feasible to build within varying sets of constraints. In this course we will introduce the role of the product manager and demonstrate the challenges faced by product managers. We will explore approaches for managing the tension that exists between software development and product delivery using the minimum viable product and the product roadmap as critical tools. Key themes covered in this course include:

• Identifying a lack of product management

• Getting to market quickly; aka: “Perfection is the enemy of progress”

• Understanding the value of iteration and failing fast; aka: “You don’t know what customers value”

• Delivering a product that meets customer needs; aka. “Customers don’t know what they need"

• Trading off product focus and business needs; aka: “Drive on the freeway but know when to use the emergency lane”

• Understanding technology maturity and product lifecycles; aka: “You gotta know when to hold ‘em and know when to fold ‘em”

Coursework will include a mix of case studies, in-class workshops, product design sessions, written essays, and presentations. A key element of product management is communication, so there is an expectation that every student will contribute regularly to class discussions, and participation will be a substantial component of the final grade.

Stochastic processes are driven by random events. They can be used to model phenomena in a broad range of disciplines, including science/engineering (e.g. computational physics, chemistry, and biology), business/finance (e.g. investment models and operations research), and computer systems (e.g. client/server workloads and resilience modeling). In many cases, relatively simple stochastic simulations can provide estimates for problems that are difficult or impossible to model with closed-form equations. In this class, we focus on the rudimentary ideas and techniques that underlie stochastic time series analysis, discrete events modeling, and Monte Carlo simulations. Course lectures will focus on the basic principles of probability theory, their efficient implementation on modern computers, and examples of their application to real world problems. Upon completion of the course, students should have an adequate background to quickly learn in depth specific Monte Carlo approaches in their chosen field of interest.

This course is an intermediate approach to applied software design and development methods for use in creating efficient, reusable, and modular software. This course is offered annually but content and focus change from year to year. Methods we investigate include: distributed systems, architectures including microservices, event-driven architecture, Hybrid Transactional/Analytical Processing; software frameworks and container-based software development; and advanced techniques including multi-threading and SQL and NoSQL data stores. A heavy focus is on design and creativity and what constitutes creative design.
This course provides hands-on experience in the architecture and design of systems and a review of best practices for the communication of that design. Issues in the landscape of software design, including complexity, constraints, progressive discovery, and limitations in communication will be explored. In this course, students will be organized into teams and each team will be provided with a set of (partial) requirements and will be responsible for the analysis, design, design documentation, and implementation in source code of a project that constitutes a complex software system. Each team of students will work through requirements analysis, expression of design using a modeling language, and implementation, and techniques and tools will be provided in order to facilitate the delivery.
The progression of design will be peer-reviewed by the student teams. While this course focuses on design and implementation of software, it does not focus on the software development process or SDLC per se. That being said, we will work within an "Agile" design and implementation framework and adopt agile approaches to lean design. One of our efforts will be to dispel the myth that design is not performed within an agile environment.
During the course and lectures, we will cover the following topics:

• Why is design important , even in an agile environment?
• Attributes of good design: coupling, cohesion, law of Demeter, generic solutions vs. specific solutions
• What is the role of modeling in software development?
• Documenting and communicating software design using the Unified Modeling Language notation
• Lean thinking and lean modeling
• Design guidelines for quality, interoperability, modifiability, performance, security, testability, and maintainability
• The role of patterns in designing software and design refactoring
• Decomposing systems into recognizable patterns

This course is eleven weeks in length and covers the elemental practices of user interface (UI) design, user experience (UX) design, and user research. The intention of the course is to provide an overview of the experience design field so that the student is empowered to practice design as well as effectively manage design. It is, however, more likely that the student will collaborate with others on the design of products and services.
Experience design is the domain of empowering users to complete intended tasks efficiently and effectively. Research, UI, and UX help to create products and services that people want to use. User interface design (UI) is considered to include the visual design and organization of interfaces to guide users through the intended product experience. User experience design (UX) includes designing applications for users. It also includes the consideration of systems and business processes. Contemporary UX now includes topics such as service design, business design, API integration, and innovation. User research hopes to understand the needs and desires of customers. It includes topics such as voice of the customer research, customer engagement and retention measurement, as well as continual research to understand future product opportunities. Researchers also hope to understand if designs are usable by the intended audience.
During the class, we will utilize the latest design methods including prototyping, guerrilla research, design sprints, and Agile/Lean design/development processes.
At the conclusion of the class, the student will understnad the value of using design processes in creating new products. The student will have researched a problem. They will have prototyped an online service adn tested it with users, and have improved on their initial prototype afterwards. The student will have also created a sprint plan and prioritized the features for a minimal viable product. And finally, the students will present their solution to the class with data supporting their solution.

This course provides students with an introduction to modern web development, with an emphasis on the pragmatic skills needed to build live, functioning web applications. Students will learn fundamental domain modeling skills, HTML and CSS frameworks, agile software techniques and best practices, Javascript and AJAX, and both server-side and client-side debugging techniques. We will use the Ruby language and the Rails framework to immerse students into the challenge of building a live, database-backed web application deployed at a public web address. Specifically, students will learn how to: Build a live website or web application and deploy it to the public internet; Use the Ruby on Rails framework to rapidly build a web application; Write software using the Ruby programming language; Use a relational database to provide content for dynamic websites; Follow industry best-practices of modern web software development; Troubleshoot and resolve the most common problems with web applications.