Skip to content

POSA 15 FAQ

Jump to bottom Edit New page
douglascraigschmidt edited this page Dec 23, 2015 · 194 revisions

Table of Contents

  1. What are the course learning objectives?
  2. What is the schedule and format for the MOOCs?
  3. What are "Section 0" Lectures and "Supplemental" Lectures?
  4. How do these MOOCs compare/contrast with courses at Vanderbilt?
  5. What are your assumptions about--and expectations for--students taking this MOOC?
  6. What is the most effective way to learn material covered in the course and to successfully complete the programming assignments?
  7. Can students take this course if they have little/no prior experience programming Android and/or Java in Eclipse?
  8. Why are there so many URL links embedded at the bottom of the slides?
  9. What is the teaching staff policy for monitoring and answering discussion forum threads and questions?
  10. How many and what types of quizzes and programming assignments will there be in this MOOC?
  11. How can students understand and learn the material in the videos most effectively?
  12. How do the CS 282 and CS 251 videos relate to the 2015 MOOC videos?
  13. What are "Virtual Office Hours"?
  14. Will there be a Statement of Accomplishment or a "with distinction" certificate for students who complete this class?
  15. Who is eligible to take the MoCCA Specialization Capstone project course?
  16. Do students who took the previous offering of MoCCA Specialization in 2014 need to retake them to continue with subsequent MoCCA Specialization series?
  17. What is a "trans-institutional MOOC Specialization"?
  18. Is it necessary to take the MOOCs in the MoCCA Specialization in a particular order?
  19. Can Android Studio be used as the development environment for the MOOCs?
  20. Is there a required textbook?
  21. Where can students learn about how to configure their Android and Java environment to run the examples and complete the programming assignments?
  22. Where can students learn more about patterns and frameworks?
  23. Which versions of software are required for the MOOCs
  24. Can students use programming language [X] for the course?
  25. Where are the slides and source code presented in the videos and the code skeletons provided for the programming assignments?
  26. How will the 2015 offering of the MOOCs differ from previous offerings?
  27. How does the coverage of Android concurrency in Part 2 of the MoCCA Specialization compare/contrast with the coverage in Part 3?
  28. Why do these MOOCs' names start with "posa"?
  29. What are the plans/schedule for offering the MoCCA Specialization again in the future?
  30. How long will the course material be available online after the MOOC ends?
  31. Where is the source code that corresponds to the pathnames embedded in the slides shown in the videos?
  32. Will there be much flexibility in the schedule of deadlines for programming assignments in these MOOCs?
  33. How closely aligned will the programming assignments be between MOOCs in the MoCCA Specialization?
  34. How will the programming assignments be obtained, submitted, and assessed?
  35. Will the links in the MOOC lecture videos be made clickable and/or consolidated into a single convenient location?
  36. Where are good sources of tutorials and examples for Java and Android concurrency mechanisms?
  37. How can students keep informed about important due dates for assignments?
  38. How many hours per week will be required for these MOOCs?
  39. What are some consequences of the "massiveness" of a MOOC?
  40. How much of the Android software stack is covered by the MoCCA Specialization?
  41. Can students use public source code repositories to store their solutions to the programming assignments?
  42. What are some good techniques, tools, and methods for visualizing, analyzing, and debugging concurrent Java programs.
  43. Where is the source code for examples and assignment solutions from the Vanderbilt courses CS 282 on Android and CS 251 on patterns?
  44. How much of a focus on patterns and frameworks will there be in this MOOC?
  45. Why are there lecture videos on YouTube and on the Coursera MOOC websites?
  46. Are there other programs students can write to get experience with more advanced Android concurrency and communication mechanisms if they find the programming assignments too easy?
  47. Since many assignments have been posted to GitHub can we work on them prior to their official release?
  48. Where is more information available on Android internals?
  49. What resources can be used for the weekly quizzes?
  50. Can I take Programming Cloud Services for Android Handheld Systems without taking Programming Mobile Services for Android Handheld Systems?
  51. Which videos have in-video quizzes?
  52. What can we do if the audio is out of sync with the video stream when viewed from the course website on Coursera?
  53. Why aren't the MOOCs in the MoCCA Specialization identical wrt programming testing procedures?
  54. What is the naming scheme for the videos?
  55. Who will define the projects implemented in the Capstone Projects Course?
  56. What is the best way to handle null references in Java?
  57. What are rules for choosing the appropriate Android Context?
  58. Can students do extra assignments to improve their grade?
  59. How can we convince our colleagues and management of the value of patterns and frameworks in practice?
  60. How can I prepare in advance for the upcoming Programming Cloud Services for Android Handheld Systems MOOCs?
  61. Why have the MOOCs in the MoCCA Specialization been split into multiple courses?
  62. Is there a way to get the Android Virtual Device (AVD) emulator to run faster?
  63. How can students install/use the SureLogic concurrency analysis tools?
  64. How long does it take for the post-processed videos, subtitles, and downloadable MP4 videos to appear for live lectures?
  65. How can students get help if their solutions to the programming assignments aren't working?
  66. What is a "hook method"?
  67. Why do the times/days of the Live Lectures and Virtual Office Hours change?
  68. Why do programs fail to download images when running in the Android emulator?
  69. Can 3rd-party concurrency libraries or frameworks be used for the programming assignments?
  70. Will the source code for the programming assignment solutions be made available?
  71. What sorts of methods go into the Utils.java file and are they always used for each assignment?
  72. Is it necessary to watch the lecture videos prior to doing the programming assignments?
  73. Can example code be used for the programming assignments?
  74. How Were Professor White's Videos Made and are there PDF Versions of His Material?
  75. Can the Concepts Covered for Spring be Extended to Other Web Application Frameworks?
  76. Can the software examples shown in this MOOC be used by students for other projects?
  77. What will be the focus of the new POSA Content MOOC?
  78. Why are all the fields in the example code and assignments prefixed with "m"?
  79. Why is the POSA Communication MOOC longer than the other MOOCs in the MoCCA Specialization?
  80. When will the final grades and certificates be available after the MOOC ends?
  81. What is the impact of transitioning the MoCCA Specialization to the new Coursera platform?

