My name is Ken and I’m a geek. Like most geeks I like to stay up to date with the latest technologies, and normally try to find some excuse to play with them. As a dotCloud engineer I take advantage of our once a month hackdays to do just this.

One of the technologies I have been hearing a lot about lately is a new programming language called Go.

On the Go website it says “Go is an open source programming environment that makes it easy to build simple, reliable, and efficient software.” At first pass that sounds like a lot of programming languages, so what makes it better than the rest, and why is this so special?

To answer those questions, I’m going to steal some sections from the Go FAQ.

Go is a concurrent, garbage-collected language with fast compilation. It was started at Google and was released to the public on November 10, 2009.

Features of Go

  • It is possible to compile a large Go program in a few seconds on a single computer.
  • Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.
  • Go’s type system has no hierarchy, so no time is spent defining the relationships between types. Also, although Go has static types the language attempts to make types feel lighter weight than in typical OO languages.
  • Go is fully garbage-collected and provides fundamental support for concurrent execution and communication.
  • By its design, Go proposes an approach for the construction of system software on multicore machines.

Typical Go App

If you have never seen a Go program before, here is the typical Hello World application written in Go.

https://gist.github.com/4658856

Looking at the code it is pretty straightforward. If it wasn’t for the curly brackets it almost looks like Python.

If you want to learn more about Go, I recommend their excellent tutorial http://tour.golang.org. I also did a quick search on amazon and it looks like there are already a number of Go books. So pick one up today, and start learning.

Learning Go on dotCloud

We are starting to use Go on a few internal projects at dotCloud. I like what I see so far, but before I get too ahead of myself, I still have a lot to learn. I personally find the best way to learn is to have a small, real world, non-critical project that you can use as your guinea pig.

Reading books and going through tutorials is a good place to start, but it’s a lot like high school physics, when you ignore friction, wind resistance and gravity. Once you start doing real world problems which include those variables, things never go smooth the first time.

That is why it is always best to get your hands dirty on a real project as soon as possible. dotCloud’s free sandbox apps are perfect for this.

I’m not sure about you, but a lot of the projects that I work on lately are web-based. I was sad to find out that there were not many options for hosting Go applications. It seems you could run your own server (VPS, etc) or you could deploy to Google App Engine.

One of the many advantages of working for dotCloud is having access to this awesome deployment platform, where I’m like a kid in a candy shop. I can take these different services, write some code and easily deploy them to dotCloud, all without breaking a sweat.

Last Friday we had a hackday at dotCloud, where everyone takes the day off from their normal projects and we can work on anything we want. I took this time, to work on a Go on dotCloud custom service. It is still very early, but it allows you deploy your Go applications to dotCloud as easily as all of our other services.

Try it out on dotCloud

I have put the code up on github so that everyone can use it, and submit pull requests. It is still very early beta, but I welcome everyone to try it out, and please let me know what you think, good or bad. If you have a suggestion on how to make it better, feel free to submit pull requests and issues.

Using it is pretty straightforward. Assuming you already have a FREE dotCloud account, you just need to follow these steps.

  • Create a new application

$ dotcloud create -f sandbox mygoapp

  • Fork my github repo, and then clone it.

$  git clone git://github.com/kencochrane/golang-on-dotcloud.git

  • Add your code in the src directory.
  • Edit the dotcloud.yml
    • Change the build_package config variable, to the name of your GO package
    • Change the processes so that you can run the correct processes
    • Add or remove ports depending on your application needs.
  • Push the application

$ dotcloud push mygoapp .

Enjoy!

That should be about it. Best of all you can do all of this for FREE since dotCloud doesn’t charge for services in the Sandbox. So deploy as many times as you like, and let me know if you have any questions or problems.

Coming from a Python background, I am most interested in the fact that Go is a fast compiled language with concurrency built-in. I don’t think it will replace Python as my go-to language, but when I need something small and fast with concurrency, it is nice to know there is another option at my disposal.

I’m looking for new ideas for my next hackday, if you have any suggestions, please let me know.

We’re happy to announce the public beta of our all-new, open-source command-line client interface (CLI): a from-the-ground-up rewrite, backed by our soon-to-be-released REST API.

Cape_boy_tonguexsmall

We’ve put a lot of work on the new client into cleanup and polish: either behind-the-scenes reliability fixes, speeding up interactions, or improvements to the utility’s help and other output. Fully real-time application and deployment logs with output coloring are now archived to easily isolate problems, and compare or redeploy old versions. OAuth2-based authentication provides finer-grained security. Detailed info gives you greater visibility into your application’s state and usage history. All useful improvements over the CLI you use today.

