Computer Science

Fall Term 2015

CSCI E- 10A Introduction to Computer Science Using Java I (14289)
CSCI E- 15 Dynamic Web Applications (14291)
CSCI E- 18 Web Development Using XML (14297)
CSCI E- 19 Software Testing and Test-Driven Development (14803)
CSCI E- 22 Data Structures (14309)
CSCI E- 24 Numerical Analysis (14469)
CSCI E- 26 Introduction to C, Unix/Linux Programming, and Web
Interfaces (14294)
CSCI E- 32 Advanced JavaScript with Node.js and AngularJS (14815)
CSCI E- 33 Programming Microsoft .NET (14310)
CSCI E- 34 User Experience Engineering (14557)
CSCI E- 40 Communication Protocols and Internet Architectures (14296)
CSCI E- 45A The Cyber World: Hardware, Software, Networks, Security, and
Management(14299)
CSCI E- 48 Secure Mobile Computing (14841)
CSCI E- 50 Intensive Introduction to Computer Science (14290)
CSCI E- 54 Concurrent Programming in Scala (14725)
CSCI E- 55 Java and the Hadoop Distributed File System (14298)
CSCI E- 59 Database Design and Implementation (14738)
CSCI E- 60 Developing Web-Based Database Applications (14307)
CSCI E- 61 Systems Programming and Machine Organization (13836)
CSCI E- 71 Agile Software Development (14737)
CSCI E- 81 Machine Learning and Data Mining (14728)
CSCI E- 90 Cloud Computing (14300)
CSCI E- 91 An Introduction to Cloud and DevOps Concepts (14799)
CSCI E- 92 Principles of Operating Systems (14724)
CSCI E- 97 Software Design: Principles, Models, and Patterns (14306)
CSCI E- 98 Managed Runtime Environments (14531)
CSCI E- 109 Data Science (14328)
CSCI E- 121 Introduction to the Theory of Computation (14302)
CSCI E- 165 Data Systems (14861)

Spring Term 2016

CSCI E- 3 Introduction to Web Programming Using JavaScript (24095)
CSCI E- 7 Introduction to Programming with Python (24555)

CSCI E- 8 Web GIS: Technologies and Applications (24031)

CSCI E- 10B Introduction to Computer Science Using Java II (24027)
CSCI E- 12 Fundamentals of Website Development (21144)
CSCI E- 17 Medical Informatics (24035)
CSCI E- 20 Discrete Mathematics for Computer Science (24032)
CSCI E- 28 Unix/Linux Systems Programming (24040)
CSCI E- 40 Communication Protocols and Internet Architectures (24033)
CSCI E- 45B The Cyber World: Governance, Threats, Conflict, Privacy,
Identity, and Commerce(24037)
CSCI E- 46 Applied Network Security (24556)
CSCI E- 47 Formal Methods for Information Security (24497)
CSCI E- 49 Cloud Security (24557)
CSCI E- 50 Intensive Introduction to Computer Science (24107)
CSCI E- 55 Java and the Hadoop Distributed File System (24036)
CSCI E- 56 Web Application Development with Groovy and Grails (24415)
CSCI E- 58 Bioinformatics Algorithms (24039)
CSCI E- 63 Big Data Analytics (24038)
CSCI E- 64 Mobile and Cloud Computing (24228)
CSCI E- 66 Database Systems (24046)
CSCI E- 67 Oracle Database Administration (24045)
CSCI E- 93 Computer Architecture (24414)
CSCI E- 124 Data Structures and Algorithms (21462)
CSCI E- 152 Programming Languages (23837)
CSCI E- 171 Visualization (24028)
CSCI E- 186 Economics and Computation (23816)
CSCI E- 599 Software Engineering Capstone (24531)

CSCI E-10A Introduction to Computer Science

Using Java I
Introduction to Computer Science Using Java I
Fall Term 2015 CRN 14289
Intended for students with no previous programming background, this course
introduces problem-solving methods and algorithm development using the
high-level programming language Java. Students learn how to design, code,
debug, and document programs using modern engineering techniques in the
Unix environment. Related topics include programming using iterative
constructs, the basic aspects of arrays and recursion, string manipulation,
parameter passing, information hiding and encapsulation using classes, and
the functional decomposition of methods to enable object-oriented design.
Some applications are chosen for their relevance to more advanced
coursework in computer science while others involve nonscientific and
business-related areas. Students can count two of the following three
coursesCSCI E-10a, CSCI E-10b, and CSCI E-50toward a degree. They
cannot count all three toward a degree.

