Sanat's Blog

Perf

2015-11-30T09:06:00.000+05:30

Perf isn’t just about how fast your framework runs.

Perf is also about:

how fast you can set up a dev environment for it
how fast you can train people to use it
how fast they become productive in it
how fast it can be deployed
how fast someone new looking at it 3 years later can begin to maintain it

Friction

2015-03-05T09:15:00.000+05:30

Every app needs one primary metric - Friction. This is a function of how easy it is for users of the app to do what they came to do and how long it takes them to do it. Every other metric flows from that, even revenue earned - because if your users encounter too much friction, you're not gonna get any revenue.

FizzBuzz

2015-01-01T16:27:00.000+05:30

This is a simple implementation of the FizzBuzz Test in Go.

Creating a "Master Page" for your Go Web App

2013-11-11T12:20:00.000+05:30

Most web apps share a common layout across different views. This common layout may include a header or a footer and even a navigation menu. Go's batteries-included standard library provides an easy way to create these common elements that can be reused in different views to create a "Master Page"-like effect.

This basic example demonstrates how:

Let's create a simple web app that has 2 views - a Main view and an About view. Both these views have the same header and footer sections.

The header template is defined in a file named header.html

The footer template is defined in a file named footer.html

The Main template is defined in a file named main.html

The About template is defined in a file name about.html

And here's the code that serves it up.

Each of the above templates has a name defined using the {{define "name"}} action. The Main and About templates include the header and footer templates using the {{template "name" .}} action. The '.' passes in the context to the named template. Now whenever the Main and About templates are executed, the header and footer will get included and inserted at the required location. That's all there is to it.

This is how the 2 views look.

This technique can also be used to create different layouts for different sections of the web app; for example, the administration section may look different from the user section. We just need to name our templates appropriately and include them where required.

On Google's social layer.

2013-11-09T09:36:00.002+05:30

Every once in a while, there is a major outrage over Google trying to "shove Google+ down our throats" as one more of its properties is integrated with Google+. There are accusations of Google wanting to inflate its active user count by "forcing" more people into Google+.

Google+ is one of the most misunderstood pieces of the Google puzzle. It is popularly considered as Google's wannabe answer to Facebook/Twitter and as yet another attempt at "getting" social.

Yet Google+ is more than just a mere social network. Google+ is literally Google + You (and your juicy details).

Google's goal is to become your perfect personal assistant - the ultimate handheld/wearable Star Trek computer. To do this, it has to understand your behavior/preferences. Google+ is a fabric that is being built around Google's other properties to do just that.

It is also important to understand this in the context of Google's business model. Google provides a number of services (mostly for free) in return for showing you advertisements (yes, there's no real free lunch). So, while attempting to become your Star Trek computer, it also has to stay relevant to advertisers - the people who spend money to keep it going.

Advertisers want to make sure that the money they spend, results in ads being shown where there is the greatest chance of success. People who see the ads (users like you and me) don't like ads, but would rather see relevant ads than irrelevant ones.

Understanding you, your behavior, preferences and social interactions helps Google achieve both objectives - becoming your Star Trek computer as well as becoming the ultimate advertising platform.

Judging from the outrage, a lot of people don't like this setup. The good thing about this, is that you don't have to use Google or any of its properties. There are alternatives. Be prepared to discover though, that these alternatives are not all that different, or if they are, are unviable from a long term perspective.

Windows Service with Go - the easy way

2013-07-26T08:51:00.000+05:30

This is a quick and dirty way to create a Windows Service using Go.

First, you create a normal Go program with a main() function. This calls another method where the actual work gets done. This function runs in an infinite loop (if you're writing a Go web server, you don't need this loop as the http listener will take care of this).

package main

func main() {
 //Call this function where the action happpens
 doStuff()
}

func doStuff() {
 for {
  //the actual stuff happens here.
 }
}

Once you build this to an exe file, register it as a service using the wonderful NSSM (the Non-Sucking Service Manager). In our case, that would be -

