The Google Assistant brings
together all of the technology and smarts we've been building for years,
from the Knowledge Graph to Natural Language Processing. To be a truly
successful Assistant, it should be able to connect users across the apps and
services in their lives. This makes enabling an ecosystem where developers can
bring diverse and unique services to users through the Google Assistant really
important.

In October, we previewed
Actions on Google, the developer platform for the Google Assistant. Actions on Google further
enhances the Assistant user experience by enabling you to bring your services to
the Assistant. Starting today, you can build Conversation Actions for Google
Home and request to
become an early access partner for upcoming platform features.

Conversation Actions for Google Home

Conversation Actions let you engage your users to deliver information, services,
and assistance. And the best part? It really is a conversation -- users won't
need to enable a skill or install an app, they can just ask to talk to your
action. For now, we've provided two developer samples of what's possible, just
say "Ok Google, talk to Number Genie " or try "Ok Google, talk to Eliza' for the
classic 1960s AI exercise.

You can get started today by visiting the Actions on Google website for
developers. To help create a smooth, straightforward development experience, we
worked with a number of
development partners, including conversational interaction development tools
API.AI and Gupshup, analytics tools DashBot and VoiceLabs and consulting
companies such as Assist, Notify.IO, Witlingo and Spoken Layer. We also created
a collection of samples and voice user
interface (VUI) resources or you can
check out the integrations from our early access
partners as they roll out over the coming weeks.

Coming soon: Actions for Pixel and Allo + Support for Purchases and
Bookings

Today is just the start, and we're excited to see what you build for the Google
Assistant. We'll continue to add more platform capabilities over time, including
the ability to make your integrations available across the various Assistant
surfaces like Pixel phones and Google Allo. We'll also enable support for
purchases and bookings as well as deeper Assistant integrations across
verticals. Developers who are interested in creating actions using these
upcoming features should register for our early access
partner program and help shape the future of the platform.

Build, explore and let us know what you think about Actions on Google! And to say in the loop, be sure to sign up for our newsletter, join our Google+ community, and use the “actions-on-google” tag on StackOverflow.

The Gmail API team introduced a new settings feature earlier this year, and today, we're going to
explore some of that goodness, showing developers how to update Gmail user
settings with the API.

Email continues to be a dominant form of communication, personally and
professionally, and our email signature serves as both a lightweight
introduction and a business card. It's also a way to slip-in a sprinkling of your
personality. Wouldn't it be interesting if you could automatically change your
signature whenever you wanted without using the Gmail settings interface every
time? That is exactly what our latest video is all about.

If your app has already created a Gmail API service endpoint, say in a variable
named GMAIL, and you have the
YOUR_EMAIL email address whose signature should be changed
as well as the text of the new signature, updating it via the API is as pretty
straightforward, as illustrated by this Python call to the
GMAIL.users().settings().sendAs().patch() method:

For more details about the code sample used in the requests above as well as in
the video, check out the deepdive post. In
addition to email signatures, other settings the API can modify include:
filters, forwarding (addresses and auto-forwarding), IMAP and POP settings to
control external email access, and the vacation responder. Be aware that while
API access to most settings are available for any G Suite Gmail account, a few
sensitive operations, such as modifying send-as aliases or forwarding, are
restricted to users with domain-wide authority.

Developers interested in using the Gmail API to access email threads and
messages instead of settings can check out this other
video where we show developers how to search for threads with a minimum
number of messages, say to look for the most discussed topics from a mailing
list. Regardless of your use-case, you can find out more about the
Gmail API in the developer
documentation. If you're new to the API, we suggest you start with the overview page which
can point you in the right direction!

Today we are announcing a change to the domain scheme of the Google AMP Cache.
Beginning soon, the Google AMP Cache will serve each site from its own subdomain
of https://cdn.ampproject.org. This change will allow content
served from the Google AMP Cache to be protected by the fundamental security
model of the web: the HTML5
origin.

No immediate changes are required for most publishers of AMP documents. However,
to benefit from the additional security, it is recommended that all AMP
publishers update their CORS
implementation in preparation for the new Google AMP Cache URL scheme. The
Google AMP Cache will continue to support existing URLs, but those URLs will
eventually redirect to the new URL scheme.

How subdomain names will be created on the Google AMP Cache

The subdomains created by the Google AMP Cache will be human-readable when
character limits and technical specs allow, and will closely resemble the
publisher's own domain.