CSCI E-15 Dynamic Web Applications

Dynamic Web Applications

Fall Term 2015 CRN 14291
This course is the next step for students who have experience with
HTML/CSS and are looking to take their web programming skills to the next
level with server-side web development. Websites can be relatively static
mediums: a simple portfolio or a site for a local coffee shop are two
examples of basic sites with hard-coded content. This format works well for
presenting the same information for every visitor to the site. Web
applications, however, take websites to the next level. Think about your
experience with online banks, tools like Google Docs, and online stores like
Amazon. These are all robust applications operating with databases and
offering a personalized experience to each individual user. Over the course of
the semester we cover the skills necessary to evolve simple static websites
into dynamic, database-driven web applications. The following technologies
are covered: object-oriented PHP using the expressive MVC framework,
Laravel, basic server setup and management, version control with Git,
dependency management, testing, and other modern web development
practices.

CSCI E-18 Web Development Using XML

Web Development Using XML
Fall Term 2015 CRN 14297
Students learn key XML technologies (XML, XQuery, XPath, XSLT, RNG, XML
Schema, Schematron, DTD) used for open data exchange as well as specific
XML-based presentation and publishing formats (HTML5/XHTML, SVG, RSS,
XSL-FO, DocBook, OpenDocument). In addition, the course covers topics such

as XML programming APIs (DOM and SAX), native XML databases (eXistdb
and BaseX), XML publishing pipelines (Apache Cocoon, XProc), and the basics
of the semantic web and linked data. Using these technologies, students
develop dynamic, data-driven websites that are capable of delivering content
in a variety of media formats (screen, text, print, graphics) to a variety of
devices for a variety of audiences.

CSCI E-19 Software Testing and Test-Driven

Development
Software Testing and Test-Driven Development
Fall Term 2015 CRN 14803
In this course we review the traditional software testing techniques that are
applicable to any software product, as well as learn techniques for testing
object-oriented software and graphical user interface testing. The Agile
development paradigm of test-driven development is discussed. We also
discover how innovative companies are able to build testing and quality into
every stage of the development process and deliver a multitude of releases
with a relatively small testing organization. We practice test creation and
testing techniques through discussions, individual, and group projects.
Concepts covered include test cycles, testing objectives, testing in the
software development process, types of software errors, reporting and
analyzing software errors, problem tracking systems, test case design,
testing tools, test planning; test documentation, and managing a test group.

CSCI E-22 Data Structures

Data Structures
Fall Term 2015 CRN 14309
This course is a survey of fundamental data structures for information
processing, including lists, stacks, queues, trees, and graphs. It explores the
implementation of these data structures (both array-based and linked
representations) and examines classic algorithms that use these structures
for tasks such as sorting, searching, and text compression. The Java
programming language is used to demonstrate the topics discussed; and key
notions of object-oriented programming, including encapsulation and
abstract data types, are emphasized.

CSCI E-24 Numerical Analysis

Numerical Analysis
Fall Term 2015 CRN 14469
When we use a calculator to compute cos(x), we are asking the machine to
approximate a value. In this course, we investigate the algorithms used to
compute such values. As in many other areas of computer science, we seek
to find a result of desired accuracy with a minimum of effort. The course

covers root finding, solving systems of linear equations, interpolation, least

squares, numerical integration and differentiation, and solving systems of
differential equations. Students may have learned some techniques in
calculus to approximate an area with a Riemann integral or to approximate a
function with a Taylor Series. We review these techniques, and study variants
that converge much faster, and are thus better suited for calculators and
computers. Class work involves experimenting with different algorithms.
Programming is done in MATLAB, an interactive system for exploring
mathematical problems.

CSCI E-26 Introduction to C, Unix/Linux

Programming, and Web Interfaces
Introduction to C, Unix/Linux Programming, and Web Interfaces
Fall Term 2015 CRN 14294
Designed for students with some programming experience, this course
provides a rigorous introduction to writing and using software tools in the
Unix and GNU/Linux programming environments to build command-line and
web-based programs. The course teaches students how to write C programs
and Unix shell scripts, and how to create web interfaces to those programs.
Topics include text processing, memory management, files and pipes, and
processes and protocols. Students write programs to analyze data and
generate reports, use shell scripts to combine tools into applications, and use
HTML, CGI, and Ajax to provide web access to those applications and data.