nssm install MyService d:\MyService.exe

(where d:\MyService.exe is the full path to the exe file).

This will register the exe as a Windows Service named MyService. You can change the settings of this service by typing Services.msc and choosing MyService from the services list.

You can delete this service using either NSSM or the native service control sc.exe

sc delete MyService

This method is pure Go and does not use any native Windows APIs directly. The advantage of this is that the same Go program can be run on another OS, if required.

If you want to write something Windows-specific and take advantage of native APIs, like writing to the Windows Event Log, you can use this package from +Alex Brainman.

Printing from your Android device.

2013-06-13T08:30:00.004+05:30

Though things are going largely paperless, there are those times when you need to have a dead-tree edition of that important document. As we go increasingly mobile, a 'Print' feature on your device becomes necessary. That is where Google Cloud Print comes to the rescue.

Google Cloud Print is a service that lets you print a document using any Cloud Print-enabled printer over the web. If you have a normal (classic) printer, you can use that too. You just need to connect your PC to the printer and enable Google Cloud Print using the Chrome browser on it. To do this, go to your Chrome Settings page, click on Show Advanced Settings and then on the Add Printers button under the Google Cloud Print heading.

This will display a list of printers your PC has access to and you can select one or more of them.

Next, you need to install the Google Cloud Print app on your Android device. Once you do this, you can print from your device using the Share option. For example, to print a webpage from Chrome, select Share and then Cloud Print.

This will display a list of printers you can print to. You can also save the webpage to your Google Drive.

Handling Multiple File Uploads in a Go Web Application

2013-03-10T11:51:00.000+05:30

It took me some time to get this right as I couldn't find an easy-to-follow example on the web. Since this is a common use case, this post may hopefully help someone.

This example has a single template for the main webpage that has the file upload form. The backend handler serves this template on a GET request and handles the upload on a POST request. If you're not familiar with Go's html templates, I would recommend reading this well written document first.

The uploadHandler method is where the action happens. This handler responds to a GET request by displaying the upload form. This form POSTs to the same URL - the handler responds by parsing the posted form, saving the uploaded files and displaying a success message.

You can find the complete project at - https://github.com/sanatgersappa/Go-MultipleFileUpload

Update: As pointed out by Luit in the comments, an alternate way of doing this is to use a mime/multipart.Reader exposed by r.MultipartReader() instead of r.MultiparseForm(). This approach has the advantage that it doesn't write to a temporary location on the disk, but processes bytes as they come in.

Serving Go using FastCGI on Windows Azure

2012-11-13T10:28:00.000+05:30

One of the cooler features of Windows Azure is that you can spin up Linux virtual machines on it and run apps written in the language of your choice.

These are the steps I followed to create a Linux VM on Windows Azure, install nginx and Go on it and serve up a "Hello World" app using FastCGI.

First, I signed up a 3-month trial account on Windows Azure - you will need a Microsoft Account for this.

Next, I created a new Virtual Machine using New -> Compute -> Virtual Machine -> From Gallery.

I selected Ubuntu Server 12.04.1 -

I gave the new VM a name - GoMachine, selected a username and password and hit Next -

I selected VM type as Standalone and the DNS name as gopher.cloudapp.net -

Choose Availability Set as None -

Once the VM was provisioned, I SSH'd into it using PuTTy using the credentials I had set earlier -

I installed Go using the command - sudo apt-get install golang-go.

I installed nginx using the command - sudo apt-get install nginx.

Next, I created a directory called fcgi in which I created a file - fcgi.go -

and compiled it using go build fcgi.go.

I edited the file /etc/nginx/sites-available/default to allow it to serve FastCGI and pointed it to 127.0.0.1:9999 where the fcgi app will listen. The server will also take requests directed to http://gopher.cloudapp.net.

I started the fcgi application using ~/fcgi/fcgi& to run it in the background. I also restarted nginx using sudo service nginx restart for the new configuration to take effect.