When possible, the Google AMP Cache will create each subdomain by first
converting the AMP document domain from IDN (punycode) to UTF-8. Every "-"
(dash) will be replaced with "--"(2 dashes) and every "." (dot) will be replaced
with a "-" (dash). For example, pub.com will map to
pub-com.cdn.ampproject.org. Where technical limitations prevent a
human readable subdomain, a one-way hash will be used instead.

Updates needed for hosts and service providers with remote endpoints

Due to the changes described above, CORS endpoints will begin seeing requests
with new origins. The following updates will be required:

Expand request acceptance to the new subdomain: Sites that
currently only accept CORS requests from https://cdn.ampproject.org
and the publisher's own origins must update their systems to accept requests
from https://[pub-com].cdn.ampproject.org,
https://cdn.ampproject.org, and the AMP publisher's own origins.

Tighten request acceptance for security: Sites that
currently accept CORS requests from https://*.ampproject.org as
described in the AMP spec,
can improve security by restricting acceptance to requests from
https://[pub-com].cdn.ampproject.org,
https://cdn.ampproject.org, and the AMP publisher's own origins.
Support for https://*.ampproject.org is no longer necessary.

Support for new subdomain pattern by ads, analytics, and other
technology providers: Service providers such as analytics and ads
vendors that have a CORS endpoint will also need to ensure that their systems
accept requests from the Google AMP Cache's subdomains (e.g.
https://ampbyexample-com.cdn.ampproject.org), in addition to their own
hosts.

Retrieving the Google AMP Cache URL

For platforms that display AMP documents and serve from the Google AMP Cache,
the best way to retrieve Google AMP Cache URLs is to continue using the Google
AMP Cache URL API. The Google AMP Cache URL API will be updated in Q1 2017
to return the new cache URL scheme that includes the subdomain.

You can use an interactive tool to find the Google AMP Cache subdomain generated
for each site over at ampbyexample.com.

Timing

Google Search is planning to begin using the new URL scheme as soon as possible
and is monitoring sites' compatibility. In addition, we will be reaching out to
impacted parties, and we will make available a developer testing sandbox prior
to launching to ensure a smooth transition.

As one of our most popular Udacity courses, the Developing Android Apps
course was recently updated to ensure developers have the resources to build
high quality apps. This course, which has already helped more than half a
million developers learn to build Android apps, has been through the car wash
and come out sparkling clean and updated.

Google and Udacity have worked together to update the course to include the very
latest changes in Android and Android Studio, including how to use the new
Constraint Layout editor, and how to use Firebase Job Dispatcher. Learn best
practices for building Android apps using Android 7.0 (Nougat) while keeping
your apps backwards compatible in older versions, learning at your own pace in
your own time.

You sent us feedback that some of the lessons were a little difficult to get
through, so we've restructured the lessons and added smaller apps for you to
build as you progress through the course. So not only will you build the
Sunshine weather app as a complete, integrated application that spans the entire
course, but you'll also create an app in each lesson to help you learn
individual concepts.

Build a To Do app and add new tasks as you learn how to build a ContentProvider.

This course brings back Android experts Dan Galpin and Reto Meier from Google, and Lyla Fujiwara from Udacity, and introduces new faces from Google and Udacity.

This updated course teaches the skills that are tested by the Associate Android
Developer certification exam. Udacity is offering a package that combines the
updated Developing Android Apps course with a voucher for the Associate Android
Developer certification exam. If you pass this exam, you will earn the Associate
Android Developer Certification and show that you are competent and skilled in
tasks that an entry-level Android developer typically performs. Enroll in
Udacity's Fast
Track to get prepared and take the Associate Android developer exam at: https://www.udacity.com/course/nd818.

The G Suite team recently launched the very
first Google Slides API,
opening up a whole new set of possibilities, including leveraging data
already sitting in a spreadsheet or database, and programmatically
generating slide decks or slide content based on that data. Why is this
a big deal? One of the key advantages of slide decks is that they can take
database or spreadsheet data and make it more presentable for human consumption.
This is useful when the need arises to communicate the information reflected by
that data to management or potential customers.

Walking developers through a short application demonstrating both the Sheets and
Slides APIs to make this happen is the topic of today's DevByte video. The
sample app starts by reading all the necessary data from the spreadsheet using
the Sheets API. The Slides API takes over from there, creating new slides for
the data, then populating those slides with the Sheets data.