There are also a couple important changes to be aware of in how you interact with your dotCloud applications (connecting applications to directories; pushing with rsync by default), and the caveat that the new CLI only works with our new granite builder. Check out the most important changes below, then get all the details in the new documentation.

Get started by installing the beta version from the GitHub repository:

You’ll be asked to enter your computer’s password to finish the installation, then you can configure the client by running dotcloud-beta setup, which will ask for your dotCloud username and password. Finally, to confirm you’re properly set up, run dotcloud-beta check.

Read on for more information about the changes.

Context-Sensitive Connected Applications

One of the most commonly-typed parameters when using the dotCloud command-line utility is the name of the application on which you’re currently working — it’s included in virtually every command you execute, but rarely changes throughout a given work session.

To eliminate this needless repetition, we now allow you to “connect” a given directory to it’s corresponding application. Then, whenever you execute commands from within that directory, the client will default to interacting with that application without you having to specify it manually.

Most version control systems (git, mercurial, svn, etc.) detect which code repository you’re interacting with based on the contents of a hidden folder (.git, .hg, .svn, etc.) in your current directory. The new CLI “connect” feature works the same way: it detects which dotCloud application you’re working on by looking for a hidden folder (named .dotcloud) which gets created when you attach a directory to an application, either using the dotcloud-beta connect command, or when creating a new application with the dotcloud-beta create command.

Rsync by default for pushes

The second major change is that, for a variety of reasons, we’ve decided to no longer have the CLI make assumptions about what transport to use for code — it defaults to using rsync in every case.

If you would like to make use of your version control system to push code to dotCloud, you’ll need to specify it manually by appending either the --git or --hg parameter to your push command. In order to make pushing with a given version control system the default for a specific app, just run dotcloud-beta connect --git YOUR_APPLICATION_NAME

Granite Builder Required

In February we released our new Granite builder to ensure pushing a new code version couldn’t break an existing application and to make zero-downtime deploys possible (read all about the changes here). Since then, most of you have upgraded your applications to take advantage of these new features, but if you haven’t upgraded yet, you’ll need to do so before the new CLI will function correctly. It just takes one command to make the change: dotcloud push YOUR_APPLICATION_NAME --clean (read more about upgrading)

We do recommend, however, that you deploy a fresh test version of your application before running the upgrade on any important apps to ensure your code isn’t inadvertently depending on quirks in the old build system.

We’re excited to give you early access to this new command-line tool and are even more excited to get your feedback — please let us know what you think by contacting support, filing bugs, or, best yet, forking the GitHub repo and submitting patches.

Enjoy!

Sometimes popularity is a good measure of awesomeness (the internet, Journey, bacon — popular and awesome). Sometimes it is not (Jessica Simpson, Chlamydia, Internet Explorer — also popular; decidedly un-awesome).

With over 400 watchers on GitHub, we already knew ZeroRPC was popular, but at our may hackday many of us worked to ensure it falls squarely in the “unbelievably awesome” camp, too: from demos to middleware to external integrations, ZeroRPC featured in almost every project!

Hackday-may-2012

Here’s a sample of what we worked on:

ZeroRPC StatsD - Andrea Luzzardi

Tracking down which component is slowing down a big distributed system can be a huge headache, but fear not! Andrea has created yet another tool to help you mangle that big tangled mess. StatsD is a project by Etsy that makes it super simple to track statistics, like counters and timers. Andrea’s StatsD middleware for ZeroRPC lets you track requests and response times of ZeroRPC Services.

https://github.com/aluzzardi/zerorpc-statsd

ZeroRPC for Node.js – Yusuf Simonson

Python-in-node

You want some Python in your Node.js? No problem! Yusuf finished up the first version of a Node.js-based implementation of ZeroRPC that lets Python and Node.js play together like the best of friends.

https://github.com/dotcloud/zerorpc-node

Sentry on dotCloud – with support for ZeroRPC – Louis Opter

Email is a great tool for many things, but managing application errors is not one of them. When the good folks at Disqus got tired of a clogged inbox they built Sentry: a realtime event logging and aggregation platform. The client collects logs and exceptions which get passed to the server over the network where they are agreggated them by type and sorted by time, frequency, etc in it’s beautiful web interface.

Louis’ hackday project makes it incredibly easy to run a standalone Sentry server on dotCloud.

https://github.com/dotcloud/sentry-on-dotcloud

As an added bonus, Louis also added support for ZeroRPC into Raven, the official Sentry Python client:

https://github.com/dcramer/raven/blob/master/CHANGES#L14

This lets you log exceptions caught by ZeroRPC to Sentry. See the docs for an example:

http://raven.readthedocs.org/en/latest/config/zerorpc.html

Our next hackday will take place in the second half of June. If you have a cool idea, or would like to join in on the fun, tweet us @dot_cloud with your ideas.