FAQ

  1. What are the course learning objectives?

    Upon completing this course, students should be able to:

    • Recognize the inherent and accidental complexities involved with developing concurrent and networked software that communicates securely between processes and threads within mobile devices and from mobile devices to clouds.

    • Apply patterns and frameworks to develop reusable and resilient concurrent applications and services using the Java object-oriented programming language and Android middleware.

    • Understand how pattern-oriented software architecture and framework techniques can and cannot help to alleviate the complexities of mobile device software.

    • Know where to find additional sources of information on how to program mobile applications and services on Android handheld systems.

  2. What is the schedule and format for the MOOCs?

    These MOOCs use a combination of live lectures and recorded lectures, which typically run for 4-6 weeks (the remaining week(s) are used for finishing up the assignments and peer evaluations). To master the material and succeed with the programming assignments we recommend watching both the live lectures and the recorded lectures, unless the recorded lectures are marked as "Supplemental" (as discussed in FAQ item #3).

    You can view the live lectures in the following ways:

    • The live lectures constitute the bulk of the "official" content of the MOOC, though some live lectures for each week have been recorded live in previous offerings of the MOOC (also see item #3 in the FAQ for info on the so-called "supplemental lectures"). Interactive live lectures will normally be held on Monday mornings, typically starting at 11am eastern time via Google Hangout (the exact times will be posted to the Announcements page of the MOOC). The lectures will be recorded by Google Hangout automatically and the "raw" version of the lecture will be available on YouTube shortly after they complete.

    • The raw version will be post-produced and made available as MP4 videos in the MOOC website a day or so after they are presented for students who aren't able to attend the interactive live lectures. These videos will be split into two sections: (1) Slide presentations and (2) Q&A discussions of the slide presentations. Subtitles will be added by Coursera at whatever pace they can manage once the lecture videos are posted on the website.

    We will also hold weekly "Virtual Office Hours" (VOH), which will be held later in the week, typically starting at 11am eastern time via Google Hangout (the exact times will be posted to the Announcements page of the MOOC). In the VOH sessions we'll answer questions from students and lead impromptu discussions with students live via Google Hangout and YouTube. VOHs will continue until the end of the MOOC (i.e., even after the Live Lectures are done) so we can present our solutions to the assignments and students can ask questions. See FAQ item #13 for more information on VOH.

    There will be periodic programming assignments that will have a deadline, which will be clearly marked on the MOOC websites and in the course calendar available by clicking on the calendar icon next to the "Upcoming Deadlines" label. This calendar is automatically updated as the material is released. The programming assignments will be based on material covered in both the live and pre-recorded lectures (but not the Supplemental lectures discussed in FAQ item #3).

    The programming assignments will be available on Wednesday for the first three weeks of the MOOC. Please see FAQ item #34 to learn how the programming assignments will be obtained, submitted, and assessed. Assignments will be due at least two weeks from when they are released. Likewise, there will be weekly quizzes, released by the middle of each week, though their due dates will all be the last day of class so you can take them as time permits. There won't be any "late dates" for quizzes since they are due the last day of class.

  3. What are "Section 0" Lectures and "Supplemental" Lectures?

    All the core material in these MOOCs (i.e., Sections 1, 2, and 3) will be presented as so-called Live Lectures, which will be available in the "Video Lectures" portion of the MOOC websites, as discussed in FAQ item #2. In addition, there are supplemental lectures for much (though not all) of the material, including pre-recorded videos from the 2014 POSA MOOC (which are available at the link provided in FAQ item #27) and lectures of my Vanderbilt courses on Android (e.g.,CS 282 and CS 251, as discussed in FAQ item #12). The Live Lectures are the most up-to-date versions of the material and they tend to run longer than the pre-recorded versions since they go into more detail. Feel free to watch the supplemental videos at a time and a pace that is most convenient for you if you find them helpful, but you're welcome to skip them altogether if they aren't helpful to you or if you prefer the form/content of the Live Lectures better.

  4. How do these MOOCs compare/contrast with courses at Vanderbilt?

    The material in these MOOCs are based on junior and senior-level undergraduate courses taught at Vanderbilt, such as the CS 282 and CS 251 courses, which focus on teaching mobile software development at both a conceptual level (e.g., an understanding of software patterns, object-oriented design, and frameworks) and a practical level (e.g., experience programming Android applications using Java,Eclipse, and Git). Students in the Vanderbilt courses are expected to be (1) familiar with Java, Eclipse, and source code control systems and (2) capable of learning new material without significant hand-holding by the teaching staff.

    There is significant synergy between lecture material in CS 282 and CS 251 and the material presented in these MOOCs (earlier versions these lectures are available on my YouTube playlists for CS 282 in 2013,CS 282 in 2014, and CS 251 in 2015). Moreover, each time the material is presented it's improved and extended, so every offering is different. Moreover, portions of these MOOCs are presented live (see FAQ item #2 above), so students who join via Google Hangout can ask questions in real-time. Naturally, the quizzes, programming assignments, and degree of feedback for the Vanderbilt courses are somewhat different from the MOOCs since the Vanderbilt courses have many fewer students (instead of ~80,000 students), which enables significantly more personalized guidance and in-depth assessments from the teaching staff that can't be replicated in a MOOC (yet).

  5. What are your assumptions about--and expectations for--students taking this MOOC?

    As mentioned in FAQ item #4, this MOOC is based on material we teach to senior-level undergraduate students at Vanderbilt. This MOOC is intended for self-motivated students who

    • Know Java, Eclipse, and Git (or can learn them quickly on their own)
    • Want to understand both the concepts and practice of developing mobile software applications and services
    • Are curious about how the Android software stack itself is designed and implemented
    • Are willing/able to carefully read/follow the instructions in the course assignments and announcements.

    Students who are just interested in vocational training (e.g., having an instructor walk through application code projects step-by-step and line-by-line in the Android development environment) may not find this MOOC suitable for their needs since our goal is to help students learn techniques and methods for finding solutions, not simply spoon-feeding the solutions . Moreover, this MOOC covers certain topics (especially patterns and frameworks for concurrency, communication, and security) associated with engineering quality mobile software development that may not be of interest to students who just want training on the Android APIs, so for those students we recommend others sources, such as the Android Application Development Tutorials on YouTube. Likewise, students who don't have time/interest in following the instructions/announcements carefully are welcome to take this MOOC, but they will need to adjust their expectations since the course is not designed for them, due to factors discussed in FAQ item #39.

  6. What is the most effective way to learn material covered in the course and to successfully complete the programming assignments?

    We recommend watching the videos multiple times, looking for different levels of meaning in the diagrams and the examples. It's particularly important to carefully watch all the videos referenced in the programming assignment descriptions since they provide many relevant tips and insights. Likewise, we recommend reading the material pointed to by links in the slides, as well as material from the (optional) suggested 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 and personalized. Additional discussions of the programming assignment goals, requirements, and (ultimately) their solutions will be covered in "Virtual Office Hours" (see the FAQ entry #13 on this topic).

  7. Can students take this course if they have little/no prior experience programming Android and/or Java in Eclipse?

    Our course assumes that students are comfortable programming in Java and have some experience programming Android apps in Eclipse. If you don't have much/any Java programming background you might consider taking the course Java for Complete Beginners and/or watching my videos on Introduction to Java in the YouTube playlist for my CS251 course at Vanderbilt. Likewise, you might also benefit from 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.

    Naturally, we 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. We encourage you to apply the Lazy Acquisition pattern in these MOOCs, i.e., watch the videos, keep track of what you know understand, and then use the resources available to you (e.g., via the web and the discussion forums) to fill in the gaps in your knowledge. One of the best things about MOOCs is that you can go through this material at your own pace, and there's really no penalty for retaking a MOOC if you struggle with it the first time through!

  8. Why are there so many URL links embedded at the bottom of the slides?

    Many of the topics (especially concurrency, inter-process communication, and application security) we cover in this MOOC are very technically deep. Given our limited time and resource constraints, we can't possibly address all this material in a single MOOC. Yet many students may benefit from learning more about these topics, either during or after the MOOC. Therefore, when there's additional pertinent information on a topic that we can't cover in our videos, we provide links in the PDF versions of the slides that students can download from the MOOC Video Lectures pages. These links point to material on the web so that students can read as their interests and time permits. Following up on all the links is a rewarding, albeit time consuming task. In fact, we term these videos "LembasLectures" since a small dose of them can keep a student nourished (intellectually) for hours! However, none of the quizzes will involve questions related to this material, so students can read them at their leisure. The videos in Section 0 are largely introductory, so feel free to watch them at an accelerated rate of speed if you're willing to read all this FAQ instead.

  9. What is the teaching staff policy for monitoring and answering discussion forum threads and questions?

    The teaching staff will endeavor to reply to thoughtful technical questions as time permits. Often, the responses will point to other resources (such as this FAQ or to video lectures) so that students can learn the details of the solutions on their own, which is more effective pedagogically. Questions posted anonymously will receive little/no attention from the teaching staff since we want to get to know the students in the MOOC so the learning environment will be more like a face-to-face course. Due to extremely limited teaching staffing resources, questions about installing or using Eclipse, Git, the Android Virtual Device emulator, debugger, etc. will need to be addressed by Community TAs and/or other students taking this MOOC. Step-by-step instructions on how to setup an Android development environment using Java, Eclipse, and Git are available here.

    Before posting on the forums, it's important to read, understand, and follow the Coursera Forum Code of Conduct. In particular, rants and flames (such as "Android sucks," "Language X is better than Java," "Patterns are bad," or "I hate these lectures") will be ignored and/or removed since they generate much more heat than light and disrupt the learning process. Moreover, insulting, condescending, disrespectful, or abusive postings will not be tolerated and will result in students being removed from the course.

  10. How many and what types of quizzes and programming assignments will there be in this MOOC?

There will be weekly quizzes, all of which will be auto-graded. The due dates for these quizzes will be the last day of class so you can take them as time permits. There won't be any "late dates" for quizzes since they are due the last day of class.

There will also be ~3 programming assignments in each of these MOOCs. Each programming assignment will be peer graded two weeks after they are released, as described in [FAQ item #34](#34). The assignments will vary for each MOOC offering, but in general they involve applying Android concurrency frameworks to do things like implement an app to download, store, and display images; implement an app that prints "ping" and "pong" successively in different threads; and implement a concurrent version of the “Daily Selfie” app from Prof. Porter's MOOC. All source code examples and skeletons for the programming assignments are available in this [GitHub repository](https://github.com/juleswhite/mobilecloud-15/).
  1. How can students understand and learn the material in the videos most effectively? 
There is no one rate of speaking that's appropriate for all students. For students whose native language is not English--or for any students who find the rate at which the material is presented in the videos too fast to comprehend--we recommend that you decrease the rate at which you play the videos to 0.8x or slower (naturally, for material that you're already familiar with, you might want to increase the rate at which the video plays!). If you need instructions on how to change the rate of playback speed for YouTube videos please do a google search for information about the browser that you're using.

After the MOOCs start you'll also be able to download the videos and use the media player on your computer to obtain fine-grained control over the playback speed. The Coursera platform also provides English subtitles for all the videos based on the scripts we used to record them originally. Likewise, you can enable "captions" via the YouTube player to view subtitles at my [YouTube playlists](https://www.youtube.com/channel/UCt-Wvc_ojTzGLpjhruIXYSw/playlists "Link:
        https://www.youtube.com/channel/UCt-Wvc_ojTzGLpjhruIXYSw/playlists"). In addition, downloading PDF versions of the slides and reviewing them prior to watching the videos may aid with comprehension.

Students may also consider watching the videos multiple times, focusing on different aspects of the material each time (e.g., listening to the voice track, looking at the code and diagrams on the slides, etc.). If you have time, you might also want to read the material referenced by the links provided at the bottom of many slides, which are listed in the [wiki](https://github.com/juleswhite/mobilecloud-15/wiki/Hyperlinks-in-the-lectures) maintained by students.
  1. How do the CS 282 and CS 251 videos relate to the 2015 MOOC videos? 
Many hours of videos from my Vanderbilt courses on Android available on YouTube playlists, including the [2013](http://www.youtube.com/watch?v=lHbIwoevePE&list=PLZ9NgFYEMxp50tvT8806xllaCbd31DpDy)and [2014](https://www.youtube.com/playlist?list=PLZ9NgFYEMxp4KSJPUyaQCj7x--NQ6kvcX)offerings of CS 282 and my [2015](https://www.youtube.com/playlist?list=PLZ9NgFYEMxp7lylj-XC8h1kjatOjbh9ne) offering of CS 251\. These videos overlap with some of the material presented in the 2015 MOOCs. However, these YouTube videos are not a substitute for videos in the 2015 MOOCs, which will be aligned with the programming assignments and topics covered in the MOOC.
  1. What are "Virtual Office Hours"? 
"Virtual Office Hours" (VOH) provide an opportunity for instructors to interact in real-time with students once a week to answer questions about material covered in the video lectures, quizzes, and programming assignments. Google Hangout on the Air and YouTube are used as the means to engage with students in VOH. All VOH sessions will be recorded, captioned, and uploaded to the Coursera website so students can watch them at their convenience offline if they can't make it to the live VOH events. Likewise, questions post to the VOH discussion forums will be answered during the sessions. 

See [this paper](http://www.dre.vanderbilt.edu/~schmidt/PDF/POSA-MOOC.pdf) for more information on VOH. There are YouTube playlists containing VOH videos for the [2013](https://www.youtube.com/playlist?list=PLZ9NgFYEMxp4IcAmAvXPU794VydFkzKeF)and [2014](https://www.youtube.com/playlist?list=PLZ9NgFYEMxp6CV41KZwZGLHo1gD7nbH-l) POSA MOOCs.  The VOH sessions for POA 2015 and beyond are integrated into the weekly videos.
  1. Will there be a Statement of Accomplishment or "with distinction" certificate for students who complete this class? 
No, the only documented way of receiving credit for this MOOC is via the Signature Track, where students who achieve the stated criterial receive a "Verified Certificate." Moreover, there's only one track, i.e., there are no "normal" vs. "with distinction" tracks. If you want to be eligible to take the Capstone project course, you'll also need to follow the instructions described in the next FAQ entry below.
  1. Who is eligible to take the MoCCA Specialization Capstone project course? 
Like all Coursera Specializations, the Capstone project course is only available to students who take the Signature Track for the preceding MOOCs in the Specialization. Moreover, only students in the Signature Track who receive a "Verified Certificate" in all preceding MOOCs *prior to the start* of the Capstone project course are eligible to enroll. If you didn't attain a Verified Certificate in Professor Porter's MOOCs in the MoCCA Specialization, you are still welcome to attempt a Verified Certificate in the remaining MOOCs in the MoCCA Specialization. If you succeed in attaining the Verified Certificates in these other MOOCs all you'll need to do is take Professor Porter's MOOCs when they are offered next, at which point you'll be eligible to take the next offering of the Capstone project course once you'll successfully attain a Verified Certificate in all the MOOCs.

Students who took the first offering of the MoCCA Specialization in 2014 need to have achieved a "Verified Certificate with Distinction" to be eligible for the MoCCA Capstone. Students who take subsequent offerings of the MoCCA Specialization need only achieve a "Verified Certificate" to be eligible for the MoCCA Capstone since subsequent offerings of the MoCCA Specialization require all students who achieve a "Verified Certificate" to complete the programming assignments successfully.
  1. Do students who took the previous offering of MoCCA Specialization in 2014 need to retake them to continue with subsequent MoCCA Specialization series? 
If you have already earned a Verified Certificate with Distinction in any of the 2014 offerings of MOOCs in the MoCCA Specialization you do not need to retake the corresponding pair(s) of new MOOCs again to continue towards the MoCCA Specialization certificate and final project in 2015\. Please consult the [Specializations Help Center](https://courserahelp.zendesk.com/hc/en-us/articles/201223289-Specializations) or contact the [Coursera support team](https://courserahelp.zendesk.com/hc/en-us/requests/new?ticket_form_id=19009) if you are not sure whether you qualify.
  1. What is a "trans-institutional MOOC Specialization"? 
This MOOC and two other MOOCs ([Programming Mobile Applications for Android Handheld Systems](https://www.coursera.org/course/android "Link:
        https://www.coursera.org/course/android") taught by [Professor Adam Porter](http://www.cs.umd.edu/~aporter) from the University of Maryland and [Programming Cloud Services for Android Handheld Systems](http://www.coursera.org/course/mobilecloud "Link:
        http://www.coursera.org/course/mobilecloud") taught by Jules White from Vanderbilt University) have been designed to complement each other as part of the Coursera Specialization on [Mobile Cloud Computing with Android](https://www.coursera.org/specialization/mobilecloudcomputing2/36 "Link:
        https://www.coursera.org/specialization/mobilecloudcomputing2/36"). In particular, the programming assignments and the course project for the MOOCs will be coordinated. Additional information on our trans-institutional MOOC Specialization is available [here](http://www.youtube.com/watch?v=JSkvChTSanM "Link:
        http://www.youtube.com/watch?v=JSkvChTSanM").

  1. Is it necessary to take the MOOCs in the MoCCA Specialization in a particular order?

    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, the material in each MOOC assumes you've mastered the material in previous MOOCs, so if you don't have this knowledge you may be lost (see FAQ item #7 about for suggestions on what you'll need to know and how to learn it). Naturally, 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. Moreover, if you want to take the Capstone project course you'll ultimately need to successfully complete all the MOOC in the Specialization, as described in FAQ item #15.

  2. Can Android Studio be used as the development environment for these MOOCs?

You're welcome to use Android Studio as your development environment since the Java code skeletons we provide along with the assignment projects should work with either Eclipse or Android Studio. Moreover, you only need to upload Java source files to the Coursera peer evaluation site, so these Java files should also work fine with either Eclipse and Android Studio during the peer assessment process. Please make sure to use Android 5.1 (API version 22) with Android Studio since there seem to be bugs with the Android Studio emulator for Android 5.0\.

 Please note that if you want to use the [SureLogic](http://www.surelogic.com/) concurrency analysis tools (see [FAQ item #63](#63)) to help find race conditions and other concurrency hazards in your programs you'll need to use Eclipse since these tools only work as an Eclipse plug-in at this point. You're not required to use these tools, though they are_very_ helpful in pinpointing bugs in concurrent programs (speaking from personal experience).
  1. 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 "Suggested Reading" on the [POSA course webpage](https://www.coursera.org/course/posa) for a list of books that are closely related to the topics of the course.
  1. Where can students learn about how to configure their Android and Java environment to run the examples and complete the programming assignments? 
Programming assignments for these MOOCs will use the Eclipse Android Development Tool (ADT) environment. Instructions on how to setup the software development environment is available [here](https://class.coursera.org/posaconcurrency-003/wiki/Installing_and_Using_Eclipse_and_Git). If you're using a different development environment (such as Android Studio) or a different build tool (such as [Maven](https://code.google.com/p/maven-android-plugin/)) you'll need to enlist the help of the Community TAs and other students on the online discussion forum.
  1. Where can students learn more about patterns and frameworks? 
The best ways to learn more about patterns and frameworks involve:
  • Reading the patterns and frameworks literature (e.g., the GoF and POSA books)
  • Reading lots of pattern- and framework-oriented software (e.g., java.utils.concurrent, Android source code, the examples from these MOOCs, etc.) and mapping the patterns from the literature to the patterns in the software
  • Writing lots of pattern-/framework-oriented software and continually refactoring your code using different patterns to hone your intuition.
Naturally, this process doesn't happen overnight - we've been doing this for 20+ years and we still learn something new nearly every day! 
 Other videos about patterns and frameworks appeared in Section 2 and the Appendix of the [Spring 2013 offering of the POSA MOOC](http://www.dre.vanderbilt.edu/~schmidt/Coursera/spring-2013-posa.html). You can find links to all these videos [here](https://class.coursera.org/posasoftware-001/lecture/index), though you will need to register first at [this link.](https://www.coursera.org/course/posasoftware) If you're a Safari online book club member you should check out the [Design Patterns in Java](http://www.dre.vanderbilt.edu/~schmidt/LiveLessons/) video training series that covers the "Gang-of-Four" design patterns.  You may also want to try implementing the assignments given in my [CS 282](http://www.dre.vanderbilt.edu/~schmidt/cs282/index.html#assignments "Link: http://www.dre.vanderbilt.edu/~schmidt/cs282/index.html#assignments") and [CS 251](http://www.dre.vanderbilt.edu/~schmidt/cs251/index.html#assignments) classes at Vanderbilt.
  1. Which versions of software are required for these MOOCs 
The following software is required for these MOOCs:

*   Android version 5.x (e.g., API version 22), also known as "Lollipop".
*   Java 7.
*   Spring.
*   Eclipse Juno version or later (e.g., Kepler or Luna). See [FAQ item #19](#19) for information on using Android Studio.

You're welcome to use whatever Android version works best for you during development, but make sure that your solution works with API version 5.x--and use version 5.x for peer evalution--so that everyone is using the same version to avoid inconsistencies during the assessments.  In addition, Coursera recommends using the Chrome and Firefox browsers to view the course material. There's also a [mobile app](https://learner.coursera.help/hc/en-us/articles/201522945-Recommended-Browsers-and-Devices) for Coursera MOOC, as well.
  1. Can students use programming language [X] for the course? 
The programming assignments in the Android portion of this course are designed for the Java programming language. The cloud computing portion may provide more flexibility, but it will also focus largely on Java, as well. Although you're welcome to use other languages on Android for your personal edification, 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](https://learner.coursera.help/hc/en-us/articles/
201212339-Peer-Graded-Assignments).
  1. Where are the slides and source code presented in the videos and the code skeletons provided for the programming assignments? 
PDF versions of the slides will be available for download after the videos are released onto the MOOC websites each week. If you look at the left frame of the MOOC sessions page, you will see the Video Lectures link.  Follow that and you will see the lectures.  The slides can be viewed or downloaded by clicking on the link at the right that looks like a piece of paper.  The PDF versions of the slides have clickable links to make it easy to navigate to the supplemental material referenced in the slides.  The source code examples referenced in the slides can be obtained by clicking on the corresponding links.

We've created GitHub repositories for the 2015 MOOC assignments and examples. The POSA repository can be accessed [here](https://github.com/douglascraigschmidt/POSA-15) and the MobileCloud repository can be accessed here [here](https://github.com/juleswhite/mobilecloud-15). You can either install/use GitHub to access each folder in the repository (as described [here](https://class.coursera.org/posaconcurrency-003/wiki/Installing_and_Using_Eclipse_and_Git "Link: https://class.coursera.org/posaconcurrency-003/wiki/Installing_and_Using_Eclipse_and_Git")) or you can download it in a single zip file. We_strongly_ recommend you learn to use Git rather than downloading the zip file.

You can browse the latest/greatest Android source code online [here](https://android.googlesource.com "Link: https://android.googlesource.com") or download it [here](http://source.android.com "Link: http://source.android.com"). Likewise, you can browse the latest/greatest Java source code online [here](http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src) or download it [here](http://www.mkyong.com/java/where-to-download-jdk-source-code/). For example, if you want to find implementations of the Thread class (both Java and C++ versions) simply google "Thread site:android.googlesource.com" in your browser and you'll get a list of relevant links containing the implementations.
  1. How will the 2015 offering of these MOOCs differ from previous offerings? 
The material from the earlier MOOCs is available as follows:

*   **2014 POSA MOOC** -- All the video lectures, assignments, quizzes, and discussion forum postings from the 2014 offering of the POSA MOOC is available [here](https://class.coursera.org/posa-002/lecture/index), though you will need to register first at [this link.](https://www.coursera.org/course/posa) A summary of the 2014 POSA MOOC is also available [here](http://www.dre.vanderbilt.edu/~schmidt/Coursera/spring-2014-posa.html).
*   **2013 POSA MOOC** -- All the video lectures, assignments, quizzes, and discussion forum postings from the 2013 offering of the POSA MOOC are available [here](https://class.coursera.org/posasoftware-001/lecture/index) so you can rewatch the older videos for more information on the themes of object-oriented software patterns, frameworks, and design dimensions. To access this material you will need to register first at [this link.](https://www.coursera.org/course/posasoftware) A summary of the 2013 POSA MOOC is also available [here](http://www.dre.vanderbilt.edu/~schmidt/Coursera/spring-2013-posa.html).

Although the 2015 MOOCs cover some of the same topics as these previous MOOCs, they will differ in several respects. For example, the 2015 MOOCs won't cover some of the more "abstract" topics we discussed in the 2013 POSA MOOC. For example, we won't have (new) videos on pattern relationships (e.g., pattern sequences, pattern languages, etc.), general discussions of frameworks, design dimensions of concurrency and networking, overview of middleware stacks, etc., since that's outside the scope of Android. Likewise, the 2015 MOOCs differ from the 2014 POSA MOOC since not only is there new material on Android concurrency, but the bulk of the lectures will be live, so there's more opportunity to ask questions. The 2015 MOOCs cover many POSA and GoF patterns addressed in Section 3 of the 2013 POSA MOOC, though they'll be presented in the context of Java and Android instead of C++ and ACE.
  1. How does the coverage of Android concurrency in Part 2 of the MoCCA Specialization compare/contrast with the coverage in Part 3? 
Part 2 has ~30 minutes worth of coverage on topics pertaining to concurrency in Android. Part 3 has ~6 hours worth of coverage on these topics. It's therefore_much_ more in-depth, focusing on the patterns, frameworks, and best-practices of writing concurrent programs in Android. In addition to showing how to write concurrent Android applications, we'll also walk through the source code implementing the concurrency frameworks provided by Android itself. Moreover, there will be multiple programming assignments that will provide learners with opportunities to practice developing non-trivial concurrent Android applications.
  1. Why do these MOOCs' names start with "posa"? 
All MOOCs [I](http://www.dre.vanderbilt.edu/~schmidt/) teach on the Coursera platform have a focus on [pattern-oriented software architecture](http://www.dre.vanderbilt.edu/~schmidt/POSA) (POSA), which is a software development paradigm that applies patterns to guide the design and implementation of software frameworks, components, and applications. The details of what sorts of patterns--and what applications of patterns we'll cover--differ from MOOC-to-MOOC, but the patterns focus is consistent - hence the common prefix for the names.
  1. What are the plans/schedule for offering the MoCCA Specialization again in the future? 
We plan to offer the entire MoCCA Specialization again in the future, starting in with Part 1 of Professor Porter's <A HREF="https://www.coursera.org/course/androidpart1">Programming Mobile Applications for Android Handheld Systems</A>.  Each Vanderbilt MOOC runs six weeks, with a week or two between MOOCs. As soon as the final schedule is set the start dates will be posted [here](https://www.coursera.org/specialization/mobilecloudcomputing2/36). Note that Prof. Porter's MOOCs at the University of Maryland run more often than the other MOOCs in the MoCCA Specialization. We also hope to increase the frequency at which the Vanderbilt MOOCs are offered.
  1. How long will the course material be available online after the MOOC ends? 
We keep the videos, presentations, discussion forum postings and responses, etc. available as long as Coursera allows, so the existing material should be available unless they remove it for some reason beyond our control. The programming assignments, however, are only available during the period in which the MOOC is active.  When we migrate to the new on-demand system the programming assignments will also be available as long as Coursera allows.
  1. Where is the source code that corresponds to the pathnames embedded in the slides shown in the videos? 
All the Android source code referenced by the pathnames in the slides shown in the videos is available for browsing online [here](https://android.googlesource.com "Link: https://android.googlesource.com") or for downloading [here](http://source.android.com "Link: http://source.android.com"). Likewise, you can browse the latest/greatest Java source code online [here](http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src) or download it [here](http://www.mkyong.com/java/where-to-download-jdk-source-code/). For example, if you want to find implementations of the Thread class (both Java and C++ versions) simply google "Thread site:android.googlesource.com" in your browser and you'll get a list of relevant links containing the implementations.

 If you download this source code to your computer the pathnames will be relative to the top-level source directory and typically start with the bionic, dalvik, frameworks, libcore, or packages pathname prefixes. The source code shown for more examples is based on Android 5.x, which is the so-called "Lollipop" release. The code we examine, however, should be largely the same in other versions of Android, as well.
  1. Will there be much flexibility in the schedule of deadlines for programming assignments in these MOOCs? 
There will be **no** flexibility in the schedule or partial credit for the programming assignments since this causes chaos with the peer grading system and greatly increases the load on the teaching staff, which is very small and has no spare time to keep track of flexible deadlines. However, students who unable to do the assignments in the allotted time frame should consider "auditing" the MOOCs for this offering and then take it again when it's offered again in the future. Please see [FAQ item #29](#29) for more information on when these MOOCs may be offered again.
  1. How closely aligned will the programming assignments be between MOOCs in the MoCCA Specialization? 
The instructors for all the MOOCs are working together to ensure the projects are properly aligned, though it won't be necessary to have completed the previous project(s) in a given MOOC. Moreover, the other programming assignments in their MOOCs will reflect the focus of their respective MOOCs since (1) the topics are largely different in each MOOC and (2) there's no requirement that students must take the MOOCs in a particular sequence, so inter-MOOC dependencies will be minimized.
  1. How will the programming assignments be obtained, submitted, and assessed? 
Programming assignments will be released via [GitHub](https://github.com/juleswhite/mobilecloud-15/tree/master/assignments) (we sometimes release previews of the assignments on GitHub as we finish them, so if you don't see an assignment posted on GitHub yet it's because we're still working on it). There may be some minor changes to the assignments and skeleton code before they are officially submitted for peer assessment. As long as you're using Git correctly you should have no problems merging these changes into your local copies. 

 Every assignment will be due at least two weeks from when it is released. Since concurrent programs do not lend themselves to deterministic auto-graded tests, we use peer assessment, where five other students in the MOOC compile/run the submitted solutions to ensure that the solution actually produces the expected output (i.e., isn't "faked") and to check other properties of a correct solution that may not be correctly assessed by automated regression tests, which aren't always accurate for concurrent programs.

As the assignments are released (and prior to their due date) we'll use the Coursera Peer Assessment mechanism to do the actual submissions.  The criteria for peer assessment will be specified in the Peer Assessment description and explained in detail in a Virtual Office Hour session [FAQ item #13](#13) held the day after the deadline for submitting a programming assignment.
  1. Will the links in the MOOC lecture videos be made clickable and/or consolidated into a single convenient location? 
Students in these MOOCs are crowd-sourcing the links from all the lecture slides and adding them to this [wiki](https://github.com/juleswhite/mobilecloud-15/wiki/Hyperlinks-in-the-lectures), so please contribute to this effort. All the lecture slides will be available in PDF form after the videos have been uploaded to the Coursera MOOC websites each week, so you can also access the links that way. Note that the "Introduction" videos have no associated PDF files.
  1. Where are good sources of tutorials and examples for Java and Android concurrency mechanisms? 
Concurrency and communication are not easy topics to master, so students should leverage multiple sources of learning. Nearly every video in Section 1 (and beyond) has code fragments straight out of Android, all of which is available from [source.android.com](http://source.android.com/ "Link:
        http://source.android.com/"). The Java code from the [java.util.concurrent](http://developer.android.com/reference/java/util/concurrent/package-summary.html)package in libcore/luni/src/main/java/java/util/concurrent is an excellent way to see how Java concurrency mechanisms covered in the MOOC videos are developed and used in practice. We've developed complete example programs for these MOOCs that are available [here](https://github.com/douglascraigschmidt/POSA-14/tree/master/ex). There's also example code in the assignments available [here](https://github.com/juleswhite/mobilecloud-15/tree/master/assignments), though you'll need to fill in the "TODO" comments to get them to work.

Students who are Safari online book club members should check out my LiveLessons courses on [Java Concurrency](http://www.dre.vanderbilt.edu/~schmidt/LiveLessons/CPiJava) and [Design Patterns in Java](http://www.dre.vanderbilt.edu/~schmidt/LiveLessons/DPiJava), which also contain source code on my [GitHub](http://www.github.com/douglascraigschmidt/Livelessons) repository. Other useful tutorials on Java concurrency mechanisms appear [here](http://docs.oracle.com/javase/tutorial/essential/concurrency)and [here](http://tutorials.jenkov.com/java-util-concurrent/). Finally, consider reading the books listed in the "Suggested Readings" Section of the MOOC pages.
  1. How can students keep informed about important due dates for assignments? 
Once the 2015 MOOCs have officially begun, there will be a calendar of events listing the due dates, etc. Likewise, reminders will be posted periodically to the Announcements page (and thus disseminated via email to all enrolled students). Ultimately, however, students are responsible for keeping track of the deadlines and procedures related to properly submitting the MOOC assignments. Given the large number of students enrolled in the MOOC, there will be_no_ support for individual extensions or special handling of late or improperly submitted solutions to the assignments.
  1. How many hours per week will be required for these MOOCs? 
There's no 100% accurate way to estimate how long any given student will require to watch the videos and complete the quizzes and assignments each week since each person has different background, aptitude, motivation, learning style, etc. Concurrency and communication are not easy topics to master, however, so be prepared to put in a significant amount of time if you want to get the most out of this MOOC.
  1. What are some consequences of the "massiveness" of a MOOC? 
The massive number of students in these MOOCs (20,000+) impacts some aspects of the course that differentiate it from a traditional face-to-face courses, such as the courses the instructors teach at Vanderbilt and the University of Maryland. In particular:

*   The MOOC teaching staff will not provide individual feedback on student assignments, so please don't send us email directly. We will, however, present our solutions to the assignments in the weekly "Virtual Office Hours" described in [FAQ item #13](#13). See [FAQ item #65](#65) for suggestions on what to do if you run into problems.

*   Some things will inevitably go awry, e.g., peer graders will undoubtedly not follow the rubric correctly, unit tests will need to change, students will forget to add their source code when they submit their solutions, important deadlines will be missed due to unforeseen circumstances, assignments will be modified after they are released, etc.

*   The lecture form and/or content will not be tailored to the individual needs of each student.

Due to the massive number of students--coupled with the very limited teaching staff--it's unfortunately sometimes the case that the instructors won't be able to "make it right" in a manner that makes everyone happy. In these situations, our goal is to maximize the opportunity for as many students as possible to gain access to a world-class education. Other considerations (such as consistency, fairness, and accountability) are also relevant, but our first priority is to help empower students with an education that will improve their lives.
  1. How much of the Android software stack is covered by the MoCCA Specialization? 
The MOOCs that comprise the [MoCCA Specialization](https://www.coursera.org/specialization/mobilecloudcomputing2/36) cover a wide range of Android and Cloud Computing middleware and application topics, as summarized in [this overview video](https://www.youtube.com/watch?v=JSkvChTSanM). However, this Specialization does not (yet) cover the [full stack](https://www.facebook.com/note.php?note_id=461505383919) of Android and Cloud Computing software. In particular, the Android Linux kernel, user-level device drivers, native development kit, Dalvik virtual machine, and C/C++-based library and service layers are not covered in detail. Future offering of the MoCCA Specialization will (hopefully) provide more coverage of these topics, as time and resources permit.
  1. Can students use public source code repositories to store their solutions to the programming assignments? 
<p>Please do not use public source code repositories (e.g., a freely available <A HREF="http://www.github.com">GitHub</a> accounts, which are public) to store your solutions to the programming assignments. Likewise, do not post your solutions as a pull request to our Github accounts.  Publically available repositories encourage students to copy each others work, which is a violation fo the Coursera code of conduct that does not allow students to share work unless explicitly instructed by course policies.  <A HREF="http://www.gitlab.com">GitLab</a> provides freely available private accounts, so you might want to check them out. </p>
  1. What are some good techniques, tools, and methods for visualizing, analyzing, and debugging concurrent Java programs. 
Debugging concurrent programs is hard due to a variety of accidental and inherent complexities. There are many resources available to help students debug their concurrent programs, some of which are free, some of which aren't, and some are a mixture of free and non-free. The [Thread Scheduling Visualizer (TSV)](http://docs.oracle.com/javase/realtime/TSV/JavaRTS-TSV.html#introduction) is a set of tools that provide an easy way to record and visualize thread scheduling. The [Fluid project](http://www.fluid.cs.cmu.edu:8080/Fluid) provides a set of tools for programmers to analyze, assure, and evolve multi-threaded Java programs. Some tips on debugging multi-threaded program are available [here](http://www.drdobbs.com/cpp/multithreaded-debugging-techniques/199200938).
  1. Where is the source code for examples and assignment solutions from the Vanderbilt courses CS 282 on Android and CS 251 on patterns? 
The [source code](http://www.dre.vanderbilt.edu/~schmidt/LiveLessons/#JavaSourceCode) for the Java variant of the CS 251 "expression tree processing application" is available as part of the supplemental material for the Pearson LiveLessons courses on [Design Patterns with Java](http://www.dre.vanderbilt.edu/~schmidt/LiveLessons/). Other concurrent programming examples are available in the [POSA 15 GitHub](https://github.com/douglascraigschmidt/POSA-15/tree/master/ex/) repository. Other assignment solutions are not available since they form part of the work expected from Vanderbilt students who take these courses.
  1. How much of a focus on patterns and frameworks will there be in this MOOC? 
Patterns and framework provide the foundation for much of the material in this course. There is a short introduction to patterns and frameworks in these MOOCs and other sections focus on POSA and GoF patterns and frameworks applied in Android. Many other videos and other resources related to patterns and frameworks are also available [here](http://www.dre.vanderbilt.edu/~schmidt/DigitalLearning/).
  1. Why are there lecture videos on YouTube and on the Coursera MOOC websites? 
The videos on YouTube and the videos on the Coursera site should be identical, but all videos must be approved by Vanderbilt before they can be uploaded and published on the Coursera MOOC websites. We therefore release them first on YouTube as we complete them so that interested students can preview them and provide feedback so that any mistakes can be fixed before they are released to the Coursera MOOC websites.
  1. Are there other programs students can write to get experience with more advanced Android concurrency and communication mechanisms if they find the programming assignments too easy? 
If you get bored with these programming assignments and want to try writing more interesting programs you have several options:

*   You might try writing the solutions without using any of the provided skeletons.
*   You might try implementing the assignments given in my [CS 282](http://www.dre.vanderbilt.edu/~schmidt/cs282/index.html#assignments "Link: http://www.dre.vanderbilt.edu/~schmidt/cs282/index.html#assignments") and [CS 251](http://www.dre.vanderbilt.edu/~schmidt/cs251/index.html#assignments) classes at Vanderbilt.
  1. Since many assignments have been posted to GitHub can we work on them prior to their official release? 
You're welcome to work ahead on these assignments, which is one reason why release them out early. However, some aspects of the assignments may change based on a number of factors, such as feedback from students, improved JUnit tests, bug fixes, etc. Although it's unlikely you'll need to do a wholesale rewrite of your solution (mostly the JUnit tests should get more thorough) until the assignment is officially posted via the "Programming Assignments and Assessments" tab you'll need to be prepare for some changes if you work ahead.
  1. Where is more information available on Android internals? 
It's worthwhile watching videos on Android's [anatomy and physiology](https://sites.google.com/site/io/anatomy--physiology-of-an-android) and [Dalvik Virtual Machine](https://sites.google.com/site/io/dalvik-vm-internals "Link:
        https://sites.google.com/site/io/dalvik-vm-internals"). Although these are from 2008 they provide a good overview of how Android works internally.
  1. What resources can be used for the weekly quizzes? 
You are welcome to use videos or presentation material when answering the weekly quiz questions.
  1. Can I take Programming Cloud Services for Android Handheld Systems without taking Programming Mobile Services for Android Handheld Systems? 
It is possible to take the cloud course without the mobile services course. However, the cloud course uses the concurrency concepts that are introduced in the mobile services course. If you take both courses, you will have a much stronger understanding of the material and be far less likely to have trouble in the cloud course. We highly encourage students to take both courses.

  1. Which videos have in-video quizzes?

    All "non-introductory" videos have in-video quizzes, which pop up periodically (typically prior to the "Summary" segments) and ask students questions about what they've been watching. All of Section 0 and the intros to each Section are considered "introductory" videos. Likewise, the "Supplemental Lectures" described in FAQ item #3 may not have in-video quizzes. In-quiz videos only appear if you stream the videos from the Coursera server, but don't appear if you download the videos to your local computer first.

  2. What can we do if the audio is out of sync with the video stream when viewed from the course website on Coursera?

You might try playing the videos at a lower resolution if your browser supports this or downloading the to your computer and watching them locally. Apparently, the videos on my [YouTube playlist](https://www.youtube.com/playlist?list=PLZ9NgFYEMxp4tbiFYip6tDNIEBRUDyPQK&feature=mh_lolz "Link:
      https://www.youtube.com/playlist?list=PLZ9NgFYEMxp4tbiFYip6tDNIEBRUDyPQK&feature=mh_lolz") are synchronized better, so you might try watching them (they are identical to what's on the Coursera website).
  1. Why aren't the MOOCs in the MoCCA Specialization identical wrt programming testing procedures? 
The log-based testing techniques and auto-grading tools that Prof Porter used in the [Programming Mobile Applications for Android Handheld Systems](http://www.coursera.org/course/android) MOOC made sense for the user-facing apps that were the focus of his course. They make less sense for the concurrency and communication apps and services we're developing and evaluating in the POSA MOOCs, which are inherently non-determinism and are hard to auto-grade with 100% accuracy. As this Specialization evolves--and if/when more resources become available--we hope to align our approaches so that students can use the most effective tools for the various techniques, methods, and tools covered in each MOOC in the Specialization.  In the mean-time, we'll use peer assessment, as discussed in [FAQ item #34](#34).
  1. What is the naming scheme for the videos? 
The videos are named in order according to the Section and Part they appear, which corresponds to the MOOC syllabi rather than to the week in which they appear (since each new offering of the MOOCs will likely have a different mapping onto weeks, so that information shouldn't be encoded into the names). The optional lectures do not correspond to this naming scheme since they aren't officially part of the MOOCs. If you want to store the videos locally on your computer in a different order (e.g., by week) feel free to rename them when you download them.
  1. Who will define the projects implemented in the Capstone Projects Course? 
Students can choose one project (from a menu of three projects) that the instructors will define. The reasons for this approach are to (1) enhance the consistency of the projects with respect to their difficulty, (2) ensure a critical mass of students for each project who can serve as peer assessors, and (3) avoid complex legal issues associated with intellectual property. Each project will involve elements of each MOOC in the Specialization, i.e., (1) user-facing portions of Android, (2) concurrency, services, communications, and content on Android, and (3) cloud services based on Java and Spring. Each student will own the copyright on his/her solution (which must be completed individually, rather than as part of a team). However, all student solutions must be available in open-source format to enable peer assessment.
  1. What is the best way to handle null references in Java? 
There's a good summary of error handling techniques for Java null references [here](http://stackoverflow.com/questions/5991745/java-null-reference-best-practice). To avoid cluttering the solutions and distracting from the focus on concurrency and communication, the code examples in these MOOCs don't always check for null as thoroughly as production Android code should. In practice, however, we recommend that you apply consistent handling for null Java references in your code.
  1. What are rules for choosing the appropriate Android Context? 
See the discussions [here](http://possiblemobile.com/2013/06/context/) for an overview of which Contexts to choose for different situations.
  1. Can students do extra assignments to improve their grade? 
No, the assignments are peer graded and thus require a non-trivial amount of work from the teaching staff and other students in the class. As a result, there will be no extra assignments.  If you are unable to complete all the assignments please feel free to retake the MOOC the next time it is offered.
  1. How can we convince our colleagues and management of the value of patterns and frameworks in practice? 
As with most issues associated with IT, there's no single "silver bullet" that will convince managers and executives of the "return on investment" (ROI) value of software techniques, tools, and methods (TTMs). Instead, what's required is a long-term commitment (at both the individual and organizational levels) to invest in TTMs that provide tangible payoffs wrt things that matter to managers/executives and (arguably more importantly) to customers/sponsors). The pattern-oriented and framework-oriented TTMs presented through this MOOC are a step in the right direction -- after all, these TTMs underlie much of Android and Java, which would not be as powerful and pervasive without these TTMs. Ultimately, each individual and organization needs to devise a strategy for demonstrating the tangible benefits of patterns and frameworks to the powers-that-be in terms of ROI that they value, such as reducing software defect rates, enhancing productivity across the lifecycle (rather than just "hacking it up and shipping it out"), and increasing the resilience (e.g., to failures and cyber-attacks).
  1. How can I prepare in advance for the upcoming Programming Cloud Services for Android Handheld Systems MOOCs? 
The MobileCloud MOOCs following the POSA MOOCs will cover a number of topics on HTTP-based cloud services with the Java Spring Framework. Before you start preparing for the cloud course, ensure that you understand the concurrency material from the POSA MOOCs, particularly AsyncTasks and Handlers. Some helpful resources to get a jumpstart on the cloud course are:

*   Spring's Building a RESTful Web Service guide ([http://spring.io/guides/gs/rest-service](http://spring.io/guides/gs/rest-service "Link:
                  http://spring.io/guides/gs/rest-service"))

*   Android's Connecting to the Network guide ([http://developer.android.com/training/basics/network-ops/connecting.html](http://developer.android.com/training/basics/network-ops/connecting.html "Link:
            http://developer.android.com/training/basics/network-ops/connecting.html"))

*   For other more advanced topics that are both within and beyond the scope of the cloud course, Spring has a comprehensive set of guides ([http://spring.io/guides](http://spring.io/guides "Link:
            http://spring.io/guides"))
  1. Why have the MOOCs in the MoCCA Specialization been split into multiple courses? 
Each of the original three MOOCs in the Mobile Cloud Computing with Android (MoCCA) Specialization have been split into multiple courses, so there are now a total of seven MOOCs (plus the Capstone course) in the latest Specialization instead of the three MOOCs in the first offering of the Specialization. The motivations for this change are to

*   Provide greater flexibility in terms of scheduling, e.g., so instructors and students don't need to devote 8-10 weeks to a single MOOC without any breaks and
*   Make it easier to reorganize the content of the lectures to convey the material more effectively over the entire Specialization.

We are also considering running the MoCCA Specialization more frequently (e.g., with a new Specialization starting every month -- and ultimately "on-demand"), so it'll be easier for students to fit these MOOCs into their schedules.

In the future, we're also considering extending the MoCCA Specialization (or offering multiple inter-connected Specializations) to create a larger number of shorter classes to cover a wider range of topics that are needed to be effective a developing mobile cloud computing applications/services with Android. In particular, our experience with the first offering of the MoCCA Specialization was that many students had insufficient background in foundational topics, such as object-oriented design and programming, Java, software engineering, concurrency, networking, patterns, etc., which made it hard for them to succeed in mastering the concepts and skills associated with mobile cloud computing. Rather than trying to pack all this material into a small number of long MOOCs, our reorganization/reboot will make it easier to connect a larger number of smaller MOOCs into more comprehensive Specialization(s).
  1. Is there a way to get the Android Virtual Device (AVD) emulator to run faster? 
If you run on an Intel-based development machine we recommend you install the Intel [Hardware Accelerated Execution Manager (HAXM)](https://software.intel.com/en-us/android/articles/intel-hardware-accelerated-execution-manager), which greatly speeds up the performance of the AVD emulator. In order for HAXM to work you'll need an Intel processor with support for Intel VT-x, Intel EM64T (Intel 64), and Execute Disable (XD) Bit functionality, as well as least 1 GB of available RAM.
  1. How can students install/use the SureLogic concurrency analysis tools? 
Installation instructions for the SureLogic concurrency analysis tools are available [here](http://www.surelogic.com/static/eclipse/install.html), a video showing how to install these tools on Android is available [here](http://youtu.be/WrWCiy_xANM), and a video showing how to use the Flashlight tool on an Android application is available [here](https://www.youtube.com/watch?v=WPoccVS4j1k&feature=youtu.be). These tools require that Eclipse run on Java 7\. Moreover, the version of Eclipse must be reasonably modern -- the installation instructions has details on versions of Eclipse that are supported (Android Studio is not yet supported). Please also cut and paste the following pre-activated license:

    [sl-#v1.0#(7da893fe23ff965eb334ac6467d577b05b8e25325644ecc97f0234baa
    1e35e085497104004d41e1ae35bfb453c999cbce66dea1b91bf50a9500acfc5a9ae7
    5fa8794195c2664e1290e9d0d2845d7e504a7033e1a4e549dd24208f4974ea751499
    006c80f4c47bd77829fd34aec706bf991cd15bddc579f0e5ca2a288b4d0a2bfd4882
    833c5eda7a9f5537089fe4e7739436bac84b801ac4e410739db640dcb51976387481
    ec837d077ff84653ad057a524a2205b45024a9dd4f20f238b5f83884e38375df2f09
    add5633b4b91b2e276336e85e398e080d65973ffe4d3fc3210a902733e5dd43eab81
    2c5d8455fca570f2bd32e156399172c511fa2d1f96b54fe3aaO69643d38396666333
    033342d373939372d343031352d623063312d6237323334633631383839370a686f6
    c6465723d547269616c20557365720a70726f647563743d416c6c20546f6f6c730a6
    475726174696f6e496e446179733d34350a696e7374616c6c6174696f6e446561646
    c696e653d323031352d30362d32320a747970653d5573650a6d61784163746976653
    d320a706572666f726d4e6574436865636b3d66616c73650a7e1da)][sl-nc-#v1.0
    #(5f04b42c28e92a118ee3755258b4a165305008e5d5abb11719238994d2647b614d
    63f679000a44ac4d43eda48ac94ac3a0207ee564ee59f9c55a0748a5547cfcd11161
    d86b58b8c459f991aaaa447ff6f5260578606ce2a50a084bd4a775708fe20c4dce15
    b710f54dc359986b98288eb929988e2be4c1c778d41ba59f646b5ea2a60db5f7751d
    c6b693a362f9b674857536082c964d33667f416dd9197ec397a7c18187b80de19c5f
    5d3c84965ea45782d6fbddadc9d0474b09f512f86a8c69e3768dd8e9bd958eba616e
    5c85ac6c2f9c57d672f00287433b7f79b71472b2ccfb49e5be21cbffae35199aa41c
    f3cd6f9d1effbc1ab14b255937eb5033a85fabc4bO69643d38396666333033342d37
    3939372d343031352d623063312d6237323334633631383839370a646174653d3230
    31352d30352d30360a6ae)]
  1. How long does it take for the post-processed videos, subtitles, and downloadable MP4 videos to appear for live lectures? 
One of the innovative aspects of these MOOCs is that many of the lectures are presented live, which helps keep the material "fresh" and the discussions interactive. Post-processed videos of the live lectures are typically available in the "Video Lectures" page of the MOOC around 6-8 hours after the lectures complete.  However, there's a delay of up to several days while the material is encoded for downloading and subtitled, all of which is handled by Coursera rather than the MOOC teaching staff, who have no control over this process, so you'll need to be patient. The Supplemental Lectures are already subtitled, however, so if you'd like to read transcripts of earlier presentations on many of these topics feel free to watch those videos while the encoding and subtitling of the live lectures is occurring.
  1. How can students get help if their solutions to the programming assignments aren't working? 
Although the teaching staff doesn't have the resources to help individual students debug their programs, if you run into problems feel free to post your buggy code to the appropriate assignment discussion forum so that other students can provide you tips on fixing your bugs. Please don't post working solutions to the discussion forum, however, since that violates the Coursera Code of Conduct.
  1. What is a "hook method"? 
A hook method is a specific point in a framework-based program where developers can customize generic framework components with callbacks that the framework invokes to run application-specific logic. Hook methods in Java-based frameworks (such as Android) are typically defined by extending a super class or implementing an interface & overriding a virtual (possibly abstract) method. The run() method in a Java Thread/Runnable is a good example of a hook method that is discussed in the Week 1 lectures.
  1. Why do the times/days of the Live Lectures and Virtual Office Hours change? 
There is no single time/day that is perfect for all the students from around the world. Moreover, I have other commitments during the week. As a result, the times/dates of the Live Lectures and Virtual Office Hours on Google Hangout may change from week-to-week. The schedule of the Google Hangout sessions for each will be posted prior to the start of each week. If you're unable to attend in person please feel free to post questions in the appropriate discussion forum (i.e., either Lectures or Virtual Office Hours) and I'll answer them during the session.
  1. Why do programs fail to download images when running in the Android emulator? 
Typical problems are (1) failure to download the image in a background thread and/or (2) the Android emulator needs to be configured to access the Internet. Information on how to perform this configuration is available [here](http://developer.android.com/tools/devices/emulator.html#emulatornetworking).
  1. Can 3rd-party concurrency libraries or frameworks be used for the programming assignments? 
No 3rd-party concurrency libraries or frameworks can be used for the programming assignments since that would require the peer reviewers to (1) install these libraries/frameworks and (2) understand these libraries/frameworks.
  1. Will the source code for the programming assignment solutions be made available? 
The source code will *not* be made available, but we'll go over the solutions in Virtual Office Hours.
  1. What sorts of classes go into the utils directory and are they always used for each assignment? 
The utils directory in each program provides a library of classes that are useful for various assignments in these MOOCs.  Not every class/method is needed for each assignment, however, though they are kept in one file to maximize reuse opportunities.
  1. Is it necessary to watch the lecture videos prior to doing the programming assignments? 
Yes, because the lecture videos provide many relevant hints and tips for completing the programming assignments correctly.  Moreover, the teach staff will ignore any questions that could be answered by watching the lecture videos, so make sure to watch them prior to starting the assignments.
  1. Can example code be used for the programming assignments? 
Yes, it's fine to use any of the example code provided by the teaching staff in programming assignment solutions.

  1. How Were Professor White's Videos Made and are there PDF Versions of His Material?

    A video showing how Professor White uses a lightboard to film his videos appears here. However, there are no PDF versions of the material he presents - just the videos.

  2. Can the Concepts Covered for Spring be Extended to Other Web Application Frameworks?

    The core concepts of many web frameworks are similar (e.g., Model, View, Controller). However, the implementation details are different. If you understand the underlying concepts, it should be easier to pick up a new web framework. Going from Java Spring to Ruby on Rails, however, may not be a small jump if you aren't already familiar with Ruby or some of the ideas behind Rails. Java web frameworks are probably closer to Spring than non-Java frameworks that don't use annotations.

  3. Can the software examples shown in this MOOC be used by students for other projects?

    Yes, please see the MOOC open-source license for details on how to use the software examples shown in this MOOC in other projects.

  4. What will be the focus of the new POSA Content MOOC?

    The Fall 2015 offering of the MoCCA Specialization will include a new MOOC entitled "Programming Mobile Services for Android Handheld Systems: Content". This MOOC is optional for the Fall 2015 MoCCA Specialization (but will be mandatory for the 2016 MoCCA Specialization) and will be inserted after the "Programming Mobile Services for Android Handheld Systems: Communication" MOOC and before the "Programming Cloud Services for Android Handheld Systems: Spring" MOOC. Here's a rough outline of what will be covered in this MOOC (which is subject to change):

* Section 1: Introduction to Data Management on Android
  • Part 1: Overview of Java and Android File I/O Classes
  • Part 2: Overview of Relational Databases and SQL
  • Part 3: Overview of SQLite
  • Part 4: Programming with SQLite 
* Section 2: Introduction to Content Management on Android
  • Part 1: Overview of Android Content Providers
  • Part 2: Overview of Android Content Resolvers
  • Part 3: Developing Custom Content Providers
  • Part 4: Concurrent and Asynchronous Access to Content Providers 
* Section 3: Synchronizing Client and Server Data via Content Providers
  • Part 1: Using Content Providers to Access RESTful Web Services
  • Part 2: Synchronizing Android Clients and Web Services via SyncAdapters 
* Section 4: Case Study Analyzes of Android Content Management
  • Part 1: The ContactsProvider Case Study
  • Part 2: The HobbitProvider Case Study
  • Part 3: The WeatherService Case Study
  • Part 4: The VideoUploadClient Case Study

  1. Why are all the fields in the example code and assignments prefixed with 'm'?

    This naming convention is used throughout all the Android source code, which is available for browsing online here or for downloading here.

  2. Why is the POSA Communication MOOC longer than the other MOOCs in the MoCCA Specialization?

    The POSA Communication MOOC starts at the end of November and runs during the winter holidays when many students won't be able to participate fully in the course. Therefore, even though there's still ~5 weeks of material in the MOOC (just like the other MOOCs in the MoCCA Specialization), we've scheduled the deadlines to be more flexible to accommodate student holidays.

  3. When will the final grades and certificates be available after the MOOC ends?

    The final grades and certificates are typically available 2-3 weeks after the MOOC ends.

  4. What is the impact of transitioning the MoCCA Specialization to the new Coursera platform?

    The MoCCA Specialization (like a Coursera Specializations) is migrating to the new Coursera platform, which will have the following impacts

    • The future sessions that were open (posacontent, mobilecloudprogram, and mobilecloudsecurity) have been closed for enrollment. Learners who have enrolled and paid for these individual courses will be refunded, as they will run on the new platform. Refunds will be processed in early January, and if they'd like to take those respective courses on the new platform, they can pre-enroll and will have to submit a new payment.

    • Learners that have completed any MOOCs in the MoCCA Specialization on the old platform will receive credit for the respective MOOCs on the new platform.

  • Learners who have paid for and earned/are currently earning any of the certificates need not worry. Their progress will be carried over to the new platform. This includes those currently working in the open session (posacommunication)

  • All bulk pay learners will have their payments carried over to the new platform

  • If a learner has completed any of the four MOOCs in the specialization that come prior to the new MOOC (posacontent, which is described in FAQ item #77), they will have credit for it; therefore it shouldn't hinder their ability to earn a certificate for the entire MOOC Specialization.

  • Some of these resolutions won't be immediately visible as the Coursera engineering teams are working at limited capacity during the holidays. All transitory issues will be handled by the week of January 4th, once Coursera is back up to their full capacity.

Add a custom footer
Add a custom sidebar
Clone this wiki locally