Developers interact with Slides by sending API requests. Similar to the Google Sheets API, these requests
come in the form of JSON payloads. You create an array like in the JavaScript
pseudocode below featuring requests to create a cell table on a slide and import
a chart from a Sheet:

var requests = [

{"createTable": {

"elementProperties":

{"pageObjectId": slideID},

"rows": 8,

"columns": 4

}},

{"createSheetsChart": {

"spreadsheetId": sheetID,

"chartId": chartID,

"linkingMode": "LINKED",

"elementProperties": {

"pageObjectId": slideID,

"size": {

"height": { ... },

"width": { ... }

},

"transform": { ... }

}

}}

];
If you've got at least one request, say in a variable named
requests (as above), including the Sheet's
sheetID and chartID plus the
presentation page's slideID. You'd then pass it to the API
with just one call to the presentations().batchUpdate() command,
which in Python looks like the below if SLIDES is your API
service endpoint:

SLIDES.presentations().batchUpdate(presentationId=slideID,

body=requests).execute()

Creating tables is fairly straightforward. Creating charts has some magical
features, one of those being the linkingMode. A value of "LINKED"
means that if the Sheet data changes (altering the chart in the Sheet), the same
chart in a slide presentation can be refreshed to match the latest image, either
by the API or in the Slides user interface! You can also request a plain old
static image that doesn't change with the data by selecting a value of
"NOT_LINKED_IMAGE" for linkingMode. More on this can be found in
the documentation
on creating charts, and check out the video where you'll see both those API
requests in action.

For a detailed look at the complete code sample featured in the video,
check out the deep dive post. We look forward
to seeing the interesting integrations you build with the power of both APIs!

Posted by Derek Murray, Software Engineer
Today we are launching preliminary Windows support for TensorFlow.

Native support for TensorFlow on Windows was one of the first requests we
received after open-sourcing TensorFlow. Although some Windows users have
managed to run TensorFlow in a Docker container, we wanted to provide a more
complete experience including GPU support.

With the release of TensorFlow r0.12, we now provide a native TensorFlow package
for Windows 7, 10, and Server 2016. This release enables you to speed up your
TensorFlow training with any GPU that runs CUDA 8.

We have published the latest release as a pip package in PyPI, so now
you can install TensorFlow with a single command:

C:\> pip install tensorflow

And for GPU support:

C:\> pip install tensorflow-gpu

More details about Windows support and all of the other new features in r0.12
are included in the release
notes.

We're excited to offer more people the opportunity to use TF at maximum speed.
Follow us on Twitter to be the first to hear about future releases – we're @tensorflow.

Acknowledgements

Many people have contributed to making this release possible. In particular,
we'd like to thank Guenther Schmuelling and Vit Stepanovs from Microsoft for
their significant contributions to Windows support.

Originally posted on Google Open Source BlogBy Mary Radomile, Open Source Programs Office
Today marks the start of the 7th year of Google Code-in (GCI), our pre-university contest introducing students to open source development. GCI takes place entirely online and is open to students between the ages of 13 and 17 around the globe.

Tasks take an average of 3-5 hours to complete and include the guidance of a mentor to help along the way. Complete one task? Get a digital certificate. Three tasks? Get a sweet Google t-shirt. Finalists get a hoodie. Grand Prize winners get a trip to Google headquarters in California.

Over the last 6 years, 3213 students from 99 countries have successfully completed tasks in GCI. Intrigued? Learn more about GCI by checking out our rules and FAQs. And please visit our contest site and read the Getting Started Guide.

Teachers, if you are interested in getting your students involved in Google Code-in you can find resources here to help you get started.

After two successful
classes, we're excited to announce the next group of promising startups for
the third class of Launchpad Accelerator. The startups from Brazil, India,
Indonesia, and Mexico will be joined by developers from five additional
countries: Argentina, Colombia, Philippines, Thailand and Vietnam.

The program includes intensive mentoring from Google engineers, product managers
and other expert mentors from top technology companies and VCs in Silicon
Valley. Participants receive equity-free support, credits for Google products,
PR support and work closely with Google for six months in their home country.

Class 3 kicks off early next year (January 30) at Launchpad Space, our
physical space in San Francisco where developers and startups can get free
technical training, one-on-one mentoring and more education geared towards
helping them successfully build their apps & startups.

If you're interested in applying for future Launchpad Accelerator cohorts, we
encourage you to follow us on the Launchpad Accelerator site to receive
updates. We also expect to add more countries to the program in the future. Stay
tuned!