When Udacity launched in summer 2014 course Developing Scalable Apps (with Java), my review here: http://www.the-swamp.info/blog/mooc-udacity-course-review-developing-scalable-apps/ there were requests for same course in Python, fortunately Udacity heard plea and few days ago I accidentally look at courses listing and I noticed Developing Scalable Apps in Python among new courses. 

So I was curious how is it looks like in comparison with Java course. Course is labeled as advanced with prerequisites "You should be fairly comfortable programming in Python, preferably with some experience developing web applications and working with databases for at least a year. You will be developing the backend of a sample app, so you don’t have to worry about HTML or JavaScript." I admit that I didn't devote much of my focus to following lectures, I had it as a background sound while doing something else, so probably I miss something. Also due the lack of time (and laziness) I didn't do code exercises :). 

First thing (I guess expected) is that they copied theoretical videos (non programming parts) from Java course. I can't tell now how many, but by my judgement is at least 50%. Second thing is that this course contains 5 lessons (contrary to 6 in Java course). Those are:

1. Scalability Basics

2. Getting Started

3. Storing and Retrieving Data

4. Advanced Datastore Concepts

5. Advanced App Engine Topics

Missing lecture is about using endpoints in Android application. Github repo with starting points for every lecture is here https://github.com/udacity/ud858. It's like watching theoretical part and do exercises in Python (not Java). I feel like code is also done that way, i.e. like if Java code would be replaced for Python's.  

Mine observations:

- first lesson is about history of scaling and how Google App Engine fits there

- second lesson is project setup plus getting started.

- they mentioned and briefly explain Python's decorators since that's how endpoints are implemented to be used which is good. 

- two lectures are devoted do Datastore, from theoretical part all important parts are explained: strong and eventual consistency, ancestor queries, indexes, queries etc. Programming assignments reflects theoretical instructions, i.e. you build endpoints where you use different types of queries. 

- under Advanced App Engine Topics are Cron, Tasks and Modules. I liked that they explain in more detail how Modules works and how they can be used.

- unfortunately no unit tests (in Java class there are)

- I guess for me biggest take away was finding out about class filterNode(). 

For me the most useful thing was finding out about FilterNode class with which you can dynamically insert filters on certain model properties. when creating instance it takes three arguments: name of the property in string, operation symbol ('>', '<'etc.) and value. simple code snippet to demonstrate:

class MyModel(ndb.Model):
    count = ndb.IntegerProperty()
    
    @classmethod
    def query_test(cls):
        q = cls.query()
        f = ndb.query.FilterNode('count', '>', 3)
        q = q.filter(f)
        results = q.fetch(10)
        return results

- I am a bit struggling here since writing Request & Response Messages for models is kinda violating of Don't Repeat Yourself, since in Message classes usually all fields are used from Model so when defining Message class it's like copying fields from Model. At least they could mention excellent endpoints-proto-datastore library (not part of GAE SDK) which does just that: exposes Models as Endpoints. I guess the focus was on pure Endpoints. 

- I think going through course without previous experience with Google App Engine would take a little bit more time to consume in my opinion

Overall I think it's good experiance to make through coding exercises and create simple backend (and see in frontend result). I don't know if it's somehow biased but I was more excited going through Java course, probably because it was first time now it's basically the same, just in different language :) plus I did several projects with Python Endpoints so it was just walk through.