FEED Validator

for Atom and RSS and KML

Congratulations!

This is a valid RSS feed.

Recommendations

This feed is valid, but interoperability with the widest range of feed readers could be improved by implementing the following recommendations.

line 23, column 0: description should not contain data-lang attribute (13 occurrences) [help]
```
&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;la ...
```
line 195, column 0: description should not contain relative URL references: /images/posts/consultant-configuration-management-with-consul/consul-web-ui.png (6 occurrences) [help]
```
</description>
```

line 368, column 0: description should not contain script tag [help]

&lt;script src=&quot;https://gist.github.com/wouter-willems/574a70cf4bc2aee1 ...

Source: https://labs.magnet.me/feed.xml

<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>Magnet.me | Labs</title>
<description>On this blog we share our thoughts and experiences.</description>
<link>https://labs.magnet.me/</link>
<atom:link href="https://labs.magnet.me/feed.xml" rel="self" type="application/rss+xml" />
<pubDate>Thu, 19 Jul 2018 14:10:22 +0000</pubDate>
<lastBuildDate>Thu, 19 Jul 2018 14:10:22 +0000</lastBuildDate>
<generator>Jekyll v3.8.1</generator>
<item>
<title>Async await in AngularJS</title>
<description>
ES7 introduces <a href="http://tc39.github.io/ecmascript-asyncawait/">async functions</a>, which allow you to write asynchronous code with a synchronous syntax. Unfortunately this doesn't work well with AngularJS: awaited code will run outside of Angular's digest loop, and therefore it won't trigger watchers or view updates.


<h1 id="the-problem">The problem</h1>
ES7 introduces async functions that allow to write async code with a synchronous syntax. This looks like this:
<figure class="highlight"><pre><code class="language-javascript" data-lang="javascript">async function() {
await doSomethingAsync();
console.log("Something is done!");
await doSomethingElseAsync();
console.log("Something else is also done!");
}</code></pre></figure>
This works because <code class="highlighter-rouge">await</code> expects a promise as arguments, and it waits until the promise is resolved before continuing.
Unfortunately this doesn’t work well in AngularJS: awaited code is not run in the digest loop, and therefore we need to put <code class="highlighter-rouge">$scope.$apply</code> calls all over the place. This results in code like this:
<figure class="highlight"><pre><code class="language-javascript" data-lang="javascript">async function initialize() {
$scope.user = await users.getActiveUser();
$scope.$apply();
$scope.messages = await conversations.getMessagesFor($scope.user);
$scope.$apply();
}</code></pre></figure>
Obviously this isn’t ideal, it would be better if we could omit the <code class="highlighter-rouge">$scope.$apply</code> calls.
<h1 id="meet-async">Meet $async</h1>
Fortunately there is a way out. Thanks to the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*">generator functions</a> introduced in ES6 we can write our own async engine that does work well with AngularJS. At Magnet.me we’ve created the <a href="https://github.com/Magnetme/ng-async">$async</a> module which does exactly that. With <code class="highlighter-rouge">$async</code> we can rewrite the initialize function like this:
<figure class="highlight"><pre><code class="language-javascript" data-lang="javascript">const initialize = $async(function*() {
$scope.user = yield users.getActiveUser();
$scope.messages = yield conversations.getMessagesFor($scope.user);
});</code></pre></figure>
Instead of an async function we now use a generator function passed to <code class="highlighter-rouge">$async</code>, and instead of <code class="highlighter-rouge">await</code>ing a promise we now <code class="highlighter-rouge">yield</code> a promise.
<h1 id="how-it-works">How it works</h1>
Generator functions do not run to completion when they are invoked. Instead they return an iterator that can be iterated over manually. This iterator will stop and “return” at every call to <code class="highlighter-rouge">yield</code>. For example, the following generator function generates all positive integers:
<figure class="highlight"><pre><code class="language-javascript" data-lang="javascript">function* integersGenerator() {
let i = 1;
while (true) {
yield i;
i++;
}
}
const integersIterator = integersGenerator();
integersIterator.next().value; //1
integersIterator.next().value; //2
integersIterator.next().value; //3
//etc.</code></pre></figure>
The <code class="highlighter-rouge">$async</code> module makes use of the ability to pause generator functions to emulate async functions. It expects a generator that will generate promises, and it will chain all these promises together correctly. The result is that each <code class="highlighter-rouge">yield</code> call will wait for its promise to be resolved before continuing. The core of <code class="highlighter-rouge">$async</code> looks something like this:
<figure class="highlight"><pre><code class="language-javascript" data-lang="javascript">//This function iterates asynchronous over an iterator
function iterateAsync(iterator) {
//First run until the first yield. 
//`.value` should now contain the yielded promise
return iterator.next().value
//Then we wait until the promise has resolved, 
//and recursively iterate again
.then(() =&gt; iterateAsync(iterator));
}
//usage:
iterateAsync(function*() {
yield somePromise;
yield someOtherPromise;
//etc.
});
//This is effectively the same as this:
somePromise
.then(() =&gt; someOtherPromise())
.then(/*etc*/);</code></pre></figure>
Now that we have our own async engine it is trivial to make it work properly with Angular: we can add the call to <code class="highlighter-rouge">$scope.$apply</code> in the <code class="highlighter-rouge">iterateAsync</code> function and there it is: an async function that works with AngularJS!
The entire module is only a couple of lines long, if you’re interested in all the details then check it out <a href="https://github.com/Magnetme/ng-async/blob/master/src/index.js">here</a>!
<h1 id="inspiration">Inspiration</h1>
To give credit where credit’s due, the idea of using generators to implement aysnc functions isn’t new. Libraries that do so exist for a long time, with the most well-known being <a href="https://www.npmjs.com/package/co">co</a>. <code class="highlighter-rouge">$async</code> is mostly inspired by <code class="highlighter-rouge">co</code>, but more lightweight and Angular-flavored.
</description>
<pubDate>Mon, 16 Nov 2015 18:00:00 +0000</pubDate>
<link>https://labs.magnet.me/nerds/2015/11/16/async-await-in-angularjs.html</link>
<guid isPermaLink="true">https://labs.magnet.me/nerds/2015/11/16/async-await-in-angularjs.html</guid>
<category>AngularJS</category>
<category>JavaScript</category>
<category>Nerds</category>
</item>
<item>
<title>Configuration management with Consul</title>
<description>Microservices are a hot topic, and there are many challenges you'll face when adopting this way of building software. In this blogpost we'll tackle the challenge of configuration. In particular how to manage the configuration of many different services located in a cluster where services are running in different datacenters, on a multitude of host machines or containers, and even potentially with different roles. Using <a href="http://github.com/Magnetme/consultant">Consultant</a> - a newly open-sourced Magnet.me project - we'll show you how to load your service's configuration with zero effort and subscribe to updates.

