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.
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.
Note: This course is part of a trans-institution sequence of MOOCs entitled Mobile Cloud Computing with Android
This MOOC and two others, taught by Dr. Adam Porter
from the University of Maryland and Dr. Douglas C. Schmidt
from Vanderbilt University, have been designed
to complement one another as part of the first trans-institution Specialization taught on the Coursera platform. Some of the programming assignments and the course project for these MOOCs will be coordinated. Dr. Porter's MOOC, Programming Mobile Applications for Android Handheld Systems
will be taught first; it focuses on the design and programming of user-facing application components. Dr. Schmidt's MOOC, Programming Mobile Services for Android Handheld Systems
, will be taught
next; it focuses on middleware systems programming topics, such as synchronous and asynchronous concurrency models, background service processing, structured data management, local inter-process communication and networking. This MOOC introduces the concepts
and knowledge needed to connect the user-facing and service-based components, built in the first two courses, to the cloud.
If you just want to take some of the MOOCs in this sequence or take them all in different order you’re certainly welcome to do so, and you’ll still learn a lot. If you take all the MOOCs in this sequence in the order presented, however, you’ll gain a
deeper, end-to-end understanding of handheld systems, their applications and services, as well as their integration into the cloud.
The course is organized into the sections outlined below.
Section 1: Talking to the Cloud with HTTP
Section 2: Building Java Cloud Services
- Module 1: The HTTP Protocol
- 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
- Module 2: Designing Applications with HTTP Communication
- Building Cloud Services on HTTP
- Protocol Layering / HTTP Design Methodologies
- HTTP Polling
- Push Messaging
- Module 1: Java Servlets
- What are Servlets?
- A First Cloud Service with a Servlet
- Video Servlet Code Walkthrough
- Video Servlet Test Walkthrough with HttpClient
- Securely Handling Client Data Avoiding Injection Attacks
Section 3: Building Database-driven Java Cloud Services
- 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 4: Restricting Service Access with User Accounts
- Module 1: Persistent Objects
- Object to DB Mapping
- Understanding SQL Injection Attacks
- Spring Data Code Walkthrough
- Module 2: RESTful Services for Persistent Objects
- Spring Data REST
- Spring Data REST Code Walkthrough
Section 5: Deploying to the Cloud Scaling
- Module 1: Secure HTTP Communication
- Man in the Middle Attacks Public Key Infrastructure
- Module 2: What was I Saying: Keeping Track of 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 6: Patterns and Frameworks for Concurrent and Networked Server Software [Optional Material]
- Module 1: General Scaling Strategies
- Stateless vs. Stateful Applications
- Horizontal Scaling
- Auto-scaling Horizontally
- 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
- 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
- Evaluating Patterns and Frameworks for Concurrent and Networked Software
Ideally, students who take this course will be familiar with general object-oriented design and programming concepts (such as encapsulation, abstraction, polymorphism, extensibility ), fundamental Java object-oriented programming language features (such as classes, inheritance, interfaces, and generics available in Java, basic systems programming concepts (such as event handling, processes/threads, synchronization), and networking terminology (such as client/server and peer-to-peer architectures).
Although the lectures are designed to be largely self-contained, it's recommended (but not required) that students refer to the following books:
- Martin Fowler, Refactoring: Improving the Design of Existing Code, Addison-Wesley Professional, 1999.
- Goetz et al., Java Concurrency in Practice, Addison-Wesley, 2006.
- Doug Lea, Concurrent Programming in Java, Prentice Hall, 1999.
- Gamma et at., Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, Reading, MA, 1995..
- Schmidt et al., Pattern-Oriented Software Architecture, Vol 2: Patterns for Concurrent and Networked Objects, Wiley and Sons, 2000.
- Buschmann et al., Pattern-Oriented Software Architecture:, Vol 4: A Pattern Language for Distributed Computing, Wiley and Sons, 2007.
- Buschmann et al., Pattern-Oriented Software Architecture, Vol 5 On Patterns and Pattern Langauges, Wiley and Sons, 2007.
Much of this material is available online
The class will consist of lecture videos with integrated quiz questions designed to ensure you understand the material covered in the videos. In recognition that not all participants have the same learning objectives or available time,
the course is offered at two levels of engagement:
– Estimated Time Commitment: 3 – 5 Hours Per Week
Students at this level receive a Statement of Accomplishment
that certifies advanced proficiency with the course concepts, which will be assessed by weekly auto-graded standalone quizzes. This track is designed for those
who wish to engage the material by doing the auto-graded quizzes and participating in the online discussion forums, but who may not have the time/interest to complete the auto-/peer-graded programming
– Estimated Time Commitment: 5 – 7 Hours Per Week
Students at this level will receive a Statement of Accomplishment with Distinction
that certifies greater mastery of the practice of the course content. In addition to completing the auto-graded weekly quizzes from the Standard Track, students in this track will also complete auto-/peer-graded programming assignments. The programming assignments will involve writing cloud services using popular software frameworks written in Java, such as Spring Framework
. This track is designed for those students wishing to achieve mastery
of the course material and to understand its application in realistic project context.
- What are the course objectives?
Upon completing this course, students should be able to:
- Build cloud services that can support mobile, embedded, or web-based clients.
- Identify security concerns related to client-provided data and common programming flaws that lead to insecure services.
- Apply key pattern-oriented software architecture techniques to develop reusable concurrent and networked cloud services using the Java object-oriented programming language, Servlets, and the Spring Framework.
- Develop Android components to communicate with the cloud and design/implement application-level protocols on top of HTTP.
- Implement data persistence components for cloud services and understand scalability issues with varying architectures
What is a "trans-institutional sequence of MOOCs"?
- Know where to find additional sources of information on how to build secure and scalable cloud services for mobile devices, embedded systems, and web applications.
This MOOC and two other MOOCs called Programming Mobile Applications for Android Handheld Systems, which is taught by Professor Adam Porter from the University of Maryland, and Programming Mobile Services for Android Handheld Systems, which is taught by Professor Douglas C. Schmidt, have been designed to complement each other. In particular, some of the programming assignments and the course project for both courses will be coordinated. Professor Porter's will focus on the design and programming of user-facing applications, and will be taught first, starting in January 2014. Professor Schmidt's MOOC will focus on middleware systems programming topics, such as synchronous and asynchronous concurrency models, background service processing, management of structured data, and local inter-process communication and networking, and will be taught second, starting in April 2014. Additional information on our trans-institutional MOOC sequence is available here and here.Is it necessary to take Prof. Porter or Prof. Schmidt's MOOC prior to this MOOC or can students take this MOOC without taking his course?
You can take the course without the other two courses in the sequence. If you just want to take some of the courses in this sequence--or take them all in different order--you're certainly welcome to do so, and you'll still learn a lot. However, if you take all the courses in this sequence in the order presented you'll gain a deeper, end-to-end understanding of handheld systems, their applications and services, as well as their integration into the cloud.When will the course material be made available each week? All the course material (e.g., video lectures, quizzes, short essays, programming assignments, etc.), for each week will be made available at 9am eastern time (2pm UTC/GMT).How does this MOOC compare/contrast with courses at Vanderbilt?
This MOOC is heavily based on courses we teach at Vanderbilt, such as the course Principles of Software Engineering. The course lecture material is similar. The quizzes, programming assignments, and level of feedback for the Vanderbilt courses are different, however, since the courses at Vanderbilt have many fewer students, so there's significantly more personalized guidance from the professor and TAs that can't (yet) be replicated via a MOOC.Can students use programming language [X] for the course?
The programming assignments in this course are designed for the Java programming language. Although you're welcome to use other languages to implement the cloud services, if you stray from Java you'll have more work to do to map what we're covering in the videos and projects to the languages you want to use. You may also find it hard to get feedback on your work via the Coursera peer-grading system .Will there be a Statement of Accomplishment for students who complete this class?
Yes. Students who successfully complete the quizzes and assignments in this class will receive a Statement of Accomplishment signed by the instructor. There will be two levels of Statements of Accomplishment: Normal Track and Distinction Track. The difference between these two tracks is covered at the Coursera website for this MOOC.What is the most effective way to learn material covered in the course?
We recommend watching the videos multiple times, looking for different levels of meaning in the diagrams and the examples. Likewise, we recommend reading any papers referenced in the lectures, as well as material from the (optional) recommended reading. Naturally, participating in the online discussion forum (and ideally, a meetup group if one is available in your area) will help make the course material more engaging.Can students take this course if they have no prior experience with Android programming or programming with Java?
Our course assumes that students are comfortable programming in Java and have some experience programming Android apps. If you don't have any significant Java programming background we recommend that you first take the Creative, Serious and Playful Science of Android Apps MOOC, which is a novice-friendly introduction to computer science and programming Android-apps for smart-phones and tablets. No prior programming knowledge is necessary for that MOOC. Likewise, we also recommend that you take Professor Adam Porter's MOOC Programming Mobile Applications for Android Handheld Systems since his course provides important coverage of Android app programming that will be useful in our course. Is there a required textbook?
There is no required textbook, per se. There's lots of information available in the videos, slides, and the URLs mentioned in the slides that will help you learn the material we cover in this class. For deeper mastery of the material, however, please see the list of "recommended reading" on the course webpage for a list of books that are closely related to the topics of the course.Where can students learn about how to configure a Java development environment to complete the programming assignments?
The videos from Professor Porter's MOOC Programming Mobile Applications for Android Handheld Systems provide step-by-step instructions on how to setup an Android development environment using Eclipse and Java. Eclipse will be the primary development environment used in this course. Videos will be provided on how to setup the Eclipse plug-in for Google App Engine. If you're using a non-Eclipse development environment (such as Intellij IDEA) you'll need to enlist the help of other students on the online discussion forum.Where can students learn more about patterns and frameworks?
Many videos about patterns and frameworks appeared in the Spring 2013 offering of the POSA MOOC. You can find links to all these videos here. The videos in Section 2 and the Appendix have lots of background information on patterns and frameworks. If you're a Safari online book club member you should check out the Design Patterns in Java video training series that covers the "Gang-of-Four" patterns.Which web browsers are recommended
Coursera recommends using the Chrome and Firefox browsers. There's also a mobile app for Coursera MOOC, as well. Where can students download the slides that are presented in the videos?The PDF and PowerPoint versions of the slides will be available online as the videos are released. You can download them from the course website.