CSCI E-32 Advanced JavaScript with Node.js and

AngularJS
Advanced JavaScript with Node.js and AngularJS
Fall Term 2015 CRN 14815
Web development has changed significantly in the last ten years.
Development of applications has become complex and, in most cases,
mystifying to classic development. New frameworks and technologies are
cropping up all the time and it's easy to get left behind. This course isn't
simply about the hot new technologies, it's about being a JavaScript
professional: how to work with current web development best practices and
how to be a great software engineer. Topics include version control, build
systems, task runners, optimization, APIs/web services, single page
applications, and unit testing.

CSCI E-33 Programming Microsoft .NET

Programming Microsoft .NET
Fall Term 2015 CRN 14310
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.

CSCI E-34 User Experience Engineering

User Experience Engineering
Fall Term 2015 CRN 14557
Success in today's software marketplace requires an excellent user
experience (UX). That's why all developers, architects, and managers today
need to understand the basic principles of UX, even if it's not their primary
job. In this course, we take an in-depth look at the foundations of an
excellent UX in a platform-agnostic manner. We learn to ask and then answer
the vital questions that everyone involved in software needs to consider
when making every design decision; we learn to start with the user, not the
toolkit. Who are our users and how do we represent them? What problems
are these particular users trying to solve, and what would they consider the
characteristics of a good solution? How should the user interaction flow, and
how can we represent that with stories? How can we prototype and test
different designs? How can we create programs to learn what users really do,
instead of what they can remember doing or are willing to admit to doing?
How can we measure how well we've succeeded? Rather than getting into
the implementation of such elements, we focus on how one decides what to
implement, and why, in order to make the user happier and more productive.
For example, the web and other channels contain an enormous amount of
information about how to program a color gradient or an animation. There is
almost zero discussion anywhere about when to use a color gradient or
animation and when not to, or why you should use them in this situation but
not in that one. This course aims to correct that imbalance. Useful design
tools, such as the Balsamiq mock-up editor, are discussed as they bear on

specific covered topics. Tools aimed primarily at user experience

implementation, such as Microsoft Expression Blend, are not covered.

CSCI E-40 Communication Protocols and Internet

Architectures
Communication Protocols and Internet Architectures
Fall Term 2015 CRN 14296
Networks are now too large, complex, and diverse to be built on an ad hoc
basis. This course provides a structured approach to the design, analysis,
and implementation of networks and protocols. We study various protocols,
including TCP/IP, WWW/HTTP, e-mail/SMTP, multimedia protocols for voice
and video, and the IEEE 802 LAN protocol suite. In each case, the protocol's
functions and the underlying reference model are discussed. LAN
architecture and design, internetworking using switches and routers, and the
design and analysis of both private networks and the Internet are presented.
The course discusses new areas of work, including network quality of service,
voice and video on the Internet, policy-based networks, and
broadband/gigabit networks.

CSCI E-45A The Cyber World: Hardware,

Software, Networks, Security, and Management
The Cyber World: Hardware, Software, Networks, Security, and Management
Fall Term 2015 CRN 14299
Today we all live and work in a participatory cyberspace. Computers, the
data networks that interconnect them, and the services available over the
networks make up this cyberspace. As cyberspace invades almost all areas
of modern day living, playing, and working, it is becoming more important
that people understand its technical and political underpinnings and
operations, as well as its capabilities, threats, and weaknesses. This is a
companion course to CSCI E-45b. The goal of this pair of courses is to give
students the tools they need to understand, use, and manage the
technologies involved, as well as the ability to appreciate the legal, social,
and political dynamics of this ever expanding universe and the interplay
between the cyber and physical worlds. The pair of courses covers the
essential elements of computing and the history, structure, operation, and
governance of the Internet. This course focuses on the fundamental workings
of the digital world. From individual computing devices to the broader
Internet, students learn how each piece in this gigantic puzzle comes
together to create the digital infrastructure that is the cyberspace of today
and tomorrow. In addition, we explore the fundamental concepts,
technologies, and issues associated with managing and securing cyberspace.