<h2 id="consul">Consul</h2>
We’ve been experimenting with <a href="https://consul.io">Consul</a> lately to manage service discovery, routing, and configuration for our (micro)services. Consul is a service developed by <a href="https://hashicorp.com">HashiCorp</a> which you can run in your cluster. Consul uses <a href="https://serfdom.io">Serf</a> to gossip between multiple running instances of Consul to share the location and state of services running in the cluster. In addition to this, Consul also provides a key/value store which allows you to store configuration or meta-data for the operation of your services. Consul is also datacenter aware, meaning that the you can not only search for the locations of a particular service in the entire cluster, but also limit that search to a particular datacenter to avoid long roundtrips. We’ll save the service discovery awesome-ness for another blogpost. Let’s focus on configuration!
<h2 id="configuration">Configuration</h2>
Configuration is an integral part of many services. If your service needs to talk to a database, it’s likely you’ll want to store the username, password, database name, and perhaps even the location of the database server if you’re not using service discovery. These settings are typically static, and don’t change while the service is running. There are also settings which are more dynamic and can change while a service is running, like settings regarding the number of workers for a certain task. All these settings are typically stored inside one or more configuration files which the service reads on startup. If the service supports dynamic configurations, typically the service watches these configuration files for changes, and reloads the configuration from disk when a change is detected.
The problem is managing all this configuration for every instance of the service in the entire cluster. For instance, what do you need to do if you want to alter the config of all service instances in a particular datacenter, running on a particular host, or with a particular role? With microservices this can be a bit of challenge as it’s likely the service instances might be running just about anywhere in your cluster. The solution to this problem is to make your configuration available from a service such as Consul, and make your services look their own configuration up depending on their location and role in the cluster.
<h2 id="integrating-consultant-with-a-service">Integrating Consultant with a service</h2>
Assuming you’ve already got Consul setup for your cluster, let’s look at how we can integrate Consultant into our JVM-based services, and let them retrieve their own configuration from Consul. Consultant was designed to be extremely simple to use, and to integrate with existing services. Below you’ll see how we can create a Consultant object for our news service, and retrieve a <code class="highlighter-rouge">Properties</code> object from it:
<figure class="highlight"><pre><code class="language-java" data-lang="java">Consultant consultant = Consultant.builder()
.identifyAs("news")
.build();
Properties config = consultant.getProperties();</code></pre></figure>
It’s highly recommended to provide environment variables specifying the datacenter, host, and role of this particular service instance. In case of our news service we’d want to specify the following environment variables: <code class="highlighter-rouge">SERVICE_DC=eu-central</code> to let it know it’s running in our EU datacenter, and <code class="highlighter-rouge">SERVICE_HOST=host-12.magnet.me</code> to let it know that it’s running on a specific host.
Consultant will instantly retrieve the configuration applicable for this news service running in that particular datacenter and on that particular host.
<h2 id="subscribing-to-changes">Subscribing to changes</h2>
But that’s not all Consultant does. Should we change any of settings in Consul’s key/value store, Consultant is immediately notified of this, and will update the <code class="highlighter-rouge">Properties</code> object. Should you wish to validate any configuration changes, then you can do that too:
<figure class="highlight"><pre><code class="language-java" data-lang="java">Consultant consultant = Consultant.builder()
.identifyAs("news")
.validateConfigWith((config) -&gt; {
Preconditions.checkNotNull(config.getProperty("database.username"));
Preconditions.checkNotNull(config.getProperty("database.password"));
Preconditions.checkNotNull(config.getProperty("database.url"));
})
.build();</code></pre></figure>
Should the validation fail, the <code class="highlighter-rouge">Properties</code> object will not be updated. This means that your service remains unaware of these changes in its configuration. Should you wish to be notified of when the service’s configuration is successfully changed you can also subscribe to these changes:
<figure class="highlight"><pre><code class="language-java" data-lang="java">Consultant consultant = Consultant.builder()
.identifyAs("news")
.onValidConfig((config) -&gt; {
System.out.println("Yay, we've got a new config!");
})
.build();</code></pre></figure>
Or if you’d like to be notified of a particular setting being changed:
<figure class="highlight"><pre><code class="language-java" data-lang="java">Consultant consultant = Consultant.builder()
.identifyAs("news")
.onSettingUpdate("database.password", (key, oldValue, newValue) -&gt; {
System.out.println("Hey the db password changed to: " + newValue + "!");
})
.build();</code></pre></figure>
These listeners will be called every time Consultant is able to retrieve a configuration from Consul’s key/value store which passes the validation (if you’ve specified any validation checks).
<h2 id="storing-the-config-in-consuls-keyvalue-store">Storing the config in Consul’s key/value store</h2>
Now that we can have our services retrieve their configuration from Consul’s key/value store, it’s time to see how we can store our settings in there. The easiest way to do this, is to manually add the configuration through Consul’s web UI. Simply by adding a new entry with a key matching the pattern: <code class="highlighter-rouge">config/&lt;service_name&gt;/&lt;setting_name&gt;</code> you can define a setting with that particular name, for that particular service.
If you wish to define a setting which overrides the default value for a particular datacenter, host, or instance you can do so by defining a selector block. In that case the key should follow one of these patterns:
<figure class="highlight"><pre><code class="language-java" data-lang="java">config/&lt;service_name&gt;/[dc=&lt;datacenter_name&gt;].&lt;setting_name&gt;
config/&lt;service_name&gt;/[host=&lt;host_name&gt;].&lt;setting_name&gt;
config/&lt;service_name&gt;/[instance=&lt;instance_name/role&gt;].&lt;setting_name&gt;</code></pre></figure>
Note that you can even mix and match these to define even more specific groups by for instance specifying a selector such as: <code class="highlighter-rouge">[dc=eu-central,host=app-12.magnet.me]</code>.
<img src="/images/posts/consultant-configuration-management-with-consul/consul-web-ui.png" alt="Consul's web UI" />
<h2 id="summary">Summary</h2>
Using Consul and Consultant, Magnet.me is able to have each service retrieve its own configuration from Consul. By subscribing to changes in that configuration, we are able to alter the behaviour of our services at runtime, tweak the performance of our services at runtime, and even run the same configuration in development environments as we do in production environments. We hope you’ve enjoyed this blogpost, and that you’ll give Consul and Consultant a try! Consultant is available from <a href="http://search.maven.org/#search%7Cga%7C1%7Cme.magnet.consultant">Maven’s Central Repository</a>!
</description>
<pubDate>Mon, 26 Oct 2015 12:00:00 +0000</pubDate>
<link>https://labs.magnet.me/nerds/2015/10/26/consultant-configuration-management-with-consul.html</link>
<guid isPermaLink="true">https://labs.magnet.me/nerds/2015/10/26/consultant-configuration-management-with-consul.html</guid>
<category>Configuration</category>
<category>Tutorials</category>
<category>Consul</category>
<category>Nerds</category>
</item>
<item>
<title>Trying out InfluxDB and Grafana</title>
<description>At Magnet.me we try to measure and log everything. We use it to get a better understanding of our customers and our software. We already had Kibana and Logstash in place, but we were still missing some functionality to cover all our metric needs. We ended up trying InfluxDB and Grafana as our main tooling. In this blog post, we'll tell you how to try it out yourself, and why you should give it a shot.

