developer toolbox

http://github.com/peterbourgon/go-cookbook/blob/master/reduce.go

http://go-lang.cat-v.org/library-bindings

http://github.com/mattn/go-gtk

http://github.com/oibore/go-pg/blob/master/src/runner.go

http://code.google.com/p/nefarious-ide/

http://go-lang.cat-v.org/text-editors/vim/

http://github.com/vito/go-play/tree/master/gopaste/

http://www.manatlan.com/page/gg

http://github.com/hoisie/gocouch

http://github.com/mikejs/gomongo

http://github.com/vito/go-parse

http://code.google.com/p/optparse-go/source/browse/

http://github.com/orfjackal/gospec

http://github.com/orfjackal/gospec/blob/gospec-1.0.0/examples/assert_examples_test.go

http://github.com/jldailey/fcgigo

http://github.com/purex01/netsnail

http://github.com/moriyoshi/pulsego/

http://github.com/hoisie/gocouch/blob/master/gocouch_test.go

gtk twitter go:

http://github.com/mattn/go-gtk/blob/master/example/twitter/twitter.go

xgb Port of XCB to generate Go bindings for X11 Window System by Tor Andersson. (Not technically a 'binding' as it generates Go code that speaks the X protocol.) Now part of the main Go distribution!

http://golang.org/doc/go_for_cpp_programmers.html#Interfaces

Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.

And perhaps most radically, there is no type hierarchy: types just are, they don't have to announce their relationships.

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.

Why is there no type inheritance?¶

Object-oriented programming, at least in the best-known languages, involves too much discussion of the relationships between types, relationships that often could be derived automatically. Go takes a different approach.

Rather than requiring the programmer to declare ahead of time that two types are related, in Go a type automatically satisfies any interface that specifies a subset of its methods. Besides reducing the bookkeeping, this approach has real advantages. Types can satisfy many interfaces at once, without the complexities of traditional multiple inheritance. Interfaces can be very lightweight—having one or even zero methods in an interface can express useful concepts. Interfaces can be added after the fact if a new idea comes along or for testing—without annotating the original types.

Because there are no explicit relationships between types and interfaces, there is no type hierarchy to manage or discuss.

It's possible to use these ideas to construct something analogous to type-safe Unix pipes. For instance, see how fmt.Fprintf enables formatted printing to any output, not just a file, or how the bufio package can be completely separate from file I/O, or how the crypto packages stitch together block and stream ciphers. All these ideas stem from a single interface (io.Writer) representing a single method (Write). And that's only scratching the surface.

It takes some getting used to but this implicit style of type dependency is one of the most exciting things about Go.

http://github.com/hoisie/web.go

announcing webgo#

http://github.com/hoisie/mustache.go

http://github.com/defunkt/mustache

http://defunkt.github.com/mustache/

Mustache

Inspired by ctemplate and et, Mustache is a framework-agnostic way to render logic-free views.

As ctemplates says, "It emphasizes separating logic from presentation: it is impossible to embed application logic in this template language."
Overview

Think of Mustache as a replacement for your views. Instead of views consisting of ERB or HAML with random helpers and arbitrary logic, your views are broken into two parts: a Ruby class and an HTML template.

We call the Ruby class the "view" and the HTML template the "template."

All your logic, decisions, and code is contained in your view. All your markup is contained in your template. The template does nothing but reference methods in your view.

This strict separation makes it easier to write clean templates, easier to test your views, and more fun to work on your app's front end.
Why?

I like writing Ruby. I like writing HTML. I like writing JavaScript.

I don't like writing ERB, Haml, Liquid, Django Templates, putting Ruby in my HTML, or putting JavaScript in my HTML.

Usage

Quick example:

>> require 'mustache'
=> true
>> Mustache.render("Hello {{planet}}", :planet => "World!")
=> "Hello World!" 

We've got an examples folder but here's the canonical one:

class Simple < Mustache
  def name
    "Chris" 
  end

  def value
    10_000
  end

  def taxed_value
    value - (value * 0.4)
  end

  def in_ca
    true
  end
end

We simply create a normal Ruby class and define methods. Some methods reference others, some return values, some return only booleans.

Now let's write the template:

Hello {{name}}
You have just won ${{value}}!
{{#in_ca}}
Well, ${{taxed_value}}, after taxes.
{{/in_ca}}

This template references our view methods. To bring it all together, here's the code to render actual HTML;

Simple.render

Which returns the following:

Hello Chris
You have just won $10000!
Well, $6000.0, after taxes.

Simple.

gui for go

Embedded how low can it Go

xgb example

http://freecella.blogspot.com/2010/01/gospecify-basic-setup-of-projects.html

http://scienceblogs.com/goodmath/2009/11/googles_new_language_go.php

http://stackoverflow.com/questions/1924081/which-language-would-you-use-to-write-a-erp-type-of-application

http://loadcode.blogspot.com/2009/12/design-patterns-in-go-programming.html

Google hopes to remake programming with Go

http://stackoverflow.com/questions/1731495/what-kind-of-solutions-is-golang-google-go-designed-for

http://www.downloadsquad.com/2009/11/12/new-go-integrates-with-chrome-and-chrome-os-native-high-speed/

Google's Native Client software is special in that it runs at much higher speeds than your usual Firefox or Chrome add-ons. It runs much more like another application on your computer, rather than 'a web app' in the browser. It has security built-in that won't allow developers to program dangerous applications.

But it's not actually new. It's been around for months. What is new is that Go, Google's new language, will integrate fully with Native Client!

This means two very important things: a) web apps will be propelled to a new level of speed and complexity when coded in Go with Native Client and b) you are now looking at how applications in Chrome OS will be developed and run.

When you run programs in Chrome OS they will simply be Native Client web applications. There won't be a difference between Photoshop or Gmail, World of Warcraft or FarmVille -- they'll all be tabs in Chrome.

Everything will be a tab in Chrome.

http://code.google.com/p/nativeclient/

Native Client is an open-source technology for running native code in web applications, with the goal of maintaining the browser neutrality, OS portability, and safety that people expect from web apps. We've released this project at an early stage to get feedback from the open-source community. We believe that Native Client technology will help web developers to create richer and more dynamic browser-based applications.

Native Client runs on 32-bit x86 systems that use Windows, Vista, Mac OS X, or Linux. Some ARM and x86-64 support is implemented in the source base, and we hope to make it available for application developers later this year.

http://github.com/phf/go-db

http://github.com/phf/go-sqlite3/blob/master/core_test.go

RFC: Database API for Go

http://github.com/mikejs/gomongo

http://github.com/thoj/Go-MySQL-Client-Library

Analysis of Git and Mercurial

http://arstechnica.com/open-source/news/2009/11/go-new-open-source-programming-language-from-google.ars

http://en.wikipedia.org/wiki/Go_%28programming_language%29

Google hopes to remake programming with Go

http://kzk9.net/b/2009/11/tokyocabinet_wrapper_fo_golang/

http://www.sitepoint.com/blogs/2009/11/19/google-chrome-go-plugin/

http://loadcode.blogspot.com/2009/11/first-impressions-from-go-programming.html

http://loadcode.blogspot.com/2009/12/go-vs-java.html

What application can you really code in Go?

http://loadcode.blogspot.com/2009/12/design-patterns-in-go-programming.html
http://loadcode.blogspot.com/2010/01/interpreter-pattern-in-go-using.html

Composite pattern

go on mingw/win2k

proposed changes to http server

http://slides.games-with-brains.net/

http://www.slideshare.net/feyeleanor/the-ruby-guide-to-nix-plumbing-on-the-quest-for-efficiency-with-ruby-mkri

http://raycompstuff.blogspot.com/2009/12/simpler-chat-server-and-client-in.html

http://raycompstuff.blogspot.com/2009/11/strings-package-in-golang.html

http://raycompstuff.blogspot.com/2009/11/input-from-stdion-in-go.html

http://raycompstuff.blogspot.com/2009/11/defer-in-go.html

http://code.google.com/p/goplot/

GoPlot is a learning vehicle for experimenting in the Go programming language. The direction of the code is toward a graphing utility with some curve-fitting features. So far it's capable of doing a simple linear regression on the source data.

As of version 0.3.0, GoPlot runs as a web server. The one page it serves presents a graph and a textarea for entering data as x,y pairs, one per line.

Input is simple value pairs (2D points) and results are provided as JSON. The JSON is interpreted on the client side and plotted in SVG using jsxGraph.

http://www.metasploit.com/users/opcode/syscalls.html

http://www.infoq.com/articles/google-go-primer