CSCI E-48 Secure Mobile Computing

Secure Mobile Computing
Fall Term 2015 CRN 14841
Modern technology is heavily dependent upon mobile computing technology.
Mobile communication and devices have revolutionized industry and society.
Secure mobile computing explores the threat landscape of mobile computing
at the device, communication infrastructure, platform, and application levels.
Students appraise secure mobile computing tools and techniques to
implement confidentiality, integrity, and availability of mobile computing
data. Students also review mobile computing communications security and
infrastructure security to evaluate eavesdropping and surveillance avoidance
techniques. Students explore the use of automated and manual security
testing techniques to evaluate the security posture of a mobile computing
device. Students specifically install, configure, and utilize a virtual lab
environment using a mobile testing framework, a network protocol analyzer,
a security/vulnerability scanner, and source code analysis tools.

CSCI E-54 Concurrent Programming in Scala

Concurrent Programming in Scala
Fall Term 2015 CRN 14725
With the end of Moore's Law on the horizon and a consequent fundamental
turn toward concurrency in software engineering, a broad variety of
concurrency paradigms have become increasingly popular. In addition, the
functional style of programming, which provides inherent support for
concurrency, has gone mainstream in recent years. The goal of this course is

to provide hands-on experience in developing concurrent programs by using

the Scala programming language and its rich ecosystem of libraries and
frameworks. The course exposes students to a wide array of topics, from
modern hardware architectures and functional programing, to various
approaches to dealing with concurrency and its constructs. We focus on
actors, agents, futures and promises, and functional reactive programming.
We also cover in detail the JVM memory model, threads, synchronization, and
monitors. Along the way, we analyze trade-offs of each technique.

CSCI E-55 Java and the Hadoop Distributed File

System
Java and the Hadoop Distributed File System
Fall Term 2015 CRN 14298
This course comprises a rigorous study of the core Java programming
language followed by an inquiry into Hadoop, a framework that allows for the
distributed processing of large data sets across clusters of computers The
first part covers classes, packages, enums, inheritance, abstract classes,
interfaces, reflection, exceptions, threads, and annotation. These common
tools for Java development are discussed: JUnit, log4j, and Ant. The second
part explores writing Java applications on the Hadoop Distributed File
System, and using the MapReduce programming model. Networks of cluster
nodes are simulated by multiple Java Virtual Machines running on a single
computer. Access to separate nodes on a network is not required.

CSCI E-59 Database Design and Implementation

Database Design and Implementation
Fall Term 2015 CRN 14738
The object of this course is to teach students the general concepts of
relational databases and how to design one that is anomaly free and can
answer queries that satisfies its user's requests. Students learn to design,
create, populate, and query a database by working with Oracle. Students
also learn basic database administration skills such as creating users and
granting and revoking privileges individually or collectively through roles.

CSCI E-60 Developing Web-Based Database

Applications
Developing Web-Based Database Applications
Fall Term 2015 CRN 14307
Web-based applications offer the advantages of workstation productivity and
ease of use together with the power and sophistication of relational database
servers. This course provides the concepts and skills necessary to design and
develop web-based database applications. Students build a working
database application using Oracle and a client application using ColdFusion
to serve the information needs of an enterprise. Through hands-on projects,

students build, populate, query, and write transactions for a relational

database using SQL, and develop a client application to access their
database using ColdFusion. As a final project, students build a prototype
client-server application.

CSCI E-61 Systems Programming and Machine

Organization
Systems Programming and Machine Organization
Fall Term 2015 CRN 13836
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. The recorded lectures are from the Harvard John A. Paulson
School of Engineering and Applied Sciences course Computer Science 61.

CSCI E-71 Agile Software Development

Agile Software Development
Fall Term 2015 CRN 14737
This course is an immersive experience with Agile software development. We
study both the technical and social aspects of Agile, including pair
programming, TDD, behavior-driven development, continuous delivery,
refactoring, extreme programming, Scrum, Agile project management, and
collaboration and cultural factors in successful software projects. Students
must have and bring to class a laptop computer suitable for software
development.

CSCI E-90 Cloud Computing