To test the app, I typed curl http://localhost/hello. It worked. However, curl http://gopher.cloudapp.net/hello didn't. To make this work, I had to create a new 'endpoint' for the VM in the dashboard -

I clicked on Add Endpoint, and created a new TCP endpoint on Port 80 -

Now, the web app is accessible from the outside world.

Update: - My 3 month trial has expired. So the above URL is not accessible any longer.

Querying Sharepoint on Office365 with Go

2012-11-07T15:41:00.000+05:30

This code snippet shows how to query Sharepoint hosted on Microsoft's Office365 service. This was inspired by Luc Stakenborg's excellent Node-Sharepoint library.

Update: This no longer works. Office365 has now been upgraded to use Sharepoint 2013, which supports OAuth-based authentication. More details here - http://msdn.microsoft.com/en-us/library/fp142384.aspx

Knockout.js – Creating a table with a cell conditionally spanning multiple rows.

2012-11-01T10:41:00.001+05:30

Creating HTML tables with conditional elements is a common scenario when creating user interfaces. This fiddle demonstrates how to create a table with a cell that conditionally spans multiple rows using Knockout.js.

App Updates - IE9 vs Chrome

2011-02-12T22:51:00.000+05:30

Installed IE9 RC on my Win 7 Laptop. I had to uninstall IE9 Beta first, restart Windows, then run the IE9 RC installer and restart Windows again. When I compare this to how easily Chrome updates, I know why it is winning.

Hg Init: a Mercurial tutorial by Joel Spolsky

2011-01-15T21:09:00.000+05:30

"Mercurial is a modern, open source, distributed version control system, and a compelling upgrade from older systems like Subversion. In this user-friendly, six-part tutorial, Joel Spolsky teaches you the key concepts."

Git Immersion

2011-01-15T21:01:00.000+05:30

"Git is a powerful, sophisticated system for distributed version control. Gaining an understanding of its features opens to developers a new and liberating approach to source code management. The surest path to mastering Git is to immerse oneself in its utilities and operations, to experience it first-hand.

Git Immersion is a guided tour that walks through the fundamentals of Git, inspired by the premise that to know a thing is to do it."

The Quentin Tarantino Guide to Creating Killer Content

2010-12-13T18:22:00.000+05:30

"If you want to be a great writer, you’ve got to own the story. Fiction or sales copy, know your story like nobody else and you will write words that no one else can touch."

The Quentin Tarantino Guide to Creating Killer Content

Google Chrome blocks persistent javascript alerts

2010-11-12T22:04:00.001+05:30

Have you encountered a badly crafted/malicious webpage that shows javascript alerts and you just can't make them go away? Well, Google Chrome detects if a webpage is throwing up too many alerts and gives you an option to block them. Neat feature.

Trade what you see, not what you think

2010-11-03T21:54:00.001+05:30

Nice video

2010-10-22T08:02:00.000+05:30

Value this time in your life kids, because this is the time in your life when you still have your choices, and it goes by so quickly.

When you're a teenager you think you can do anything, and you do. Your twenties are a blur. Your thirties, you raise your family, you make a little money and you think to yourself, "What happened to my twenties?" Your forties, you grow a little pot belly you grow another chin. The music starts to get too loud and one of your old girlfriends from high school becomes a grandmother. Your fifties you have a minor surgery. You'll call it a procedure, but it's a surgery. Your sixties you have a major surgery, the music is still loud but it doesn't matter because you can't hear it anyway. Seventies, you and the wife retire to Fort Lauderdale, you start eating dinner at two, lunch around ten, breakfast the night before. And you spend most of your time wandering around malls looking for the ultimate in soft yogurt and muttering "how come the kids don't call?" By your eighties, you've had a major stroke, and you end up babbling to some Jamaican nurse who your wife can't stand but who you call mama.

Any questions?

- Mitch Robbins (City Slickers)