text:
Warning: This page is about Google's older APIs, the Google Data APIs; it's relevant only to the APIs that are listed in the Google Data APIs directory, many of which have been replaced with newer APIs. For information about a specific new API, see the new API's documentation. For information about authorizing requests with a newer API, see Google Accounts Authentication and Authorization.
This document describes the Google Data Protocol used by many Google APIs, including information about what a query looks like, what results look like, and so on.
For more information about the Google Data Protocol, see the Developer's Guide overview page and the Protocol Basics document.
This document is intended for anyone wanting to understand the details of the XML format and protocol used by the APIs that implement the Google Data Protocol.
If you just want to write code that uses one of these APIs, then you don't need to know these details; instead, you can use the language-specific client libraries.
But if you want to understand the protocol, read this document. For example, you may want to read this document to help you with any of the following tasks:
- evaluating the Google Data Protocol architecture
- coding using the protocol without using the provided client libraries
- writing a client library in a new language
This document assumes that you understand the basics of XML, namespaces, syndicated feeds, and the GET
, and DELETE
requests in HTTP, as well as HTTP's concept of a "resource." For more information about those things, see the Additional resources section of this document.
This document doesn't rely on any particular programming language; you can send and receive Google Data Protocol messages using any programming language that lets you issue HTTP requests and parse XML-based responses.
Protocol details
This section describes the Google Data Protocol document format and query syntax.
Document format
The Google Data Protocol and Atom share the same basic data model: a container that holds both some global data and any number of entries. For each protocol, the format is defined by a base schema, but it can be extended using foreign namespaces.
Atom is the default format for the Google Data Protocol. To request a response in another format, use the alt
query parameter; for more information, see Query requests.
Note: Most Google Data Protocol feeds in Atom format use the Atom namespace as the default namespace by specifying an xmlns
attribute on the feed element, as seen in the examples given in Protocol Basics. Thus, the examples in this document don't explicitly specify atom:
for elements in an Atom-format feed.
The following tables show the Atom representation of the elements of the schema. All data not mentioned in these tables is treated as plain XML. Unless indicated otherwise, the XML elements in a given column are in the Atom namespace.
Note: This summary uses standard XPath notation: in particular, slashes show the element hierarchy, and an @ sign indicates an attribute of an element.
In each of the following tables, the highlighted items are required.
The following table shows the elements of a Google Data Protocol feed:
Feed Schema Item | Atom Representation |
Feed Title | /feed/title |
Feed ID | /feed/id |
Feed HTML Link | /feed/link[@rel="alternate"] \[@type="text/html"]/@href |
Feed Description | /feed/subtitle |
Feed Language | /feed/@xml:lang |
Feed Copyright | /feed/rights |
Feed Author |
(Required in certain cases; see Atom specification.) |
Feed Last Update Date | /feed/updated (RFC 3339 format) |
Feed Category | /feed/category/@term |
Feed Category Scheme | /feed/category/@scheme |
Feed Generator | /feed/generator /feed/generator/@uri |
Feed Icon | /feed/icon |
Feed Logo | /feed/logo |
The following table shows the elements of a Google Data Protocol search-results feed. Note that the protocol exposes some of the OpenSearch 1.1 Response elements in search-results feeds.
Search Result Feed Schema Item | Atom Representation |
Number of Search Results | /feed/openSearch:totalResults |
Search Result Start Index | /feed/openSearch:startIndex |
Number of Search Results Per Page | /feed/openSearch:itemsPerPage |
The following table shows the elements of a Google Data Protocol entry:
Entry Schema Item | Atom Representation |
Entry ID | /feed/entry/id |
Entry Title | /feed/entry/title |
Entry Link | /feed/entry/link |
Entry Summary |
(Required in certain cases; see Atom specification.) |
Entry Content |
(If no content element, then entry must contain at least one |
Entry Author |
(Required in certain cases; see Atom specification.) |
Entry Category | /feed/entry/category/@term |
Entry Category Scheme | /feed/entry/category/@scheme |
Entry Publication Date | /feed/entry/published (RFC 3339) |
Entry Update Date | /feed/entry/updated (RFC 3339) |
This section describes how to use the query system.
Query model design tenets
The query model is intentionally very simple. The basic tenets are:
- Queries are expressed as HTTP URIs, rather than as HTTP headers or as part of the payload. One benefit of this approach is that you can link to a query.
- Predicates are scoped to a single item. Thus, there's no way to send a correlation query such as "find all emails from people who sent me at least 10 emails today."
- The set of properties that queries can predicate on is very limited; most queries are simply full text search queries.
- Result ordering is up to the implementation.
- The protocol is naturally extensible. If you want to expose additional predicates or sorting in your service, you can do so easily through the introduction of new parameters.
Query requests
A client queries a Google service by issuing an HTTP GET
request. The query URI consists of the resource's URI (called FeedURI in Atom) followed by query parameters. Most query parameters are represented as traditional ?name=value[&...]
URL parameters. Category parameters are handled differently; see below.
For example, if the FeedURI is http://www.example.com/feeds/jo
, then you might send a query with the following URI:
The Google Data Protocol supports HTTP Conditional GET
. APIs that implement the protocol set the Last-Modified response header based upon the value of the <atom:updated>
element in the returned feed or entry. A client can send this value back as the value of the If-Modified-Since request header to avoid retrieving the content again if it hasn't changed. If the content hasn't changed since the If-Modified-Since time, then the service returns a 304 (Not Modified) HTTP response.
APIs that implement the Google Data Protocol must support alt
queries; support for other parameters is optional. Passing a standard parameter not understood by a given service results in a 403 Forbidden
response. Passing an unsupported nonstandard parameter results in a 400 Bad Request
response. For information on other status codes, see the HTTP status codes section of this document.
The standard query parameters are summarized in the following table. All parameter values need to be URL encoded.
Parameter | Meaning | Notes |
alt |
Alternative representation type |
author |
Entry author |
category |
Category query filter |
/-/category |
Category query filter |
entryID | ID of a specific entry to be retrieved |
fields |
Response filter |
max-results |
Maximum number of results to be retrieved | For any service that has a default max-results value (to limit default feed size), you can specify a very large number if you want to receive the entire feed. |
prettyprint |
Returns an XML response with identations and line breaks |
published-min , published-max |
Bounds on the entry publication date |
q |
Full-text query string |
start-index |
1-based index of the first result to be retrieved |
strict |
Strict query parameter checking |
updated-min , updated-max |
Bounds on the entry update date |
About category queries
We decided to provide a slightly unusual format for category queries. Instead of requiring a query like the following:
we made it possible to use:
This approach identifies a resource without using query parameters, and it produces cleaner URIs. We chose this approach for categories because we think that category queries will be among the most common queries.
The drawback to this approach is that we require you to use /-/
in this type of category queries, so that services can distinguish category queries from other resource URIs, such as http://example.com/jo/MyPost/comments
Query responses
Queries return an Atom feed, an Atom entry, or an RSS feed, depending on the request parameters.
Query results contain the following OpenSearch elements directly under the <feed>
element or the <channel>
element (depending on whether results are Atom or RSS):
- The total number of search results for the query (not necessarily all present in the results feed).
- The 1-based index of the first result.
- The maximum number of items that appear on one page. This allows clients to generate direct links to any set of subsequent pages. However, for a possible pitfall in using this number, see the note regarding
in the table in the Query requests section.
The Atom response feed and entries may also include any of the following Atom and Data API elements (as well as others listed in the Atom specification):
<link rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml" href="..."/>
- Specifies the URI where the complete Atom feed can be retrieved.
<link rel="http://schemas.google.com/g/2005#post" type="application/atom+xml" href="..."/>
- Specifies the Atom feed's PostURI (where new entries can be posted).
<link rel="self" type="..." href="..."/>
- Contains the URI of this resource. The value of the
attribute depends on the requested format. If no data changes in the interim, sending another GET to this URI returns the same response. <link rel="previous" type="application/atom+xml" href="..."/>
- Specifies the URI of the previous chunk of this query result set, if it is chunked.
<link rel="next" type="application/atom+xml" href="..."/>
- Specifies the URI of the next chunk of this query result set, if it is chunked.
<link rel="edit" type="application/atom+xml" href="..."/>
- Specifies the Atom entry's EditURI (where you send an updated entry).
Here's a sample response body, in response to a search query:
<?xml version="1.0" encoding="UTF-8"?> <feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearch/1.1/" xmlns:gd='http://schemas.google.com/g/2005' gd:etag='W/"C0QBRXcycSp7ImA9WxRVFUk."'> <id>http://www.example.com/feed/1234.1/posts/full</id> <updated>2005-09-16T00:42:06Z</updated> <title type="text">Books and Romance with Jo and Liz</title> <link rel="alternate" type="text/html" href="http://www.example.net/"/> <link rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml" href="http://www.example.com/feed/1234.1/posts/full"/> <link rel="http://schemas.google.com/g/2005#post" type="application/atom+xml" href="http://www.example.com/feed/1234.1/posts/full"/> <link rel="self" type="application/atom+xml" href="http://www.example.com/feed/1234.1/posts/full"/> <author> <name>Elizabeth Bennet</name> <email>firstname.lastname@example.com</email> </author> <generator version="1.0" uri="http://www.example.com">Example Generator Engine</generator> <openSearch:totalResults>2</openSearch:totalResults> <openSearch:startIndex>0</openSearch:startIndex> <entry gd:etag='W/"C0QBRXcycSp7ImA9WxRVGUo."'> <id>http://www.example.com/feed/1234.1/posts/full/4521614025009481151</id> <published>2005-01-09T08:00:00Z</published> <updated>2005-01-09T08:00:00Z</updated> <category scheme="http://www.example.com/type" term="blog.post"/> <title type="text">This is the title of entry 1009</title> <content type="xhtml">
This is the entry body of entry 1009
 </content> <link rel="alternate" type="text/html" href="http://www.example.com/posturl"/> <link rel="edit" type="application/atom+xml" href="http://www.example.com/feed/1234.1/posts/full/4521614025009481151"/> <author> <name>Elizabeth Bennet</name> <email>email@example.com</email> </author> </entry> <entry gd:etag='W/"C0QBRXrurSp7ImA9WxRVGUo."'> <id>http://www.example.com/feed/1234.1/posts/full/3067545004648931569</id> <published>2005-01-07T08:00:00Z</published> <updated>2005-01-07T08:02:00Z</updated> <category scheme="http://www.example.com/type" term="blog.post"/> <title type="text">This is the title of entry 1007</title> <content type="xhtml">
This is the entry body of entry 1007
 </content> <link rel="alternate" type="text/html" href="http://www.example.com/posturl"/> <link rel="edit" type="application/atom+xml" href="http://www.example.com/feed/1234.1/posts/full/3067545004648931569"/> <author> <name>Elizabeth Bennet</name> <email>email@example.com</email> </author> </entry> </feed>
If the requested feed is in the Atom format, if no query parameters are specified, and if the result doesn't contain all the entries, the following element is inserted into the top-level feed: <link rel="next" type="application/atom+xml" href="..."/>
. It points to a feed containing the next set of entries. Subsequent sets contain a corresponding <link rel="previous" type="application/atom+xml" href="..."/>
element. By following all the next links, a client can retrieve all entries from a feed.
HTTP status codes
The following table describes what various HTTP status codes mean in the context of the Data APIs.
Code | Explanation |
200 OK | No error. |
201 CREATED | Creation of a resource was successful. |
304 NOT MODIFIED | The resource hasn't changed since the time specified in the request's If-Modified-Since header. |
400 BAD REQUEST | Invalid request URI or header, or unsupported nonstandard parameter. |
401 UNAUTHORIZED | Authorization required. |
403 FORBIDDEN | Unsupported standard parameter, or authentication or authorization failed. |
404 NOT FOUND | Resource (such as a feed or entry) not found. |
409 CONFLICT | Specified version number doesn't match resource's latest version number. |
410 GONE | Requested change history is no longer available on the server. Refer to service-specific documentation for more details. |
500 INTERNAL SERVER ERROR | Internal error. This is the default code that is used for all unrecognized server errors. |
Resource versioning (ETags)
Sometimes you need to be able to refer to a specific version of a particular entry.
This is important in two cases in particular:
- Doing a "conditional retrieval," in which your client requests an entry, and the server sends the entry only if it has changed since the last time the client requested it.
- Ensuring that multiple clients don't inadvertently overwrite one another's changes. The Data APIs do this by making updates and deletes fail if the client specifies an old version identifier for the entry.
The Google Data APIs handle both of these cases using ETags, a standard part of HTTP.
An ETag is an identifier that specifies a particular version of a particular entry. The server attaches an ETag to entry and feed elements that it sends to clients. When an entry or feed changes, its ETag changes as well.
The Google Data APIs provide ETags in two places: in an ETag
HTTP header, and in a gd:etag
attribute of <feed>
and <entry>
In the Google Data APIs, an ETag is usually a string of letters and numbers, sometimes also including hyphens and periods; the string is usually enclosed in quotation marks. (The quotation marks are part of the ETag.) For example, here's an ETag from a Data API entry: "S0wCTlpIIip7ImA0X0QI"
There are two kinds of ETags: strong and weak. Strong ETags identify a specific version of a specific entry, and can be used to avoid overwriting other clients' changes. Weak ETags, in the context of the Google Data APIs, are used only for conditional retrieval. A weak ETag always starts with W/
. For example: W/"D08FQn8-eil7ImA9WxZbFEw."
Not all Google Data APIs support strong ETags. For those that do, the strong ETags are used only for entries; ETags on feeds are always weak.
Here's an example of a feed (including some of the HTTP headers) retrieved from a service that supports strong ETags:
GData-Version: 2.0 ETag: W/"C0QBRXcycSp7ImA9WxRVFUk." ... <?xml version='1.0' encoding='utf-8'?> <feed xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' gd:etag='W/"C0QBRXcycSp7ImA9WxRVFUk."'> ... <entry gd:etag='"CUUEQX47eCp7ImA9WxRVEkQ."'> ... </entry> </feed>
The client libraries that support version 2 of the Data APIs handle ETags for you, transparently. The following information is for clients that don't use client libraries, and for readers interested in how versioning is handled at the protocol level.
Note: For information about the resource-versioning system used in version 1.0 of the Data APIs, see 1.0 reference guide.
Conditional retrieval
If you want to retrieve an entry that you've retrieved before, you can improve efficiency by telling the server to send the entry only if it has changed since the last time you retrieved it.
To do this sort of conditional retrieval, send an HTTP GET
request that includes an HTTP If-None-Match
header. In the header, specify the entry's ETag.
Here's an example of an If-None-Match
If-None-Match: W/"D08FQn8-eil7ImA9WxZbFEw."
When the server receives this request, it checks to see whether the entry that you requested has the same ETag as the ETag you specified. If the ETags match, then the entry hasn't changed, and the server returns an HTTP 304 Not Modified
status code.
If the ETags don't match, then the entry has been modified since the last time you requested it, and the server returns the entry.
Updating entries
The easiest way to avoid overwriting another client's changes is for the server to make sure that when your client sends an updated entry, the version of the entry that your client started with is the same as the current version stored by the server. If a second client makes an update before your client does, then your client's update is denied, because your client is no longer basing its modifications on the latest version.
When your client retrieves data from a service that supports strong ETags, each entry has an ETag that acts as a unique version identifier for that version of that entry.
Note: Updating using ETags works only with strong ETags. For services that supply weak ETags, all updates succeed, regardless of whether someone else has updated the entry since you retrieved it; the newest update always overwrites any other prior updates. So don't send weak ETags when updating or deleting; you'll get an error message if you do.
So when your client sends an update to a strong-ETags service, it needs to specify what version of the entry it's updating. There are two ways to do that:
- Use an
HTTP header. - Use the
attribute in the<atom:entry>
We recommend the If-Match
approach where possible.
To update an entry using If-Match
, start by acquiring the entry you're updating. Make any desired changes to the entry, then create a new PUT
request containing the modified entry. (For details of URLs to use, see service-specific documentation.)
Before sending the PUT
, add an HTTP If-Match
header containing the ETag from the original entry:
If-Match: "S0wCTlpIIip7ImA0X0QI"
Then send the PUT
If the update succeeds, then the server returns an HTTP 200 OK
status code, and a copy of the updated entry.
If the update fails because the ETag you specified doesn't match the current ETag on the entry (which implies that the entry has changed on the server since you last retrieved it), then the server returns an HTTP 412 Precondition Failed
status code.
If you can't easily write HTTP headers, or have some other reason to avoid using the If-Match
header, then you can use the gd:etag
attribute instead.
If you don't send an If-Match
header, then the server uses the updated entry's gd:etag
attribute value as an implied If-Match
To override the versioning system and update the entry regardless of whether someone else has updated it since you retrieved it, use If-Match: *
instead of specifying the ETag in the header.
For information about which services support strong ETags, see the Migration Guide.
Deleting entries
Deleting entries that use strong ETags works much like updating them.
To delete an entry that has a strong ETag, first you retrieve the entry you want to delete, then you send a DELETE
request to the entry's edit URL.
If you want to make sure that you don't delete an entry that has been changed by another client since you retrieved it, then include an HTTP If-Match
header that contains the original entry's ETag value.
If you want to override the versioning system and delete the entry regardless of whether someone else has updated it since you retrieved it, use If-Match: *
instead of specifying the ETag in the header.
If an entry does not have a strong ETag, then a DELETE
request always succeeds.
Partial response (Experimental)
By default, the server sends back the full representation of the target resource after processing requests. Partial response lets you request only the elements or attributes of interest, instead of the full resource representation. This lets your client application avoid transferring, parsing, and storing unneeded fields, so it can use network, CPU, and memory resources more efficiently.
To find out if partial response is available for the product you are using, see its API documentation.
To request a partial response, use the fields
query parameter to specify the elements or attributes you want returned. Here's an example:
The server's response contains only only link and entry elements for the feed; the entry elements contain only ETag, ID, updated, and edit link information. The fields
query parameter syntax is covered in the following sections. For more details about the response, see Handling partial responses.
Note: You can use the fields
query parameter with any request that returns data. In addition to GET
, this includes POST
, and PUT
(as well as PATCH
, which is used for making partial updates). However, the fields
query parameter only affects the response data; it does not affect the data that you must provide or which fields are updated or created.
Fields parameter syntax summary
The format of the fields
query parameter value is based on XPath syntax; however, it supports only a subset of valid XPath expressions. The supported syntax is summarized below, and additional examples are provided in the following section.
- Use a comma-separated list to select several fields.
- Use
to select an elementb
that is nested within elementa
; usea/b/c
to select an elementc
nested withinb
. - Use
prefix to identify an attribute with the given name; omit the'@'
prefix to refer to an element. - Apply field conditions to select elements that match certain criteria, by placing expressions in brackets "
[ ]
" after the element you want to restrict.For example,
returns only feed entries for which Elizabeth is the author. - Specify field sub-selectors to request only specific attributes or sub-elements, by placing expressions in parentheses "
( )
" after any selected element.For example,
returns only the ID and the author's email for each feed entry. - You can delimit strings using either double or single quotes
To escape a double or single quote, repeat the quote. For example,
"""Hello,"" he said"
produces the string"Hello," he said
, and'''Hello,'' he said'
produces the string'Hello,' he said
. - You can use wildcards in field selections.
For example,
selects all child elements of entry in thegd
namespace, andentry/@gd:*
selects child element attributes in the same namespace.
The fields
query parameter acts as an output filter. This means that the partial response is computed only after processing the rest of the query. For example, if you also specify a max-results
query parameter to indicate that you want 20 results per page, then the first 20 results are generated and the partial response is computed from that. If the fields
specification doesn't match any of the first 20 entries selected by the query, then you get back an empty feed; you do not get back the first 20 matching entries.
Note: Do not attempt to use field conditions as query selectors. That is, do not attempt to retrieve a full feed and apply field conditions to filter out items of interest from a very large data set. Whenever possible, use other query parameters, such as start-index
and max-results
, to reduce the results of each query to a manageable size. Otherwise, the performance gains possible with partial response could be outweighed by the serious performance degradation caused by improper use.
Formatting the fields parameter value
The following guidelines explain how to construct the fields
query parameter value. Each guideline includes examples and provides descriptions of how the parameter value affects the response.
Note: As with all query parameter values, the fields
parameter value must be URL encoded. For better readability, the examples below omit the encoding.
- Identify the fields you want returned, or make field selections.
- The
query parameter value is a comma-separated list of elements or attributes (collectively called fields), and each field is specified relative to the root element of the resource representation. Thus, if you are retrieving a feed, fields are specified relative to the<feed>
element, and if you are retrieving a single entry, fields are specified relative to the<entry>
element. If the element you select is (or is part of) a repeating element in the feed, the service returns all instances of that element.
Here are some feed-level examples:
Examples Effect entry
Returns all <entry>
elements and all sub-elements of those entries, but not any other child elements of<feed>
Returns both the feed <id>
and all<entry>
Returns the <title>
element for all feed entries.
Whenever a nested element is returned, the response includes enclosing tags for anyparent elements. The parent tags do not include any other child elements or attributes unless they are also selected explicitly.
Returns only the <uri>
sub-element of the<author>
element for all feed entries.entry/*:rating
Returns only sub-elements with local name rating
in any namespace for all feed entries.
Here are some entry-level examples:
Examples Effect author
Returns the <author>
child element of the target entry.@gd:etag
Returns the etag
attribute of the target entry.author/uri
Returns the <uri>
sub-element of the<author>
element for the target entry.media:group/media:*
Returns all sub-fields of <media:group>
in themedia
namespace for the target entry. - Restrict the response to selected fields that match certain criteria, or use field conditions.
- By default, if your request specifies an element that occurs more than once, the partial response will include all instances of that element. However, you can also specify that the response should only include elements that have a particular attribute value or elements that fulfill some other condition using "
[ ]
" syntax, as shown in the examples below. See the field condition syntax section for more details.Examples Effect entry[link/@rel='edit']
Returns any feed entries that contain a <link>
element with arel
attribute value of'edit'
Returns any <title>
elements that occur in feed entries if their content is'Today'
Returns any <author>
elements that occur in feed entries if they have a<name>
sub-element with content'Jo'
Returns the <author>
element in the target entry if it has a<name>
sub-element with content'Jo'
. - Request only parts of the selected elements, or use field sub-selections.
- By default, if your request specifies particular elements, the service returns the elements in their entirety. You can specify that the response should include only certain sub-elements within the selected elements. You do this using "
( )
" sub-selection syntax, as in the examples below.Examples Effect entry/author(uri)
Returns only the <uri>
sub-element for authors in feed entries.entry/author[name='Jo'](uri)
Returns only the <uri>
sub-element of<author>
for any entries that have an author name of'Jo'
Returns only the values of the rel
attributes for each<link>
element in feed entries.entry(title,link[@rel='edit'])
Returns only <title>
elements with editrel
attributes for each feed entry.entry(title,author(uri)
Returns both <title>
elements and author<uri>
elements for each feed entry.
More about field condition syntax
You can use field conditions with fields or sub-fields. The condition must evaluate to true for the selected field to be included in the results. If there is no field condition, then all fields of the selected type are included.
The text value of the selected field is used for comparisons. In this context, if the field is an element, the text value is its contents; if the field is an attribute, the text value is the attribute's value. If the field has no text value, then the comparison fails and the field is not included in the results.
The following table shows the XPath operators that are supported for field conditions and provides some examples.
Operator | Syntax | Examples |
String comparison |
Logical comparison | and |
Numerical comparison | = or eq != or ne > or gt > = or ge < or lt <= or le
Date comparison | Use numerical comparison operators, as shown in examples. | To do date or date/time comparisons, you can cast elements, attributes, or string literals into
Existence | Use name of element or attribute as shown in examples. |
Boolean | true() false()
Booleans can be useful during testing to force field conditions into a true or false state.
Handling partial responses
After a server that supports partial response processes a valid request that includes the fields
query parameter, it sends back an HTTP 200 OK
status code along with the requested attributes or elements. If the fields
query parameter has an error or is otherwise invalid, the server returns an HTTP 400 Bad Request
status code.
The root element of the response is either <feed>
or <entry>
, depending on the target URI. The root element's content includes only the selected fields for that feed or entry, along with the enclosing tags for any parent elements.
The value of the the request's fields
query parameter can be echoed back in two ways:
- The root element has a
attribute that shows value of thefields
query parameter specified in the request. - If the target URI is a feed, each editable entry has a
attribute that shows the portion of thefields
selection that applies to it.
Note: In order to see these gd:fields
attribute values in your partial response, you must include them in your fields
query parameter specification. You can do this explicitly, using @gd:fields
, or using the more general @gd:*
, which also includes ETag information.
The following example query asks the server to return a document that contains only attributes in the gd
namespace (at both the feed and entry level), as well as the feed ID, the title, and the edit link for each feed entry:
The server returns the following partial response, along with a 200 Successful
HTTP status code:
<?xml version='1.0' encoding='utf-8'?> <feed xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' gd:etag='W/"DEAEQH47eCp7IWA9WxBVGUo."' gd:fields='@gd:*,id,entry(@gd:*,title,link[@rel='edit'])> <id>http://example.com/myFeed</id> <entry gd:etag='"EksPTg1Bfyp7IWA6WhJT"' gd:fields="@gd:*,title,link[@rel='edit']"> <link rel='edit' href='http://example.com/myFeed/1/'/> <title>This year</title> </entry> <entry gd:etag='"EksPQA1Cdyp7IWA6WhJT"' gd:fields="@gd:*,title,link[@rel='edit']"> <link rel='edit' href='http://example.com/myFeed/2/'/> <title>Last year</title> </entry> <entry d:etag='"EksPQAxHeCp7IWA6WhJT"' gd:fields="@gd:*,title,link[@rel='edit']"> <link rel='edit' href='http://example.com/myFeed/3/'/> <title>Today</title> </entry> </feed>
If the selected fields do not match anything, the service still returns a 200 Successful
HTTP status code, but the partial response is an empty feed:
<?xml version='1.0' encoding='utf-8'?> <feed xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' gd:etag='W/"DEAEQH47eCp7IWA9WxBVGUo."' gd:fields='@gd:*,id,entry(@gd:*,title,link[@rel='edit'])> </feed>
Partial update (Experimental)
Google products that support partial response and editable resources also allow you to use partial update. With partial update, you send only the fields you want to update, rather sending a modified version of the full resource representation. This lets your client application be more efficient when making updates, as well as when using partial response to retrieve data.
Instead of using PUT
, however, you must use a PATCH
request when making a partial update. The semantics for PATCH
are powerful enough to let you add, replace, and delete specific fields for a particular entry, all with a single request.
To find out if partial update is available for the product you are using, refer to the product-specific documentation.
Submitting a partial update request
To submit a partial update request, you send an HTTP PATCH
request to the same URL that you would normally use with PUT
to update the resource. The body of the PATCH
request is a partial <entry>
element that specifies the fields you want to add or modify. The entry's gd:fields
attribute indicates the fields you want to delete.
The server processes PATCH
requests in a specific order:
- It first removes from the resource representation the fields specified by the
attribute.The syntax for the
attribute is the same as for thefields
query parameter used when requesting a partial response. See Supported syntax for more details. - It then merges into the existing resource representation the data provided in the body of the request.
More details on how the data is merged are provided in Adding or updating fields below.
Note: Since the body of a PATCH
request is not typically compliant with the Atom Syndication Format, the Content-Type
you use with a PATCH
request is application/xml
Here is an example of a partial update request:
PATCH /myFeed/1/1/ Content-Type: application/xml <entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' gd:fields='description'> <title>New title</title> </entry>
This PATCH
request makes the following changes to the resource representation stored on the server for the target URI's entry:
- Removes the
element. - Updates the
Semantics of a partial update request
The instructions below explain how to set up your PATCH
request to delete, add, or update specific fields within an entry. A single PATCH
request can perform any combination of these operations.
Deleting fields. Use the
attribute to identify any fields you want deleted from the resource. The following sample request deletes the title and summary associated with an entry. However the request does not add or update any other data for the entry.PATCH /myfeed/1/1/ Content-Type: application/xml <entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' gd:fields='title,summary'/>
Adding or updating fields. Use the body of the
element to specify the data that you want to add or update for a resource. These fields are merged into the existing data for the resource, after any deletions are made, according to the following rules:Fields not already present are added. If the resource data does not already specify a value for a field, then the field is added to the existing data. For example, if an entry does not have a title, and your
request contains a<title>
element, then the new title is added to the entry.Fields already present are replaced or appended. The specific behavior for merging fields that are already specified in the resource data depends on the characteristics of the field:
Non-repeating fields are replaced. If the resource data already specifies a value for a non-repeating element, then the value you specify in the
request replaces the existing value for that element. For example, in the example below, the new title replaces the existing title.PATCH /myFeed/1/1/ Content-Type: application/xml <entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'> <title>New Title</title> </entry>
A more complex example is given below. For this example, assume that the entry can have only one author, and that the target resource already has values for the author's name and email address. Even though
element has two child fields, only the<name>
element is present in the data provided. As a result, only that field's value is overwritten. The value of the<email>
element, which is missing from the data provided, remains unchanged.PATCH /myfeed/1/1/ Content-Type: application/xml <entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'> <author> <name>New Name</name> </author> </entry>
Repeating fields are appended. If the resource data already specifies a value for a repeating element, then the new element you provide is added to the existing set of values.
Note that there might be times when you want to do something other than add a new instance of a repeating element. For example, you might want to do one of the following:
Replace an entire list of repeating elements. You can delete all the repeating fields using the
attribute (gd:fields='ns:accessControl'
, for example) and provide a complete set of the replacement fields. Since all the existing elements are deleted first, the set of fields you provide do not conflict with any existing values when they are appended.Replace one value in a set of existing values for a repeating element. In this case, simply remove the single element by defining the
value narrowly enough to avoid deleting other values that you want to keep. For example, to remove only an access control with anaction
, you might usegd:fields='ns:accessControl[@action="embed"]'
. Then you provide the single field that you want to replace it with in the body of the<entry>
element:PATCH /myfeed/1/1/ Content-Type: application/xml <entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' gd:fields='ns:accessControl[@action="embed"]> <ns:accessControl action="embed" permission="allowed" /> </entry>
Handling the response to a partial update
After processing a valid partial update request, the API returns a 200 OK
HTTP response code. By default, the body of the response is the complete entry that you updated. The server updates ETag values when it successfully processes a PATCH
request, just as it does with PUT
If a PATCH
request results in a new resource state that is syntactically or semantically invalid, the server returns an HTTP 400 Bad Request
or 422 Unprocessable Entity
HTTP status code, and the resource state remains unchanged. For example, if you attempt to delete a required field and do not provide a replacement, the server returns an error.
Note: It is important to understand how different fields relate to each other. It might be possible to put a resource into an inconsistent state by updating only part of mutually interdependent values. For example, it might be possible to update a start time to a later value than an end time. Although the API should return an error code, we recommend that you fully test these kinds of conditions to ensure consistency.
Alternate notation when PATCH is not supported
If your firewall does not allow PATCH
, then do an HTTP POST
request and set the override header to PATCH
, as shown below:
POST /myfeed/1/1/ X-HTTP-Method-Override: PATCH Content-Type: application/xml ...
Using partial response with partial update
You can use a partial response as the basis of a subsequent partial update request. If you do this, specify a fields
query parameter that includes edit links, as well as @gd:*
. This ensures that the partial response includes information like the ETag and gd:fields
attribute values, which are important for subsequent requests.
Here is an example that returns a partial response that you could use as the basis for a future partial update:
The server responds:
<?xml version='1.0' encoding='utf-8'?> <entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005' gd:etag='"E0UKRAREeCp7IWA6WhJT"' gd:fields="@gd;*,link[@rel='edit'](@href),gd:who"> <link href='http://example.com/myFeed/1/1/'/> <gd:who firstname.lastname@example.com'/> <gd:who email@example.com'/> <gd:who firstname.lastname@example.com'/> </entry>
Suppose that you want to remove the user with email 'firstname.lastname@example.com'
, add a user with email 'email@example.com'
, and change the email for the user currently listed as 'email@example.com'
to 'firstname.lastname@example.com'
You can make these changes simply by starting with the results of the previous response, modifying only the fields that are different, and submitting the modified partial entry as the body of the PATCH
request. For this example, the needed modifications are:
- Delete
<gd:who email='jane'/>
from the list of elements provided. - Add
<gd:who firstname.lastname@example.com'/>
to the list of elements provided. - Replace
<gd:who email@example.com'/>
with<gd:who email@example.com'/>
The PATCH
request based on the pevious partial response is shown below:
PATCH /myFeed/1/1/ Content-Type: application/xml <entry gd:fields="@gd:*,link[@rel='edit'](@href),gd:who" gd:etag="FE8LQQJJeSp7IWA6WhVa"> <link href='http://example.com/myFeed/1/1'/> <gd:who firstname.lastname@example.com'/> <gd:who firstname.lastname@example.com'/> <gd:who firstname.lastname@example.com'/> </entry>
Note: This approach relies on the gd:fields
and gd:etag
(if supported) attributes being included in the partial response for the entry. The body of the partial entry must retain all fields and attribute that were present in the partial response — except for those you explicitly want to remove. You can update any of the existing fields in the body with new values, and you can include any new fields you want to add.
When a client tries to access a service, it may need to provide the user's credentials to the service, to demonstrate that the user has the authority to perform the action in question.
The approach that a client should use for authentication depends on the type of client:
- A desktop application should use a Google-specific authentication system called Account Authentication for Installed Applications (also known as "ClientLogin"). (Web-based clients should not use this system.)
- A web-based client, such as a third-party front end to a Google service, should use a Google-specific authentication system called Account Authentication Proxy for Web-Based Applications (also known as "AuthSub").
In the ClientLogin system, the desktop client asks the user for their credentials, and then sends those credentials to the Google authentication system.
If authentication succeeds, then the authentication system returns a token that the client subsequently uses (in an HTTP Authorization header) when it sends Data API requests.
If authentication fails, then the server returns a 403 Forbidden status code, along with a WWW-Authenticate header containing a challenge applicable to the authentication.
The AuthSub system works similarly, except that instead of asking the user for their credentials, it connects the user to a Google service that requests credentials. The service then returns a token that the web application can use; the advantage of this approach is that Google (rather than the web front end) securely handles and stores the user's credentials.
For details about these authentication systems, see the Google Data APIs Authentication Overview or the Google Account Authentication documentation.
Session state
Many business logic implementations require session stickiness—keeping track of the state of a user's session.
Google tracks session state in two ways: using cookies, and using a token that can be sent as a query parameter. Both methods achieve the same effect. We recommend that clients support one of these session-state tracking methods (either one is sufficient). If a client doesn't support either of these methods, then that client will still work with Data APIs, but performance may suffer compared to clients that do support these methods. Specifically, if a client doesn't support these methods, then every request results in a redirect, and therefore every request (and any associated data) is sent to the server twice, which affects the performance of both the client and the server.
The Google client libraries handle session state for you, so if you use our libraries, you don't have to do anything to get session state support.
Additional resources
You may find the following third-party documents useful:
- Comparison of Atom and RSS from intertwingly
- Overview of Atom from IBM
- Dublin Core extensions to RSS
- HTTP 1.1 method definitions; specification for
, andDELETE
- HTTP 1.1 status code definitions
- How to Create a REST Protocol
- Building Web Services the REST Way
- A Technical Introduction to XML
- XML Namespaces by Example
- ETag section of HTTP specification


text:
L2 released Hair Care & Color: EU Supplement, a supplement to its Digital IQ Index focusing on hair care and color. This supplement takes a deeper dive into industry trends and best practices in the EU 5 (France, Germany, Italy, Spain and the U.K.) hair care and color market, assessing 53 global hair care and color brands' digital competence across site, digital marketing, social media and mobile initiatives.
The study found that recession, anemic brand loyalty, and heavy discounting have cast clouds across Europe's hair care and color industry. As business declines, brands may be too easily swayed by headline macro risk to invest in key channels, namely digital:
- Just 12% of hair care and color brands' U.K. sites are mobile-optimized.
- Spain's YouTube channels grew 62% over the last three months, faster than any other EU 5 country.
- Hair care and color brands own 48% of Google organic search results in France, compared to 36% in the U.S.
- Brands whose e-commerce strategies work in partnership with third-party retailers have varying degrees of data capture success.
- Only 19% of the 53 brands in the study have French Facebook pages, despite the fact these communities are the largest and fastest growing among the EU 5 countries.
The study also notes that some brands are looking to lessen their dependence on the more traditional media channels for marketing, branding and advertising, including:
- L'Oréal Paris has made a significant investment in video and leads in YouTube views across the EU 5 markets.
- Estée Lauder has extended its already-robust U.S. direct-to-consumer e-commerce businesses for is Aveda, Bumble and bumble, and Ojon brands to select markets, disrupting traditional salon distribution.
- Tresemmé has built fan loyalty through a Facebook app that incentivizes social sharing through product rewards.
- P&G digital and mobile e-education portal provides professional resources and tutorials customized for each of the EU 5 markets and languages.
Learn more about the digital efforts and effectiveness of hair care and color brands in Europe by downloading an excerpt of this report, as well as obtaining the information to order the full report, here.

subset: commoncrawl


text:
I can't believe autumn is almost here. I've spent most of the summer busy as a bee, a little travel, a few exciting photo jobs, a new puppy, (who is currently snoozing at my feet as I type this) with little time to blog or bake.
I had a few free hours this afternoon, and I spent them baking this tomato cobbler. It's an idea I've had in my head for a while, a savory cobbler instead of sweet (not a very original idea, true, but new for me!), but I wasn't sure which direction I wanted to go with it. Then I found this recipe from Martha Stewart. It was just what I was looking for.
This cobbler has it's feet firmly planted in two seasons. It's bursting with juicy, late summer tomatoes, but it has the feel of fall. It's warm and filling, just the thing for when the evenings turn cool. It's perfect for the in between. A transitional cobbler.
The original recipe uses a different biscuit recipe, and gruyere instead of thyme. I think gruyere AND thyme would be perfect, but I didn't have any. If you try it out, let me know! Also, the thyme biscuits are perfect on their own. Just preheat your oven to 400, form into rounds, place on a baking sheet, and bake for 10-12 minutes.
Tomato Cobbler
Adapted from Martha Stewart
Serves 4
For the filling
extra virgin olive oil
1 large onion, thinly sliced
2 garlic cloves, thinly sliced
2 pounds grape tomatoes
3 tablespoons all-purpose flour
coarse salt and freshly ground pepper
For the biscuit topping
2 cups all purpose flour
1 tablespoon baking powder
1 tablespoon fresh thyme (plus more for garnish)
1/2 teaspoon salt
1/2 cup butter
3/4 cup heavy cream or buttermilk
Make the filling: Heat 3 tablespoons of oil in a large high-sided skillet over medium heat. Cook onions, stirring occasionally, until caramelized, about 25 minutes. Add garlic, and cook until fragrant, about 3 minutes. Let cool.
Toss onion mixture, tomatoes, flour, and red-pepper flakes with 1 teaspoon salt and some pepper.
Preheat oven to 375 degrees.
Make the biscuit topping: Whisk together flour, baking powder, thyme and salt in a bowl. Cut in butter with a pastry cutter or rub in with your fingers until small clumps form. Add cream, stirring with a fork to combine until dough forms. (Dough will be slightly sticky.)
Transfer tomato mixture to a 1 quart baking dish or medium cast iron pan. Spoon 5 clumps of biscuit dough over top in a circle, leaving center open. Brush dough with cream. Bake until tomatoes are bubbling in the center and biscuits are golden brown, about 45 minutes. Transfer to a wire rack. Let cool for 20 minutes.


text:
Acupuncture for Fertility in Los Angeles, CA
Acupuncture is an ancient staple of Traditional Chinese Medicine (TCM) which involves the insertion of thin needles into the surface of the skin in varying depths at various acupuncture points on the body. Modernly, the positive effects of acupuncture have gone beyond stress reduction and pain relief, and it is now believed that acupuncture is an effective natural therapy for stimulating fertility when used alone or in conjunction with in-vitro fertilization (IVF) or fertility drugs.
There's an acupuncturist in Los Angeles that can provide you a natural fertility treatment using acupuncture. Call (424) 365-1800 or contact Vitality Integrative Medicine online.
Acupuncture & Pregnancy
Acupuncture and pregnancy are much more intertwined than you would think. Acupuncture stimulates the production of a single egg, statistically increasing the chances of in vitro success by over 26%, some studies suggest. While the science is not clear on why acupuncture works, theories and cutting-edge research suggest it may possibly increase blood flow (and thus hormonal stimulation) to the ovaries and increase the volume of egg follicles available for fertilization. The increased blood flow to reproductive organs may supply hormones and nutrients to strengthen weakened uterine linings that contribute to miscarriage.
In TCM, acupuncture is thought to stimulate and clear blockages to the flow of Qi or life energy, but modern brain researchers note that the relationship between acupuncture and infertility may have clear connections in brain chemistry, with acupuncture and brain hormones linked to conception. Acupuncture also increases production of "feel good" endorphins which help to regulate menstrual cycles.
Benefits of Acupuncture for Fertility
Recent studies have suggested that there are benefits to choosing acupuncture as an infertility treatment option. Acupuncture for fertility benefits include:
- Effective and natural for both men and women: The roots of infertility can be found in males as often as in females, and sometimes concurrently in both (e.g., a combination of low sperm count in the male and decreased egg production in the female). Modern fertility drugs are typically not nearly as effective for men as they are for women. Acupuncture has been associated with an increased number of healthy sperm, fewer defective sperm, increased sperm count and improved sperm motility.
- Improves your body's function: Used alone, without medical intervention or fertility drugs, acupuncture can increase chances of conception through balancing the endocrine system and stimulating neuroendocrine effects impacting ovaries, hypothalamus and pituitary glands. It also can impact metabolism and modulate both the peripheral and central nervous systems.
- Fewer side effects: Fertility drugs commonly prescribed have side effects including abdominal tenderness, bloating, fluid retention, weight gain and nausea. Acupuncture, by contrast, offers few to no side effects, stimulating the hypothalamus to naturally balance the endocrine system and its hormones, often the root cause of infertility in women and men.
- Stress relief: Acupuncture can also reduce stress and lower cortisol levels. Cortisol can disrupt hormonal balance and be a direct cause of infertility. However, stress can cause impotence in men by lowering sperm count and sperm motility. In women, stress can bring ovulation to a halt or impede the successful implantation even once an egg has been successfully fertilized.
What to Expect During an Acupuncture Session
Your acupuncturist should ask general health questions and review your medical history prior to your first acupuncture session. A medical examination may be required.
All acupuncture involves the relatively painless insertion of thin needles inserted in varying depths below the surface of the skin at any of over 400 identified energy points along meridians on your body. Your particular condition and issues will determine how many and where needles will be used on your body. These acupuncture needles may be stimulated by heat or electricity during you acupuncture session.
Acupuncture needles should be sterile and never be reused. Sessions can range from 20 minutes to 2 hours. IVF treatment programs are recommending - some even requiring - acupuncture for infertility patients with 6-12 acupunctures sessions recommended as a minimum, but perhaps necessitating as much as 3-9 months of ongoing acupuncture sessions at least twice each week.
To request more information about acupuncture and infertility, or to begin a treatment regimen using acupuncture as a natural fertility treatment option, call (424) 365-1800 or contact Vitality Integrative Medicine online.
Vitality Integrative Medicine
4849 Van Nuys BlvdSuite 104
Sherman Oaks, CA 91403
(424) 365-1800
8:00 am - 6:00 pm
8:00 am - 6:00 pm
8:00 am - 6:00 pm
8:00 am - 6:00 pm
8:00 am - 6:00 pm
8:00 am - 12:00 pm


text:
Postal Reform Isn't Happening in 2013
For the third time in two months, Senate committee cancels plans to move forward with USPS overhaul.
There's always next year.
Such has become the refrain for the often discussed, much sought after prize of overhauling the U.S. Postal Service. Lawmakers were again set to deliver postal reform in 2013, and at various points of the year set goals of March, August and Thanksgiving for passage. But after the latest in a series of setbacks, the window for acting on legislation in 2013 has closed, and reformers will have to renew their fight after New Year's.
The Senate had scheduled one last effort to move its bipartisan legislation through the Homeland Security and Governmental Affairs Committee for Wednesday, but the markup was cancelled. This was the third such scheduled markup -- during which committee members can propose and vote on amendments, as well as vote on whether to push the bill forward to the full Senate -- cancelled since November.
Lawmakers remain optimistic Congress can get a bill to the president's desk at some point in the near future, however. While the previous cancellations were attributed to needing time to address "concerns raised by members of the committee and stakeholder groups," a committee aide said the latest delay was simply a matter of timing.
"Given the busy floor schedule and remaining work on the bill, the Chairman [Sen. Tom Carper, D-Del.] and Ranking Member [Sen. Tom Coburn, R-Okla.], as well as committee members and stakeholders, thought it would be helpful to postpone the markup until the new year," the aide told Government Executive. The aide added Carper continues to work with all interested parties to develop a workable bill.
The reform measure introduced by Carper and Coburn has received significant criticism, including from several of the oversight committee's Democratic members, who have said it cuts too deeply and allows USPS to raise its rates unilaterally.
The American Postal Workers Union -- one of the bill's most vocal opponents -- was "pleased" the markup was delayed and pledged to continue to stand against its passage.
"Our fight is not over," APWU President Mark Dimonstein said.
The House Oversight and Government Reform Committee already has passed a bill of its own, authored by Chairman Rep. Darrell Issa, R-Calif. In September, Issa's office said he hoped to bring the bill to the full House "in the near future," though a vote has yet to occur.
(Image via Flickr user Aranami)
NEXT STORY: Play of the Day: The Conservative Coloring Book


text:
The Intolerance Network
Over 17,000 documents from HazteOir and CitizenGO, Spanish right-wing campaigning organizations. Their links to Spain's far-right political party Vox and the Mexican sect El Yunque are well documented. These documents include HazteOir founding CitizenGo in 2013 to expand their reach, as well as their organzing of the 2012 World Congress of Families, an influential American far-right platform. Read the press release here.


text:
I've read that—unless I know a lot about typesetting—I shouldn't change the margins of a LaTeX document. The default margin size of the article
class is really big and it feels like a lot of space is waste. Thanks to the geometry
package, it is simple to change the margins, but I'm not sure if I should.
Can someone tell me why the default margin size is so big? Also, why shouldn't I change the margin size?


text:
With all the free agency chaos that has been engulfing the league in the last month, it's easy to forget about the season that just ended. This will be the culmination of the positional recaps here at Razzball, and honestly it's about time. When these recaps started, Sky was still running the show, Nick Capozzi was still in Canada, and Jay and I had never met (Note: We still have not met). Things have changed in the IDP world as well. Some of these guys are already on different teams, and others have seen their teams go out and sign players who will potentially replace them in 2014. Such is life for DBs in IDP leagues.
These recaps will focus mostly on how each player landed in the top-20 last year, and whether or not they can do it again in 2014. Spoiler alert: a lot of them can't.
Please, blog, may I have some more?


text:
10 Silent Signals You're Way Too Stressed
The occasional manic Monday is a fact of modern life. But if you're under chronic stress—suffering a daily assault of stress hormones from a demanding job or a personal life in turmoil—symptoms may be subtler, says Stevan E. Hobfoll, PhD, chair of the department of behavioral sciences at Rush University Medical Center. If you experience any of the signs that follow, take some time out every day, he says, whether it's to go for a walk or simply turn off your phone.
1. Stress Symptom: Weekend headaches
A sudden drop in stress can prompt migraines, says Todd Schwedt, MD, director of the Washington University Headache Center. Stick closely to your weekday sleeping and eating schedule to minimize other triggers.
2. Stress Symptom: Awful period cramps
The most stressed-out women are more than twice as likely to experience painful menstrual cramps as those who are less tense, a Harvard study found. Researchers blame a stress-induced imbalance of hormones. Hitting the gym can soothe cramps and stress, research shows, by decreasing sympathetic nervous system activity.
3. Stress Symptom: An achy mouth
A sore jaw can be a sign of teeth grinding, which usually occurs during sleep and can be worsened by stress, says Matthew Messina, DDS, a consumer adviser to the American Dental Association. Ask your dentist about a nighttime mouth guard—up to 70% of people who use one reduce or stop grinding altogether.
4. Stress Symptom: Odd dreams
Dreams usually get progressively more positive as you sleep, so you wake up in a better mood than you were in when you went to bed, says Rosalind Cartwright, PhD, an emeritus professor of psychology at Rush University Medical Center. But when you're stressed, you wake up more often, disrupting this process and allowing unpleasant imagery to recur all night. Good sleep habits can help prevent this; aim for 7 to 8 hours a night, and avoid caffeine and alcohol close to bedtime.
5. Stress Symptom: Bleeding gums
According to a Brazilian analysis of 14 past studies, stressed-out people have a higher risk of periodontal disease. Chronically elevated levels of the stress hormone cortisol may impair the immune system and allow bacteria to invade the gums, say researchers. If you're working long hours and eating dinner at your desk, keep a toothbrush on hand. And "protect your mouth by exercising and sleeping more, which will help lower stress," says Preston Miller, DDS, past president of the American Academy of Periodontology.
6. Stress Symptom: Out-of-nowhere acne
Stress increases the inflammation that leads to breakouts and adult acne, says Gil Yosipovitch, MD, a clinical professor of dermatology at Wake Forest University. Smooth your skin with a lotion containing skin-sloughing salicylic acid or bacteria-busting benzoyl peroxide, plus a noncomedogenic moisturizer so skin won't get too dry. If your skin doesn't respond to treatment within a few weeks, see your doctor for more potent meds.
7. Stress Symptom: A sweet tooth
Don't automatically blame your chocolate cravings on your lady hormones—stress is a more likely trigger. When University of Pennsylvania researchers surveyed pre- and postmenopausal women, they found only a small decrease in the prevalence of chocolate cravings after menopause—smaller than could be explained by just a hormonal link. Study authors say it's likely stress, or other factors that can trigger women's hankering for chocolate.
8. Stress Symptom: Itchy skin
A Japanese study of more than 2,000 people found that those with chronic itch (known as pruritis) were twice as likely to be stressed out as those without the condition. Although an annoying itch problem can certainly cause stress, experts say it's likely that feeling anxious or tense also aggravates underlying conditions like dermatitis, eczema, and psoriasis. "The stress response activates nerve fibers, causing an itchy sensation," explains Yosipovitch.
9. Stress Symptom: Worse-than-usual allergies
In a 2008 experiment, researchers from Ohio State University College of Medicine found that allergy sufferers had more symptoms after they took an anxiety-inducing test, compared with when they performed a task that did not make them tense. Stress hormones may stimulate the production of IgE, a blood protein that causes allergic reactions, says study author Janice Kiecolt-Glaser, PhD.
10. Stress Symptom: Bellyaches
Anxiety and stress can cause stomachaches, along with headaches, backaches, and insomnia. One study of 1,953 men and women found that those experiencing the highest levels of stress were more than three times as likely to have abdominal pain as their more-relaxed counterparts. The exact connection is still unclear, but one theory holds that the intestines and the brain share nerve pathways; when the mind reacts to stress, the intestines pick up the same signal. Because of this link, learning to manage stress with the help of a clinical psychologist, meditation, or even exercise can usually help relieve tummy trouble too. However, if you have frequent bellyaches, see your doc to rule out food allergies, lactose intolerance, irritable bowel syndrome, or an ulcer.
Previous articles:
- 15 Secrets Of Seriously Sexually Satisfied Long-Te...
- I'm A Man, And I've Spent My Life Ashamed Of My Bo...
- 15 Benefits of Cold Showers That Will Blow Your Mi...
- 12 Things Real Women Find Gross About Men's Groomi...
- 5 Ways To Be Heard


text:
A healthier version of a classic Italian dessert
Source: Adapted from An Italian Cooking in the Midwest
Taste: 3 (out of 5)
Difficulty: 1 (out of 5)
- 1 cup non-fat yogurt
- 1 cup milk
- 1 tbsp gelatin
- 3 tbsp cold water
- 4 tbsp sugar
- 2 tbsp lingonberry syrup
- 1 tsp vanilla extract
Total: 4-6 servings (depending on serving size)
1. Soak the gelatin in cold water for about 5-10 minutes until it blooms.
2. In the mean time warm the milk until it starts to boil. Add the sugar, the lingonberry extract and the vanilla and mix. Add the gelatin and mix until dissolved.
3. Remove the milk from the heat and add the yogurt. Mix well.
4. Using a strainer to leave out gelatin lumps, pour the mixture into serving bowls and refrigerate for several hours until set.
5. Decorate with your favorite fruit or sauce and serve cold.
- I have to admit that I have deviated from the original recipe, it called for Greek yogurt, and I used a non-fat one, so my "panna cotta" lacked any creaminess and was more similar to yogurt jello. Another addition to the recipe that I made, using the lingonberry syrup, was probably another mistake, because as soon as I added it to the hot milk, it started separating. I love lingonberry syrup in milkshakes, it adds a really nice sweet and tangy flavor, but I did not account for the milk temperature in this case. So my panna cotta also did not look very pretty. Fortunately, the fruit topic hid the most of my wrong doings :-). And overall, after a heavy dinner, this panna cotta turned out to be a nice tangy dessert.
- This post was my SRC assignment. Just in case you don't know yet, SRC, or the Secret Recipe Club is a group of over a hundred food bloggers, who are assigned a "secret" blog each months. Then they choose a recipe from that blog, make it and post it on their own blog on a given reveal day. Then there is a big party, where you hop from one blog to another and check what everyone's been cooking. Lots of fun! And terrible for your diet ;-) I want to thank Amanda, Jane and April for making it all possible!
- Pola, the author of Italian in the Midwest, as the name of her blog suggests, has a lot of yummy Italian recipes on her blog, some classic and some with very original twists, for example her eggplant pesto. I will be back for that recipe.


text:
The NESEA community has a history of trying to fix our buildings as a way of improving our communities. It's time to shift our perspective, and think more about fixing our communities as a way of improving our buildings. To that end, Robert Leaver, Heather Nolen, and I have lined up an trio of expert presenters for a carbon-neutral cities workshop at BuildingEnergy Boston: Gustaf Landahl, Climate and Environment Strategist for Stockholm, Sweden; Jørgen Abildgaard, Executive Climate Project Director for Copenhagen, Denmark; and Susanne Rasmussen, Director of Environmental and Transportation Planning for Cambridge, MA.
I understand that we need to fix both buildings and communities. But I also believe we need to strike a better balance than we have so far. Sometimes I worry that a lot of us in the NESEA community are a little like the person who only has a hammer for a tool, and therefore sees everything as a nail. Most of us are architects, builders, and engineers; we work on buildings.
We don't spend a lot of time thinking about the various transportation networks and energy grids those buildings fit into, so we fall into thinking that the buildings themselves need to be the solution to the current energy and environmental challenges we face.
A good example of this is the way in which our conversations in recent years have come to be inspired by some recent very aggressive building standards: Passive House, zero-net energy, and deep energy retrofits. These are indeed transformative standards and goals. And as a result of our conversations, we are designing and constructing much better new buildings, and making more profound improvements to existing buildings.
Although these new standards have greatly improved many of our buildings, within these aggressive standards there is no accounting for the fact that, because of our fossil-fuel transportation networks, a quarter to a third of the embodied energy of a deep energy retrofit can be the result just of getting people to the jobsite and then back home at the end of the day.
Or for the fact that when you calculate the total operating energy—including commuting energy—of a household, a leaky old home in the city can look better than a Passive House in the country. Or for the fact that the social value of a PV panel in a densely developed area is greater than that of the same panel on a zero-net energy home in an outer suburb.
I took a 2-week study tour to Sweden and Denmark in 2014 with NESEA colleagues Heather Nolen, Chris Benedict, Tom Hartman, and Andy Shapiro. We were there to look at outstanding buildings. We certainly found some nice buildings to tour, but the best buildings within the NESEA community are every bit the equal, if not better than, the best buildings we found in Scandinavia.
In much of Scandinavia, there does not need to be so much pressure on a building to be an outstanding performer because their communities make sure that their networks and grids meet the building half way.
Stockholm aims to be a fossil-fuel free community by 2050. This will require not only reengineering its energy supply system, but also becoming a more energy-efficient economy so that the demand for non-fossil fuel energy does not exceed the ability of the region to meet the demand.
Stockholm's overall calculations have determined (at least for now) that its new building standard can be 2 - 3 times more relaxed than the Passive House standard. The savings from not having to achieve Passive House on a wide scale will help make it less costly to provide housing for the anticipated 40% increase in population between now and 2050. This is a good example of the community meeting the building half way.
In another example, Copenhagen is nearing completion of a multi-decade changeover from an oil-fired boiler in each building to a district heating connection in each building; currently 98% of the dwellings in Copenhagen are on a district heating system. The district-scale heating systems are combined heat and power plants, so they produce much of the electricity the buildings need in addition to the heat.
Although it still relies on a large percentage of coal to power these plants (an inconvenient truth that's not as well publicized as the fact that about 40% of Denmark's energy comes from wind), Copenhagen's plan over time is to switch from coal to such fuels and technologies as industrial-scale heat pumps powered by wind farms and district boilers powered by biomass and garbage. As Copenhagen gradually reduces the carbon content of the energy generated by these district heat and power stations, it reduces the carbon footprint of every building in the city, so there's less need for each building to meet aggressive (and often costly) energy standards to do its part in reaching the overall goal of community carbon-neutrality.
These extraordinary things that Stockholm and Copenhagen are achieving might seem interesting but ultimately pie-in-the-sky impractical for municipal planners and administrators here in the Northeast who can only dream of converting whole cities to low-carbon district heating and electricity systems. But it's not just Scandinavian cities that will be represented on our panel: Cambridge, MA, has its own aggressive plan to achieve zero net emissions in its building stock. Although the panelist from Cambridge, Susanne Rasmussen, was born and educated in Denmark, she still represents a ray of hope that we Americans also can and will get big things done here in the Northeast.
A key goal for this workshop is that each participant walk away at the end of the day feeling not only inspired, but also confident that he or she learned something immediately useful, practical, and empowering; and, most importantly, knows what the next step would be once back at home. A big promise, but one I am confident Gustaf, Jørgen, and Susanne will keep, regardless of the workshop participant— professional planner, elected official, community organizer, or concerned and motivated citizen.
Our Mission
NESEA advances sustainability practices in the built environment by cultivating a cross-disciplinary community where practitioners are encouraged to share, collaborate and learn.
Recent Posts
BE Boston 19 RegistrantsBE Boston 20 RegistrantsBE Boston 21 RegistrantsBE Boston 23 RegistrantsBE Boston 24 RegistrantsBottom Lines - Plan ByggBuildingEnergy 16 Full ConferenceBusiness MemberGreen Company ManagerMemberWebform Results Access
BE Boston 19 RegistrantsBE Boston 20 RegistrantsBE Boston 21 RegistrantsBuildingEnergy 16 Full Conference
BE Boston 19 RegistrantsBE Boston 20 RegistrantsBE Boston 21 RegistrantsBE Boston 22 RegistrantsBE Boston 23 RegistrantsBuildingEnergy 16 Full ConferenceMemberWebform Results Access


text:
Search South Florida Homes for Sale
Searching properties online is just the first step in making your next move a smooth one. Call Georgeé & Company now at 305.333.7857, or email us, so we can put our accent on your property search success. We will respond to your email immediately during business hours or within 24 hours if during non-business hours.
Sorry we are experiencing system issues. Please try again.


text:
If you're ready for an exciting family vacation that everyone can enjoy, visit Annapolis RV Center, grab an RV rental, and say goodbye to your traveling angst. Contact us today at (410) 280-0800 to request more information, or request a quote online.
Whether you're traveling with family and friends or need a trailer for a film or photo shoot, our RV rentals have the features that will surely make for a more comfortable, enjoyable, and successful trip. We even have a convenient delivery and pickup service, upon request.
Wide Selection of RV Rentals
Routine vacations can sometimes be no fun, so make sure you reevaluate your trip and mix up your travels with something new. Perfect for annual family reunions, camping adventures, road trips, and tailgating events, an RV rental in Baltimore and the surrounding areas offers everyone a way to enjoy the trip. We have a variety of RVs to choose from, including trailer rental and motorhome rental options, so finding your vacation vessel won't be a difficult task.
Quality Production Rentals
Success may be in the eye of the beholder, but we all know that being successful means having the right people supporting you. In the case of film and production shoots, ensuring your cast and crew members are comfortable is a surefire way to increase the likelihood of success. Our production trailers are also perfect for concert venues, local events, and fairs.
Request Your Quote Now!
RV Parts and Service
Finding a mechanic that can rejuvenate your RV or camper can be a task, but at Annapolis RV Center, we have mechanics on hand to assist our customers in repairing, servicing, and finding parts for their homes on wheels. If you've noticed strange noises coming from the engine, or have a dim headlight, we'll pop the hood and take a look. Our professionals are experts when it comes to repairing RVs, so your motorhome will be back on the roads of Maryland in no time!
At Annapolis RV Center, we look forward to providing you with the most modern and affordable RV rentals in Baltimore, Annapolis, MD, and the Washington, DC areas. Contact us today at (410) 280-0800 to receive more information, or read through our FAQs and policies for details on how we operate. We look forward to letting you experience our quality RV rentals.


text:
How Matching Funds Would Reshape the 2016 Presidential Election
Candidates in the 2016 presidential race would see a dramatic shift in their fundraising, and have a powerful incentive to focus more on small donors under a proposed small donor public financing system, according to a new study released by OSPIRG Foundation.
OSPIRG Foundation
With more than a year to go before voters cast their ballots for the next President of the United States, the race among candidates to build the biggest campaign war chest has already set records. The vast majority of the funds raised for the 2016 election have come from wealthy donors making contributions exponentially larger than most Americans can afford, typically to super PACs and other organizations that can legally accept donations of any size.
This report examines how the 2016 presidential race would be reshaped by a public financing system that amplifies the voices of small donors in our elections. The 2016 election will likely break all previous campaign spending records. But more important than the amount of money spent is where that money is coming from. Under our current system, courting wealthy mega-donors – who often have different priorities and policy preferences than most voters – has taken precedence over appealing to everyday Americans.
It doesn't have to be that way. What if our campaign finance system encouraged candidates to raise money from everyday citizens making small contributions? This report examines how the 2016 fundraising picture through the July Federal Election Commission (FEC) filing deadline would look if a small donor campaign finance system were in place, where small contributions were matched with limited public funds for candidates who agree to turn down large contributions.
This analysis demonstrates that under such a system, candidates relying on large donors would have a powerful incentive to shift their fundraising strategy to focus on small donors, and access to a narrow set of wealthy donors or vast personal wealth would not determine the viability of a presidential campaign.