Cloud Computing
Fall Term 2015 CRN 14300
Cloud computing has entered the mainstream of information technology,
providing infinite or at least highly elastic scalability in delivery of enterprise
applications and software as a service (SaaS). Amazon Elastic Cloud,
Microsoft Azure, Google App Engine, and a few other offerings give both
mature software vendors and start-ups the option to deploy their
applications to a system of infinite computational power with practically no
capital investment and with modest operating costs proportional to the
actual use. The course examines the most important APIs used in the
Amazon and Microsoft clouds. We learn how to use RESTful Web services,
and cloud-based messaging and workflow services to construct new
applications. We learn to migrate existing applications into the cloud, by
navigating through phases such as creation of a private cloud; attaching, in a

secure fashion, the private cloud to the public cloud; and provisioning and
maintaining resources in the public cloud. We deal with non-trivial issues like
load balancing, caching, distributed transactions, identity and authorization
management, and data encryption. We introduce Hadoop and BigData
services in the cloud.

CSCI E-91 An Introduction to Cloud and DevOps

Concepts
An Introduction to Cloud and DevOps Concepts
Fall Term 2015 CRN 14799
We examine the definition and concepts around the ideas of DevOps. How do
they relate to working in the cloud? How do they relate to Agile and ITIL
concepts? We use the AWS cloud environment as the framework to examine
these ideas. We examine use cases, possible architectures, automation,
continuous delivery, and the AWS toolset. How does this enable and
generate change in an environment? What mindset changes must occur and
how would students think through this process?

SCI E-97 Software Design: Principles, Models,

and Patterns
Software Design: Principles, Models, and Patterns
Fall Term 2015 CRN 14306
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 implementation.

CSCI E-3 Introduction to Web Programming Using

JavaScript
Introduction to Web Programming Using JavaScript
Spring Term 2016 CRN 24095

This course provides an introduction to web development by way of the

essential language and runtime environment that powers modern web
interfaces. Through a series of examples and projects, students learn basic
programming concepts while building an understanding of the power and
complexities of Javascript, which can perplex even experienced web
developers. The course provides a solid foundation in computer
programming in Javascript: syntax and data structures, conditionals, objects,
scope and closures, AJAX, the DOM, and event handling. Students gain an
understanding of the popular libraries that power rich web applications such
as jQuery, Ext JS, and others. Upon completion, students are prepared to use
Javascript libraries in their projects, write their own or extend existing
JavaScript libraries, and build rich web applications using these powerful
tools. No computer programming experience is required, though exposure to
basic HTML and CSS is helpful.

CSCI E-7 Introduction to Programming with

Python
Introduction to Programming with Python
Spring Term 2016 CRN 24555
Python is a language with a simple syntax, and a powerful set of libraries. It
is an interpreted language, with a rich programming environment, including
a robust debugger and profiler. While it is easy for beginners to learn, it is
widely used in many scientific areas for data exploration. This course is an
introduction to the Python programming language for students without prior
programming experience. We cover data types, control flow, object-oriented
programming, and graphical user interface-driven applications. The
examples and problems used in this course are drawn from diverse areas
such as text processing, simple graphics creation and image manipulation,
HTML and web programming, and genomics.

CSCI E-8 Web GIS: Technologies and

Applications
Web GIS: Technologies and Applications
Spring Term 2016 CRN 24031
Web GIS has revealed its immense value and applicability to government,
business, scientific research, and our daily life. This course aims to provide
students with a comprehensive overview of web GIS, teach students state-ofthe-art skills including ArcGIS Online Cloud GIS, ArcGIS for Server, ArcGIS
Online web app templates, ArcGIS Web AppBuilder, ArcGIS API for JavaScript,
HTML5, mobile GIS, and 3-D web scenes, and inspire students with real world
web GIS application case studies. Access to Harvard ArcGIS server and other
ArcGIS software is provided.

CSCI E-10B Introduction to Computer Science

Using Java II
Introduction to Computer Science Using Java II
Spring Term 2016 CRN 24027
This is the second course in object-oriented programming methods using
Java. It begins with the implementation of abstract data types using classes,
objects, and overloaded methods. Other topics include strings,
multidimensional arrays, vectors, and linked lists; streams and file I/O;
recursion; exception handling; threads and event-driven programming; and
graphical user interface design using the Swing classes. The course also
introduces the RISC machine architecture and aspects of compilers and
operating systems. Programming exercises are conducted in both Unix and
PC-based environments. Students can count two of the following three
coursesCSCI E-10a, CSCI E-10b, and CSCI E-50toward a degree. The
recorded lectures are from the 2015 course.

