Errata

The link to the quick start guide for App Engine is incorrect. The PDF uses:

http://console.developers.google.com/start/appengine/


The correct link actually uses https and must not have a '/' character on the end.

The correct URL is:

https://console.developers.google.com/start/appengine


Google "officially" links to this URL in "step 2" on the Cloud SDK at https://cloud.google.com/sdk/ which you refer to in the previous paragraph.


This is from the PDF version dated September 25th, 2014

Note from the Author or Editor:
Fixed in draft.

The text in paragraph 2 talks about calling getProperty() and calling intValue() on it. However, the code above on page 44 actually calls doubleValue()

PDF version dated 25th September 2014

Note from the Author or Editor:
Accepted. Updated the tip, which had several statements made inaccurate by a previous change from int to double.

The text in the PDF says:

"You can have up to 25 projects per Google account"

This is not actually true as according to the "Google App Engine General Questions" at https://cloud.google.com/appengine/kb/general#create it says:

"Each account can host 25 free applications and an unlimited number of paid applications Google App Engine."

Perhaps the PDF text should be updated to include the word "free" so it becomes:

"You can have up to 25 free projects per Google account"


This is from the PDF version dated September 25th, 2014

Note from the Author or Editor:
Accepted, updated in draft.

The servlet mapping is inconsistent with the descriptive text in the paragraph above which says "includes the <servlet-name> that matches a servlet declaration, and a <url-pattern>".

The example actually contains a "url-mapping" which is incorrect . It should be a "url-pattern"


PDF version dated 25th September 2014

Note from the Author or Editor:
Accepted, corrected here and in a later chapter in draft.

The PDF says:

"An application can only be uploaded a limited number of times per day, currently 1,000."

This looks to be incorrect as the current limit appears to be 10000. See https://cloud.google.com/appengine/docs/quotas#Deployments which says:

"Deployments
The number of times the application has been uploaded by a developer. The current quota is 10,000 per day."


This is from the PDF version dated September 25th, 2014

Note from the Author or Editor:
Accepted. I just removed the paragraph, since 10,000 times a day is once every 9 seconds, and is not really a notable limit.

The PDF says:

"The Java runtime environment uses the Java 6 virtual machine (JVM)."


This seems to be incorrect as it appears that Java 7 is used and not Java 6. This is confirmed by the Google documentation at https://cloud.google.com/appengine/docs/java/#Java_Introduction which says:

"App Engine runs your Java web application using a Java 7 JVM in a safe "sandboxed" environment."


Also, in the release notes at https://code.google.com/p/googleappengine/wiki/SdkForJavaReleaseNotes, it appears that Java 6 support was dropped in version 1.9.0


This is from the PDF version dated September 25th, 2014

Note from the Author or Editor:
Fixed in draft: replaced two remaining instances of "Java 6" with "Java 7."

The page is taking about the get() method on the DatastoreService and says:

"The get() method returns null if no entity with that key exists."

Reading the JavaDoc for the DatastoreService at https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/datastore/DatastoreService#get(com.google.appengine.api.datastore.Key) it says:

"EntityNotFoundException - If the specified entity could not be found."

The JavaDoc seems to suggest that the get() method does not return null but rather throws EntityNotFoundException. I have not actually tested this with code. I am just comparing the JavaDoc with the PDF


This is from the PDF version dated September 25th, 2014

Note from the Author or Editor:
Fixed in draft.

The text is referring back to the get() method returning null if not found but this is not true. The PDF text says:

"As with the non-batch call, the value for a key is null if there is no entity with that key."

The documentation at https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/datastore/DatastoreService#get(java.lang.Iterable) says:

"The result Map will only contain Keys for which Entities could be found. "


This is from the PDF version dated September 25th, 2014

Note from the Author or Editor:
Fixed in draft.

The PDF says:

"If a query is likely to have only one result, or if only the first result is desired, calling the asSingleEntity() method retrieves the result and returns an Entity object, or null ."

This does not match up with the Javadoc at https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/datastore/PreparedQuery#asSingleEntity() which says:

"Retrieves the one and only result for the Query.
Returns:
the single, matching result, or null if no entities match
Throws:
PreparedQuery.TooManyResultsException - if more than one result is returned from the Query."


The wording in the PDF does not match this Javadoc as the PDF suggests that if there are 2 results then it will return the first result. However, the Javadoc says it will throw TooManyResultsException


This is from the PDF version dated September 25th, 2014

Note from the Author or Editor:
Fixed in draft.

The second code example shows 0 being passed in as the second parameter to the addChild() method.

Reading the documentation for KeyFactory.Builder().addChild(), from https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/datastore/KeyFactory.Builder#addChild(java.lang.String, long) it says:

"id - the numeric identifier of the child in kind, unique across entities of this kind with the same parent, must not be zero"

This seems to suggest that the second id parameter cannot be 0

When I try to run the code that adds a child with 0 as the id, I get:

java.lang.IllegalArgumentException: id cannot be zero
at com.google.appengine.api.datastore.KeyFactory.createKey(KeyFactory.java:52)
at com.google.appengine.api.datastore.KeyFactory.createKey(KeyFactory.java:47)
at com.google.appengine.api.datastore.KeyFactory$Builder.addChild(KeyFactory.java:289)


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The PDF says:

"If the transaction cannot be committed due to a concurrency failure (or other datastore error), the commit throws a DatastoreFailureException :"

This does not match the Transaction.commit() Javadoc at https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/datastore/Transaction#commit() it says that the commit method only throws DatastoreFailureException "If a datastore error occurs."

The commit method throws java.util.ConcurrentModificationException for concurrency problems and java.lang.IllegalStateException for rollback, etc problems


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The example code to retry the transaction will not actually retry the transaction for a concurrency failure as it only retries if a DataStoreFailureException is thrown. It should be retrying for ConcurrentModificationException

See the example code provided by Google at:

https://cloud.google.com/appengine/docs/java/datastore/transactions#Java_Uses_for_transactions



Also reading the Javadoc for DataStoreFailureException at https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/datastore/DatastoreFailureException it says:

"DatastoreFailureException is thrown when any unknown error occurs while communicating with the data store. Clients should not attempt to retry after receiving this exception."

Notice the comment to not retry when this exception is thrown.


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The code in the second example does not compile due to the line:

Entity child = new Entity("MyKind", parent);

There is no Entity constructor that takes a String and a Entity.

I believe the code should be:

Entity child = new Entity("MyKind", parent.getKey());


There is also an example of this in the Google documentation at https://cloud.google.com/appengine/docs/java/datastore/entities#Java_Ancestor_paths


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The start of the paragraph above the final code sample says:

"If you’d prefer not to create a dependency on an App Engine–specific class,..."

The code example immediately below this then has an import statement that lists a Google App Engine class:

"import com.google.appengine.api.datastore.Key;"

As the code example does not use the Key class, this import statement can be removed.


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The PDF states:

"If you are only expecting one result, you can call getSingleResult() instead. This gets the first result if any, or null if there are no results:"

According to the JavaDoc for getSingleResult(), at http://docs.oracle.com/javaee/5/api/javax/persistence/Query.html#getSingleResult(), the method call does not return null - it throws exceptions to indicate no results/more than 1 result. The Javadoc says:

NoResultException - if there is no result
NonUniqueResultException - if more than one result


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The PDF says:

"To read the unit tests, click the Source tab, then click Browse in the navigation bar. The path is svn/trunk/tests/org/datanucleus/store/appengine/."


It looks like the unit tests are now in:

svn/trunk/tests/com/google/appengine/datanucleus/


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The PDF says:

"Memcache integers are 64 bits in size. Incrementing beyond the maximum 64-bit integer causes the value to wrap around to 0, and decrementing has the same behavior in reverse."

It appears that according to the Javadoc at https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/memcache/MemcacheService#increment(java.lang.Object, long) when incrementing and number wrap around occurs, the value is the "signed 64-bit min (-2^63 )"

The Javadoc says:

"Incrementing by positive amounts will reach signed 64-bit max ( 2^63 - 1) and then wrap-around to signed 64-bit min (-2^63 ), continuing increments from that point."


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The code example contains the following line:

result = memcache.increment(key, 9, 0);

This code does not compile and produces the following error:

The method increment(Object, long, Long) in the type MemcacheService is not applicable for the arguments (Object, int, int)


The problem is that Java will not autobox the third parameter from an int primitive to a Long object. The line of code needs to be updated to add an 'L' to the third parameter:

result = memcache.increment(key, 9, 0L);

Ideally, an 'L' should be added to the second parameter to identify it as a long but Java will auto convert an int to a long.


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The PDF states:

"The three-argument form of this method returns a java.util.Set<T> containing all the keys not set by the call."

This seems to be backwards compared to the Javadoc at https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/memcache/MemcacheService#putAll(java.util.Map, com.google.appengine.api.memcache.Expiration, com.google.appengine.api.memcache.MemcacheService.SetPolicy) which states:

"Returns: the set of keys for which entries were created. Keys in values may not be in the returned set because of the policy regarding pre-existing entries."

The rest of the paragraph will need to be updated too.



Additionally, the code sample following the paragraph will also need to be updated as the memcache,putAll(valueMap) method is a void method so does not return a Set


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The last sentence says:

"A request can be up to 5 megabytes in size (including headers)...."

Looking at the latest documentation at https://cloud.google.com/appengine/docs/java/urlfetch/#Java_Quotas_and_limits it appears that the current limit is actually 10 megabytes.


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

There is another reference to the 5 megabyte request limit.

"The request can be up to 5 megabytes in size"

Looking at the latest documentation at https://cloud.google.com/appengine/docs/java/urlfetch/#Java_Quotas_and_limits it appears that the current limit is actually 10 megabytes.


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The PDF states:

"Currently, common file archive types, like .zip, are also not allowed."

According to https://cloud.google.com/appengine/docs/java/mail/#Java_Sending_mail_with_attachments it looks like you can now send zip files as the file type is listed in the allowed MIME Type table.

There is a note at the end of the table about what can be in the zip file and there are some file extensions that are not allowed.


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The PDF states:

"Calling this object’s getStatusMap() method returns a Map<JID, SendResponseStatus>"

According to the Javadoc at https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/xmpp/SendResponse#getStatusMap() the actual type of the value for this map is "SendResponse.Status" and not "SendResponseStatus" as reported in the PDF.

The difference is the missing '.' character between "SendResponse" and "Status"


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The code example in the PDF uses PresenceType.AVAILABLE for both if statements:

if (presence.getPresenceType() == PresenceType.AVAILABLE) {
...
} else if (presence.getPresenceType() == PresenceType.AVAILABLE) {
...
}


The second if statement should be comparing against PresenceType.UNAVAILABLE i.e.

} else if (presence.getPresenceType() == PresenceType.UNAVAILABLE) {


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft. (A 1st ed. code sample typo. whew.)

The final code sample in the PDF on page 327 that uses etaMillis() does not compile because the number 1356940800000 is too long for a Java integer.

The final line needs to be changed by adding an 'L' character at the end of the number so it becomes:

.etaMillis(1356940800000L));


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The comment above the code sample says that 1356940800000 is "December 31, 2012, midnight UTC"

Decoding this epoch, it appears to actually be "Mon Dec 31 2012 08:00:00 UTC". See http://currentmillis.com/ as an example of one of the many websites that will do the conversion.

It appears that 1356940800000 is "December 31, 2012, midnight Pacific Time"

The correct value for UTC is 1356912000000


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The code in the code sample at the top of the page does not compile due to the following lines being in error:

PDF says:
for (userKeyStr : guildMemberKeyStrs) {

Line should be:
for (String userKeyStr : guildMemberKeyStrs) {


PDF says:
task = task.param("total_amount", Long(amount).toString());

Line should be:
task = task.param("total_amount", Long.toString(amount));


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.

The code in the code sample does not compile because the run() method needs to be public.

The PDF says:

void run() {

The line needs to be:

public void run() {


PDF version dated 23rd January 2015

Note from the Author or Editor:
Fixed in draft.