Programming Mobile Cloud Computing with Android-KTR

Programming Mobile Cloud Computing with Android-KTR

In this course----the third in a trans-institution sequence of MOOCs on Mobile Cloud Computing with Android--we will learn how to connect Android mobile devices to cloud computing and data storage resources, essentially turning a device into an extension of powerful cloud-based services on popular cloud computing platforms, such as Google App Engine and Amazon EC2.


Instructors::
1. Dr. C. Jules White
Assistant Professor of Computer Science
Electrical Engineering and Computer Science
Vanderbilt University


2. Dr. Douglas C. Schmidt
Professor of Computer Science and Associate Chair of the Computer Science and Engineering Program
Electrical Engineering and Computer Science
Vanderbilt University




About the Course::

This MOOC describes by example how to connect Android mobile devices to clouds via the use of object-oriented design techniques, Java programming language features, Jetty middleware, Java Servlets, the Java Spring Framework, and cloud computing platforms, such as Google App Engine. Although there will be 10 weeks of lecture material, the required core of the course is six weeks long and can be completed flexibly within the ten week schedule to provide flexibility for students during the summer.

An extended case study project will be used throughout the required core of the MOOC to showcase architectures for communicating with the cloud using HTTP, server-side processing of mobile data using servlets and the Java Spring Framework, and scalable storage of data using no-SQL databases and other platforms. Due to the importance of building secure and scalable mobile/cloud platforms, this MOOC will not only show you how to program handheld systems that talk to the cloud, but how to do so securely, scalably, and efficiently. Security and scalability topics will be woven into discussions of cloud service creation so that students learn, from the start, how to create robust cloud services for mobile devices.

Four weeks of optional lecture material will also be provided for students who would like to gain a deeper understanding of the patterns and frameworks for building cloud infrastructure building. This material will be presented in the context of the open-source JAWS web server, which is implemented in C++ as part of the ACE open-source object-oriented concurrent and networked programming toolkit.

Although the cloud service topics in this course will be taught in the context of connecting mobile devices to the cloud, the concepts are broader and will give students the ability to create the cloud services to support large-scale web applications, such as social networking applications; cloud services for embedded systems, such as the Internet of Things and Industrial Internet; and wearable computing devices, such as Google Glass.



Course Includes::

Section 1: Talking to the Cloud with HTTP

Module 1: The HTTP Protocol

Introduction
What are Communication Protocols?
Intro to HTTP
Why HTTP?
What is a cloud service?
HTTP Request Methods
HTTP Request Anatomy
URLs Query Parameters
Mime Types Content Type Header
Request Body Encoding
HTTP Response Anatomy
HTTP Response Codes
Cookies

Module 2: Designing Applications with HTTP Communication

Building Cloud Services on HTTP
Protocol Layering / HTTP Design Methodologies
REST
HTTP Polling
Push Messaging


Section 2: Building Java Cloud Services

Module 1: Java Servlets

What are Servlets?
A First Cloud Service with a Servlet
Web.xml
Video Servlet Code Walkthrough
Video Servlet Test Walkthrough with HttpClient
Securely Handling Client Data Avoiding Injection Attacks


Module 2: Better Abstractions for Building Java Cloud Services

Intro to Java Annotations
HTTP to Object Marshalling
Intro to JSON
The Spring Dispatcher Servlet and the Controller Abstraction
Intro to Spring Controllers
Accepting Client Data with RequestParam Annotations
Accepting Client Data with PathVar Annotations
Accepting Client Data with RequestBody Annotations and JSON
Handling Multipart Data
Generating Responses with the ResponseBody Annotation
Custom Marshalling with Jackson Annotations Serializers/Deserializers
Spring Boot Application Structure
Spring Controller Code Walkthrough
Spring Controller Test Code Walkthrough


Module 3: Better Client-side Communication Abstractions

Introduction to Retrofit
Retrofit Client Code Walkthrough
Android Retrofit Client Code Walkthrough


Module 4: Building Loosely Coupled and Extensible Java Services

Spring Dependency Injection Auto-wiring
Spring Configuration Annotations
Spring Dependency Injection Controller Code Walkthrough
Spring Dependency Injection Controller Test Code Walkthrough


