f2f

the original paper describing "faces" is here:

http://doc.cat-v.org/bell_labs/face_the_nation/

The internet. Really.

It's like asking "Horse vs Car: who will win?". People in 1900 may have said "horse, of course", but we know the real answer, given time.

Oh, and by the way, 18-24 demographic is watching less and less tv...

It comes from a very ancient democracy, you see..."

"You mean, it comes from a world of lizards?"

"No," said Ford, who by this time was a little more rational and coherent than he had been, having finally had the coffee forced down him, "nothing so simple. Nothing anything like so straightforward. On its world, the people are people. The leaders are lizards. The people hate the lizards and the lizards rule the people."

"Odd," said Arthur, "I thought you said it was a democracy."

"I did," said Ford. "It is."

"So," said Arthur, hoping he wasn't sounding ridiculously obtuse, "why don't people get rid of the lizards?"

"It honestly doesn't occur to them," said Ford. "They've all got the vote, so they all pretty much assume that the government they've voted in more or less approximates to the government they want."

"You mean they actually vote for the lizards?"

"Oh yes," said Ford with a shrug, "of course."

"But," said Arthur, going for the big one again, "why?"

"Because if they didn't vote for a lizard," said Ford, "the wrong lizard might get in. Got any gin?"

the article from which this one steals almost everything to repackage into a menial cheeseburger sans cheese is much more interesting:

http://www.vanityfair.com/news/2006/07/hitchens200607

You'll never find a decent authentication library for any language that I can trust.

splitters!

for a dead operating system Plan 9 certainly seems to be kicking, however faintly :)

yes, that too :)

back when the plan9 compilers were introduced to the world [0] POSIX 1003 was less than 3 years old. that they didn't change much in their design since is a testament to a) how good they were and 2) how good their authors were.

--

0: ftp://nic.funet.fi/pub/OS/plan9/doc/plan-9-docs/dist.ps.Z

point taken. i would love to see the videos of those talks.

if you want to invoke the America vs Europe rift you'll probably be interested in an earlier talk from the same conference given by Robert Griesemer on the evolution of Go:

https://sourcegraph.com/blog/live/gophercon2015/123645585015

in short, Go's design is not from a unique line of programming languages, it just goes back further than you think. the argument made in the talk is that Go combines the European heritage of Algol (Pascal/Oberon) with the American one (C).

no.

edit: depends on the company

both the original article and the Reddit discussion come up in my results (as 1 and 2). the reddit discussion is only 16 hours old.

https://www.google.com/search?q=golang%201%20million&rct=j

this HN discussion is too recent to show up in my results, however yesterday's thread about Qihoo and golang does show up as number 4 or 5 when searching for "golang qihoo".

no need to panic.

I'm sorry but the official name is Go. You can search for "Golang" or "Go Language" with no issue.

this article discusses how they handled 69GB of heap and up to 6 seconds of pause times:

http://blog.golang.org/qihoo

the new garbage collector in 1.5 should improve things.

this paper still reads revolutionary now, but imagine how it felt to read it in 1993 and compare it with your average "system" either at home or at work.

windows for workgroups was released the same year, while we were struggling to set up IPX networks to play doom between two machines at home...

> Many of the ideas in go were not well understood and had only been demonstrated in research languages prior to go. Its concurrency model and associated primitives, and the automatic interface system were in roughly the same state then as Rust's new ideas are now.

to Go's authors the CSP model was very well understood through three different implementations: Alef, Limbo, and Plan 9's libthread.

example session:

  (llgo) 1+1
  #0 untyped int = 2
  (llgo) x := 1
  x untyped int = 1
  (llgo) x++
  (llgo) x
  #0 int = 2
  (llgo) import "fmt"
  (llgo) fmt.Println("hello world")
  hello world
  #0 int = 12
  #1 error (<nil>) = <nil>
  (llgo) for i := 0; i != 3; i++ {
         fmt.Println(i)
         }
  0
  1
  2
  (llgo) func foo() {
         fmt.Println("hello decl")
         }
  (llgo) foo()
  hello decl
  (llgo) import "golang.org/x/tools/go/types"
  # golang.org/x/tools/go/ast/astutil
  # golang.org/x/tools/go/exact
  # golang.org/x/tools/go/types
  (llgo) types.Eval("1+1", nil, nil)
  #0 golang.org/x/tools/go/types.TypeAndValue = {mode:4 Type:untyped int Value:2}
  #1 error (<nil>) = <nil>

similarly, mdb on solaris is very powerful.

a few more lines if you just let os.Stdout be the default: http://play.golang.org/p/FDbpCxCskT

kernighan also wrote the tutorial on the Limbo programming language:

http://doc.cat-v.org/inferno/4th_edition/limbo_language/desc...

he's obviously good at it, and the perspective of someone not involved with the creation of the language is a bonus.

I was alluding to Ken being the author of the old, as well as one of the authors of the new compiler. In jest :)

You can't avoid trusting trust. "Ken was here" :)

what this fine list sorely misses is a true retelling of the "Plan 9 and the echo" story, as found here, on the Plan 9 mailing lists some millenia ago:

The Plan 9 and the Echo:

http://9fans.net/archive/2001/09/54

(for the history buffs: yes, that is dennis ritchie posting in that thread)

the problem with goamz, when i forked it, was that merging changes into canonical's bazaar cvs was very hard to do. that was before github and pull requests became de-rigeur, so i'm a bit dated. still, very few of canonical's go projects are bzr-based anymore.

that's the reason you're seeing all those forks: we all added what we needed, couldn't get it in, and gave up.

<snark> had to be hundreds of thousands because you didn't come out of the gates with a decent design and you had to wing it for the last 6 years </snark>

;)

TIL that the hardest thing to do in computer science is to learn something new and different.

don't be discouraged, it's par for the course.

we're talking about quality lines of code: debugged, qa'd, and working as expected. perhaps even after the customer has had a chance to peruse the beta. you will be surprised how much time you'll spend in meetings and how hard navigating and contributing to large projects becomes.

curiously, the number of lines of quality code expected by a developer has not changed much since "the mythical man month" was written, which was about IBM machines in the 60s, despite the obvious advances in programming languages and programming environments. it's still around 10 or so.

oops, sorry, downvote brigade. :)

what language progress? this is Go we're talking about :)

(before the downvotes start raining, my joke is referring to the Go compatibility promise, not the lack of whizbang blinkenlights)