CSCI E-12 Fundamentals of Website Development

Fundamentals of Website Development
Spring Term 2016 CRN 21144
This course provides a comprehensive overview of website development.
Students explore the prevailing vocabulary, tools, and standards used in the
field and learn how the various facetsincluding HTML5, XHTML, CSS,

JavaScript, Ajax, multimedia, scripting languages, HTTP, clients, servers, and

databasesfunction together in today's web environment. The course
provides a solid web development foundation, focusing on content and
client-side (browser) components (HTML5, XHTML, CSS, JavaScript,
multimedia), with an overview of the server-side technologies. In addition,
software and services that are easily incorporated into a website (for
example, maps, checkout, blogs, content management) are surveyed and
discussed. Students produce an interactive website on the topic of their
choice for the final project and leave the course prepared for more advanced
and focused web development studies.

CSCI E-28 Unix/Linux Systems Programming

Unix/Linux Systems Programming
Spring Term 2016 CRN 24040
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.

CSCI E-46 Applied Network Security

Applied Network Security
Spring Term 2016 CRN 24556
This course provides a practical overview of network security and related
topics. General threat classifications are discussed as they relate to the CIA
triad: eavesdropping (confidentiality), man-in-the-middle (integrity), and
denial-of-service (availability). Real-world attack incidents and
implementations are used to tie concept to reality. Defensive technologies
and techniques, including authentication/authorization, access control,
segmentation, log/traffic monitoring, reputation-based security, and secure
protocol (SSH, TLS, DNSSEC) usage are discussed and demonstrated. Handson labs and exercises are used to reinforce lectures and provide practical
implementation experience.

CSCI E-55 Java and the Hadoop Distributed File

System
Java and the Hadoop Distributed File System
Spring Term 2016 CRN 24036
This course comprises a rigorous study of the core Java programming
language followed by an inquiry into Hadoop, a framework that allows for the
distributed processing of large data sets across clusters of computers The
first part covers classes, packages, enums, inheritance, abstract classes,
interfaces, reflection, exceptions, threads, and annotation. These common
tools for Java development are discussed: JUnit, log4j, and Ant. The second

part explores writing Java applications on the Hadoop Distributed File

System, and using the MapReduce programming model. Networks of cluster
nodes are simulated by multiple Java Virtual Machines running on a single
computer. Access to separate nodes on a network is not required. The
recorded lectures are from the fall course.

CSCI E-56 Web Application Development with

Groovy and Grails
Web Application Development with Groovy and Grails
Spring Term 2016 CRN 24415
This course provides a comprehensive overview of using the Groovy
language and the Grails framework to rapidly create real-world web
applications. Students learn the fundamentals of rapid application and plugin
development, with an emphasis on convention-over-configuration and overall
best practices, by studying design patterns (MVC, DAO, dependency
injection), technologies (Ajax, REST), and frameworks (Grails, jQuery,
Bootstrap). Topics include artifacts; internationalization; testing, building, and
deploying; security; performance tuning; dynamic and static typing; and
usability, accessibility, and mobility.

CSCI E-67 Oracle Database Administration

Oracle Database Administration
Spring Term 2016 CRN 24045
Students study the internal structure and organization of an Oracle database
environment. The course presents a structured approach to planning,
building, tuning, and monitoring an Oracle 12c database on an Amazon Web
Services instance. Students create an Oracle database, tablespaces, user
accounts, views, indices, and other objects necessary to support an
application. We also examine some of the issues involved when running a
large number of databases within an environment and with running large
databases.

CSCI E-599 Software Engineering Capstone

Software Engineering Capstone

Spring Term 2016 CRN 24531

This course examines how current software engineering methods approach
structuring and managing software projects, from requirements gathering to
production release. Formal methods in software engineering have a long
history, from the older waterfall method to the current agile methods.
Students collaborate in small teams to define an architectural model and a
project plan, and then implement a system while practicing techniques in
software engineering. They prepare a presentation for the Extension
School's Master of Liberal Arts, Software Engineering faculty committee
based on the course project. The early programming assignments are in Java.