<h2 id="why-measure">Why measure</h2>
There are tons of <a href="https://codeascraft.com/2010/12/08/track-every-release/">great</a> <a href="https://vwo.com/blog/multi-armed-bandit-algorithm/">blogs</a> about measuring so I’ll just say a few words about our aproach.
At Magnet.me we use <a href="http://en.wikipedia.org/wiki/OKR">OKRs</a>. In short, it means we set quarterly objectives and we validate if we achieve them by setting measurable goals for ourselves. This implies that we need to be able to measure everything we build. Often this concerns how users use our product.
For example, when we try to get costumers to respond to a message 15% more often, we might choose to change the email we send them, or change user they way the reply button looks on our website. To measure the result of these changes we first need to know how many users used to go to the reply page, and from where. Then we try new versions of the email, add buttons to reply on the website, or change the buttons we already have. We then measure the difference. If we achieve our goal, we move on to the next goal. If we fail, we adjust our strategy. By doing this rapidly in a loop until we reach our goal, or decide it can’t be reached, it is easy for us to keep our focus and not falsly assume something is fixed because we put some effort in.
To achieve this, we need a bunch of metric tools. One that:
<ol>
<li>measures how users navigate through our site. We use Google Analytics for this.</li>
<li>allows us to A/B test. We also use Google Analytics for this if it is a test happening in the browser.</li>
<li>tracks clicks in the email to the desired state, including the time it took the user to respond.</li>
</ol>
For the last job, logging the time it took to go to the state, we did not have a great solution yet. We used to just log it and then query it with Kibana, but that had a couple of downsides. Kibana 3 (at the time) could only show one dashboard per index. Also, you cannot annotate graphs in Kibana, so marking when you launched an experiment is not possible.
<h2 id="why-influxdb">Why InfluxDB</h2>
When we started to look for a metric database, you soon find out you need a <a href="http://en.wikipedia.org/wiki/Time_series_database">Time series database</a>. It seems like most developers are using the <a href="https://www.digitalocean.com/community/tutorials/how-to-configure-statsd-to-collect-arbitrary-stats-for-graphite-on-ubuntu-14-04">StatsD + Graphite</a> stack for this. However, I never liked the UI of Graphite so we decided to use <a href="http://grafana.org/">Grafana</a> instead. On the Grafana site we ran into a great tool called <a href="http://influxdb.com/docs/v0.8/introduction/overview.html">InfluxDB</a>. InfluxDB has a couple of design goals I like in comparison to the design of StatsD:
<ol>
<li>It’s horizontally scalable</li>
<li>Besides metrics, it also stores events</li>
<li>It stores on disk and in-memory.</li>
<li>Expand storage by adding servers to a cluster. Should make node replacement quick and easy.</li>
<li>Automatically compute common queries continuously in the background.</li>
</ol>
<h1 id="setting-it-up">Setting it up</h1>
Assuming you have Docker (or boot2docker if you’re on a mac) installed, we kick off by starting up an InfluxDB instance:
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker run -d -p 8083:8083 -p 8086:8086 -e PRE_CREATE_DB="db1" --name=influxdb tutum/influxdb
</code></pre></div></div>
This will fire up the admin dashboard on port <code class="highlighter-rouge">8083</code> and the API on <code class="highlighter-rouge">8086</code>. We set it up to pre-create the database <code class="highlighter-rouge">db1</code> for testing purposes. Open <a href="">http://localhost:8083</a> or on mac <code class="highlighter-rouge">open http://$(boot2docker ip):8083</code>. Login with username and password <code class="highlighter-rouge">root</code>. You don’t have to populate the database. You should see our <code class="highlighter-rouge">db1</code> in the list. Good, now we’re ready to send some data!
At this point, I recommend following the steps in the <a href="http://influxdb.com/docs/v0.8/introduction/getting_started.html">InfluxDB Getting Started Guide</a>. They have a piece of JavaScript you can run to insert a bunch of data points. Take your time to go through the introduction and insert that data. Go on. I’ll wait.
<h2 id="grafana">Grafana</h2>
Now that you’ve played around with Influx a little it’s time to sprinkle a little of that Grafana magic on top. Pop back into your terminal and fire up a grafana instance:
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker run -d -p 80:3000 --link=influxdb:influxdb grafana/grafana:2.0.2
</code></pre></div></div>
Then open <a href="">http://localhost</a> or on mac <code class="highlighter-rouge">open http://$(boot2docker ip)</code>. Login using using username and password “admin”, click the Grafana logo on the top-left, and go to “Data Sources”, “Add New”. Here we’ll fill
in our influx database. Because we linked the containers using <code class="highlighter-rouge">--link=influxdb:influxdb</code> the Grafana instance (which proxies the HTTP requests) can reach influx at <a href="">http://influxdb:8086</a> (the port for the API). We’ve set-up the influx database with username/password “root” and our database is called “db1”. Let’s just call the datasource “Influx”.
<img src="/images/posts/measure-all-the-things/add-datasource.png" alt="adding a datasource" />
Now that we have a datasource, let’s create a new dashboard from the dashboard menu. Then click the little green button on the left and press “Add Panel” &gt; “Graph”. Grafana will show a fake graph to give you an impression, but we want our data from influx. Click on the title of the graph and press ‘edit’. Select “Influx” as our data source. In the <a href="http://influxdb.com/docs/v0.8/introduction/getting_started.html">InfluxDB Getting Started Guide</a> you have created two series: <code class="highlighter-rouge">cpu_idle</code> and <code class="highlighter-rouge">customer_events</code>. Let’s use the former one for this graph. If you’ve set it up correctly you should now see your first Grafana chart!
<img src="/images/posts/measure-all-the-things/first-graph.png" alt="Your first graph" />
<h3 id="final-remarks">Final remarks</h3>
<ul>
<li>In production, we found out that Raft doesn’t like docker changing ids all the time. To circumvent this, overwrite the config to set a steady id using the <code class="highlighter-rouge">hostname</code> variable.</li>
<li>We used Influx 0.8 and Grafana 2.0.2</li>
</ul>
</description>
<pubDate>Sun, 17 May 2015 10:01:24 +0000</pubDate>
<link>https://labs.magnet.me/nerds/2015/05/17/trying-out-influx-grafana.html</link>
<guid isPermaLink="true">https://labs.magnet.me/nerds/2015/05/17/trying-out-influx-grafana.html</guid>
<category>Metrics</category>
<category>Tutorials</category>
<category>Nerds</category>
</item>
<item>
<title>Importing Google contacts with javascript</title>
<description>To enhance the user experience for inviting your friends to take a look Magnet.me, we decided to include a feature to import contacts from your Google account. There are multiple ways to approach this, including a client-side only approach with the use of just javascript. This should be an easy process to set up, however in practice this was not the case as we ran into some problems. This blogpost will describe the problems we experienced and provide solutions to these problems.