Section 3: Building Database-driven Java Cloud Services

Module 1: Persistent Objects

Object to DB Mapping
JPA
Entities
Repositories
Understanding SQL Injection Attacks
Spring Data Code Walkthrough


Module 2: RESTful Services for Persistent Objects

Spring Data REST
Spring Data REST Code Walkthrough



Section 4: Restricting Service Access with User Accounts

Module 1: Secure HTTP Communication

Man in the Middle Attacks Public Key Infrastructure
HTTPS


Module 2: What was I Saying: Keeping Track of Sessions

Sessions
Spring Security Overview
Spring Security Configuration in Java
Building a Custom UserDetailsService
Setting up a custom UserDetailsService
The Principal
Spring Security Role Annotations
More Complex Expression-based Pre Post Authorize Annotations
Spring Security Controller Code Walkthrough
Spring Security Controller Test Code Walkthrough


Module 3: Authenticating Mobile Clients

Stateful Sessions with Cookies Why They Aren't Ideal for Mobile
Stateless Sessions with Tokens
OAuth 2.0
Spring Security OAuth 2.0
A Spring OAuth 2.0 Secured Service
A Retrofit Oauth 2.0 Client for Password Grants



Section 5: Deploying to the Cloud Scaling

Module 1: General Scaling Strategies

Stateless vs. Stateful Applications
Horizontal Scaling
Auto-scaling Horizontally
Caching
Offloading to Cloud Provider Services
Asynchronous IO in Controllers


Module 2: Scaling Up Data Storage

NoSQL Databases
Optimizing for Key-based Lookups
Optimizing for Reads vs. Writes
Contention Sharding
Mongo DB
Spring Data Mongo DB
Database as a Service
Amazon Dynamo
Spring Data Dynamo DB
App Engine Big Table



Module 3: Automating Packaging Deployment

Deploying to Infrastructure as a Service
Deploying to Amazon EC2
Packaging Web Applications into WAR files
Adapting Spring Boot Applications for Google App Engine
Deploying to App Engine



Module 4: Performance Testing

Intro to Cloud Service Performance Testing
Apache JMeter
Building Realistic Tests



Section 6: Patterns and Frameworks for Concurrent and Networked Server Software [Optional Material]

Module 1: Introduction to the Web Server Case Study

Applying Patterns and Frameworks to Concurrent and Networked Software
Overview of JAWS Web Server Case Study: Part 1
Overview of JAWS Web Server Case Study: Part 2
Overview of JAWS Web Server Case Study: Part 3


Module 2: Patterns and Frameworks for Service Access and Communication

Accidental Complexities with the Sockets API
The Wrapper Facade Pattern
ACE C++ Socket Wrapper Facades
Applying the ACE Wrapper Facades to a Web Client and Server


Module 3: Patterns and Frameworks for Synchronous Event Handling, Connections, and Service Initialization

The Reactor and Acceptor-Connector Patterns
The ACE Reactor Framework
Applying the ACE Reactor to JAWS
The ACE Acceptor-Connector Framework and Applying it to JAWS
Patterns and Frameworks for Service Configuration and Activiation
The Component Configurator Pattern
The ACE Service Configurator Framework
Applying the ACE Service Configurator to JAWS
Applying the Activator Pattern to JAWS
Patterns and Frameworks for Concurrency and Synchronization
The Active Object Pattern
The ACE Task Framework
Applying ACE Task and Acceptor-Connector to JAWS
The Half-Sync/Half-Async Pattern
Implementing Half-Sync/Half-Async Using ACE
The Monitor Object Pattern
Applying the Monitor Object and Synchronization Patterns to JAWS
The Leader/Followers Pattern
Applying the Leader/Followers Pattern and ACE_TP_Reactor to JAWS
Patterns and Frameworks for Asynchronous Event Handling
The Proactor pattern
The ACE Proactor Framework
Applying the ACE Proactor Framework to JAWS
The Asynchronous Completion Token Pattern and Applying it to JAWS


Summary::
Evaluating Patterns and Frameworks for Concurrent and Networked Software