Fix typos.

Author: dmitshur

_posts/blog/2015-09-27-surprises-in-gopherjs-performance.mdown

@@ -1,11 +1,11 @@
 ---
 layout: post
-title:  "Surprises in GohperJS Performance"
+title:  "Surprises in GopherJS Performance"
 date:   2015-09-27
 author: Dmitri Shuralyov
 ---
 
-The GohperJS project first caught my attention about 2 year ago, back when few parts of the Go spec were implemented.
+The GopherJS project first caught my attention about 2 year ago, back when few parts of the Go spec were implemented.
 However, I noticed the incredible pace at which Richard was working, making multiple sophisticated commits per day, as well as fixing reported compiler issues within hours.
 A few months later, I decided to download it and give it try on a relatively [large pure Go package](https://godoc.org/github.com/shurcooL/markdownfmt/markdown?import-graph&hide=1) for formatting Markdown, and I was quite shocked when it... [simply worked](https://github.com/shurcooL/atom-markdown-format/commit/6b5f21c4457309f8eba3a78b82e0c9a458ff13b4).
 
@@ -65,7 +65,7 @@ total time taken is: 8.358498915s
 Then I got curious how long it would take if compiled to JavaScript via GopherJS.
 
 I realized that this is a very tight loop, so any overhead incurred by the conversion of Go to JavaScript would be multiplied and be very visible.
-Still, I was curious, so fired up GohperJS and ran the same program by compiling it to JavaScript and running it with node:
+Still, I was curious, so fired up GopherJS and ran the same program by compiling it to JavaScript and running it with node:
 
 ```bash
 $ gopherjs run main.go
@@ -91,14 +91,16 @@ And got the same time in Chrome browser (stable channel).
 
 The calculated value of pi was the same, and after adding some debugging statements I was sure the calculation was indeed correct, and iterations were not being skipped.
 
-But how could it be that taking this Go program and compiling it to JavaScript and executing that would be 4 times faster? I had to get to the bottom of it.
+But how could it be that taking this Go program and compiling it to JavaScript and executing that would be 4 times faster?
+I had to get to the bottom of it.
 
-The first thing I needed to ensure, was the same code being run in both cases? The entire code is plain Go, with the exception of `math.Pow`.
+The first thing I needed to ensure, was the same code being run in both cases?
+The entire code is plain Go, with the exception of `math.Pow`.
 So I looked at how [Go implements it](http://gotools.org/math#Pow).
 Pretty straightforward Go code.
 Now I knew GopherJS uses some JavaScript native APIs to implement parts of the standard library, so I checked how [it implemented `math.Pow`](https://github.com/gopherjs/gopherjs/blob/master/compiler/natives/math/math.go#L157).
 Aha! It's not the same code after all.
-GohperJS implements it by using [JavaScript's `Math` object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math), so it translates to:
+GopherJS implements it by using [JavaScript's `Math` object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math), so it translates to:
 
 ```JavaScript
 Math.pow(x, y)
@@ -233,7 +235,8 @@ user    0m11.377s
 sys     0m0.006s
 ```
 
-11.3 seconds? Slower? Ah, of course, I was too used to `go` build tool that uses optimization by default, and forgot that C compilers don't do that.
+11.3 seconds? Slower?
+Ah, of course, I was too used to `go` build tool that uses optimization by default, and forgot that C compilers don't do that.
 
 ```bash
 $ gcc -O3 main.c