<h1 id="problems">Problems</h1>
<h2 id="google-api-explorer">Google API explorer</h2>
Google has APIs for multiple purposes. For example, I could use a Google API to create short urls (like <a href="http://goo.gl/Mp8EjW">http://goo.gl/Mp8EjW)</a>) or communicate with Google Plus. Google has set up an <a href="https://developers.google.com/apis-explorer/#p/">API explorer webpage</a> where every developer can find information about any Google API. Although this is nice, I could not find the API I was looking for. In this case, it seems that information about Google contacts is missing, even though an API for managing contacts does exist.
<h2 id="google-apps-documentation">Google Apps documentation</h2>
After some more searching I stumbled upon <a href="https://developers.google.com/google-apps/contacts/v3/">this documentation page</a> about the contacts API. This page has detailed information about how to use this API which is great. However, any information on how to use this API with just javascript is lacking. After more looking around I found a <a href="https://developers.google.com/google-apps/contacts/v1/developers_guide_js">page which does describe on how to do this with javascript</a> but this version is deprecated.
<h2 id="google-javascript-api-library">Google javascript API library</h2>
Google has a nice <a href="https://developers.google.com/api-client-library/javascript/">javascript library</a> for using many Google APIs. The basic flow on using this library is as follows:
<ol>
<li>Load the library</li>
<li>Set the API key</li>
<li>Set the scopes</li>
<li>Set the client ID</li>
<li>Call an authentication method to get an access token</li>
<li>Load an API with an http request</li>
<li>Call the API</li>
</ol>
In the first 4 steps I did not run into any issues. However, when trying to load the contacts API, the server responded that it did not exist.
<figure class="highlight"><pre><code class="language-javascript" data-lang="javascript">gapi.client.load('contacts', 'v3');
/*
which results in the following error:
GET https://content.googleapis.com/discovery/v1/apis/contacts/v3/rest?fields=rootUrl%2CservicePath%2Cresources%2Cparameters%2Cmethods&amp;pp=0 404 (Not Found)
*/</code></pre></figure>
Loading any other API that was listed in the API explorer was no problem though as loading the urlshortener did not result in an error.
<figure class="highlight"><pre><code class="language-javascript" data-lang="javascript">gapi.client.load('urlshortener', 'v1')</code></pre></figure>
This made me think that the javascript library for the contacts just did not exist. After more searching I found out that it indeed does not exist in this Stack Overflow issue <a href="http://stackoverflow.com/questions/20017487/getting-google-contacts-with-javascript">http://stackoverflow.com/questions/20017487/getting-google-contacts-with-javascript</a>.
<h1 id="solution">Solution</h1>
<h2 id="approach">Approach</h2>
The approach to our solution, which is also described in the Stack Overflow issue, turns out to be pretty simple. When you have an access token, it is possible to call any API with a simple http request, eliminating the need of a specific JavaScript library that wraps this process. The process of retrieving an access token remains the same:
1. Load the library 
2. Set the API key 
3. Set the scopes 
4. Set the client ID 
5. Call an authentication method to get an access token 
Now, instead of using the <code class="highlighter-rouge">gapi</code> library, use this access token to call the API.
6. Call the API using an http request with the access token retrieved
For example, to retrieve the contacts of our user (I used the <code class="highlighter-rouge">get</code> method from jQuery):
<figure class="highlight"><pre><code class="language-javascript" data-lang="javascript"> $.get("https://www.google.com/m8/feeds/contacts/default/thin?alt=json&amp;access_token=" + authResult.access_token + "&amp;max-results=700&amp;v=3.0")
</code></pre></figure>
7. Process the results to serve the information you need.
I do recommend to use the library whenever possible as this will reduce the amount of boilerplate code you have to write.
<h2 id="code-example">Code example</h2>
As a result, this code snippet will provide you with the contacts of a user. To serve this file, I used a simple python command to start an http server in the correct directory with:
<code class="highlighter-rouge">
python -m SimpleHTTPServer
</code>
<script src="https://gist.github.com/wouter-willems/574a70cf4bc2aee1b2f7.js"></script>
When running this example, check the console’s log to see the result.
For <a href="https://magnet.me">Magnet.me</a> we changed this to an implementation with AngularJS but the approach remains the same.
</description>
<pubDate>Mon, 11 May 2015 18:26:00 +0000</pubDate>
<link>https://labs.magnet.me/nerds/2015/05/11/importing-google-contacts-with-javascript.html</link>
<guid isPermaLink="true">https://labs.magnet.me/nerds/2015/05/11/importing-google-contacts-with-javascript.html</guid>
<category>Tutorials</category>
<category>Nerds</category>
</item>
</channel>
</rss>

If you would like to create a banner that links to this page (i.e. this validation result), do the following:

Download the "valid RSS" banner.
Upload the image to your own server. (This step is important. Please do not link directly to the image on this server.)
Add this HTML to your page (change the image src attribute if necessary):

<a href="http://www.feedvalidator.org/check.cgi?url=https%3A//labs.magnet.me/feed.xml"><img src="valid-rss-rogers.png" alt="[Valid RSS]" title="Validate my RSS feed" /></a>

If you would like to create a text link instead, here is the URL you can use:

http://www.feedvalidator.org/check.cgi?url=https%3A//labs.magnet.me/feed.xml

Home · About · News · Docs · Terms