MetaCosm

I disagree. I know most Go shops I have dealt with at least have looked into gccgo. We use gccgo in the wild (for all our image processing components), because it gave us a nice performance boost. With good testing, you can easily do A/B testing using gccgo to see where it makes sense for you in production.

We have to dig through 30TB of images -- so the performance benefits we got from gccgo were worth the trivial effort it took to implement.

Go has MULTIPLE compilers, because Go is a language spec, not a compiler. Hence GCCGO (which for example, takes advantage of some of those GCC optimizations) can be used.

Additionally, in most benchmarks, Go does fairly well and is young and constantly improving: http://www.techempower.com/benchmarks/

You will also find Nimrod / Jester in those benchmarks, and can compare the performance for yourself.

cough bullshit cough

I meant it in good humor, but over the last 15 years, I have had the joy (and pain) of getting to ship production systems in a lot of less popular stacks including: Erlang (multiple), Eiffel, Haskell, and OCaml.

Hiring and training for these less popular stacks has been a goddamn nightmare in "win" conditions. You have the benefit of the better signal to noise ratio in resumes, absolutely. But, you pay for that in rarity, salary and job demands, which is fine as long as you go in eyes wide open and plan to have a small team (under 10).

Rapid team growth (from money injection, or simply success and need) is really, really hard when you don't have a large pool of qualified candidates to pull from... and training, I honestly can't fathom trying to train PHP developers in Haskell. If you company has done this successfully, please setup a newsletter, I would subscribe.

Remember, Windows 8 was well underway by the RTM of 7 (July 2009). So, they made a guess that touch screens would be everywhere when they were done. Unlike Apple, until recently, never controlled the hardware they run on.

They spent a lot of the post-DOJ years trying to find a way to bully the hardware vendors without getting kicked in the teeth and never found a way. This is why "signature" failed, this is why touch screens failed, this you could even argue is why early tablets failed (way early, 6+ years ago).

MS seems to have learned this, and started building their own hardware. The Surface 2 Pro is a remarkably nice to use device (and I didn't even reinstall the OS, I am using stock... gasp), it is my primary mobile platform replacing a 2013 Macbook Air. Being able to swap it between a (very heavy, but usable) tablet, and a decent laptop is a nice combo for me... and I doodle and write notes on it in meeting, the pen is wonderful and pressure sensitive.

"Regular"(black car) Uber drivers seem to go through the same thing. Test on the area, background check, have to carry special class insurance, special license. I am unfamiliar with UberX specifics.

"Aliens aren't real, tell eip I said so, in the future, on hacker news. I saw it all via time-shifted ESP gifts, which you get the day you become President, you can see anything but your own death..." -- JFK, former President of the United States

Of course, like Ben Rich's "quotes" it was given only to me, mere days before he died, and never repeated to anyone else, and I never brought it up to another living soul for years... I was waiting for a bad history channel show to reveal it, but I guess this will do.

Yeah, the walled gardens are hellish. Makes it very hard to manage things... sadly, it is getting worse not better.

Which ones? I had the exact opposite reaction to trying to use evil. I liked it, I like lisp, but the plugins where so crufty and sensitive. I got most of what I wanted working, but never got good tags support working, never got good generalized fuzzy finding working (tags, buffers, files), and never got used to the "culture shock" when I dropped out of evil mode in another buffer.

Currently, to talk to everyone I speak to regularly requires: Skype, Hangouts (multiple), IRC, AIM, WhatsApp, HipChat, Viber, Yahoo!, Facebook Chat...

Because I need 4x hangouts (1 per company I work with, contracting, my own business, personal, etc) and many of the other apps either won't work with other clients, or have crippled features or usefulness, I end up running 10 "chat" clients.

grumpy old man voice Back in my day, we used to be able to setup all our text based messaging in one pidgin client, or a bitlbee instance! Damned kids.

I don't doubt your sincerity. Unfortunately, all of us have bugs, and if that bug in one step from write access to repos -- that is unacceptable.

I hope that Github is reactive enough to get permissions setup in a failsafe manner so I can give this a spin.

I agree with the core premise that trade negotiations shouldn't be done in secret, nor fast-tracked. That said, nothing in that comic really "convinced" me, it seems more like a place to fly his personal political beliefs than make a coherent point. Just seemed all over the place.

Around from the very start in one form or another.

Our team recently did something similar. We went from MongoDB to PostgreSQL. We converted most of our well known fields over to proper PostgreSQL fields, and by using UUIDs in PostgreSQL we still had opaque sharable ids. On top of that, for developer flexibility, we included a little json dumping ground column in most of our tables. This allows developers to quickly add in some data they care about without dealing with migrations and database versioning. Then, as needed (and only if needed) we move the data out of json to proper columns, mostly for performance or relational reasons.

Summary of article: "No, because that would be awful for my business".

I suspect Fang Digital has pushed this terrible notion on their clients for years and now look like idiots, so they are doubling down.

FYI: The marketers I work with have near universally dismissed FB as anything but "brand building for when you have more marketing budget than sense"... well before this video (or the 2012 BBC one) put it into the commons.

> Calling Facebook and its advertising “a fraud” because you choose to run a “like campaign” in a part of the world that is known for fraudulent clicks

He ran it in US, CA, AU, UK targeting cat lovers (see: http://youtu.be/oVfHeWTKjag @ 6:00) -- additionally, this is a full on admittance that fraudulent clicks are a huge issue.

> astute among us know that measurements such as “Likes” do not constitute anything

Then maybe facebook shouldn't be selling them as the metric?

Couldn't agree more (and wonderful link). The article was so disconnected from my reality as to be confusing.

(redacted probably irrelevant comment)

EDIT: Part of the reason for this confusion may well be cultural. I am a US developer, and have heard similar "I get no respect" type rants from Canadian developers... often shocked by the pay and respect they can demand just a bit south.

Do you happen to know of a cross-platform fuzzy finder for emacs? Bonus points if it can also fuzzy-find over tags.

My Note II (and now Note III) completely killed my tablet use... or more properly put, replaced it. With the stylus and multitasking, feels more like a small tablet with phone capabilities.

My various tablets are now nearly permanently attached to my computers. I need them for writing / testing software, but that is mostly all they do these days, don't carry them around the house much, never carry them out of the house.

What is "significant penetration" from your perspective? It is very young (as a 1.0, not even 2 years old). What language would you compare it to, and where was that language at 2 years old?

What was Java adoption in 1998? What was Scala adoption in 2006? What was Python adoption in 1996.

Unless the trend lines shift, Go is a IMHO something of a phenomenon. It seems to hit a lot of sweet spots in deployment, tooling and simplicity that is making a lot of groups happy. It is already being used to build tools people depend on (docker [just raised 15M], packer, nsq, juju, heka, coreOS), it is fast (http://www.techempower.com/benchmarks/) ... additionally, it seems to have decent penetration on both ends of the spectrum, large enterprises and tiny start-ups are choosing it (http://code.google.com/p/go-wiki/wiki/GoUsers), DevOps and Software Engineers are living together in rare harmony due to painless deploys and handoffs.

If you want to use GitHub as a barometer of language popularity ... http://adambard.com/blog/top-github-languages-for-2013-so-fa... --- Go is tracking darn close to Scala, despite being 8 years younger.

Compare Go in early 2014 to Scala early 2006, that is when they were about the same age.

It is amazing that MUMPS will be 50 years old in 2 years -- and it still alive and kicking.

An emergency MUMPS project is still my highest billing project (per hour) ever.

They aren't intended as some magical argument ending tool, they are designed as reminders are common flaws in logic. They are more for personal use than use against others, because it is easy to fall into bad logic, even more so when emotions (notoriously immune to logic) are involved. Being aware of them will help you be self-aware.

RE: "No True Scotsman" -- you missed the point a bit. The point is that it is a shell game. "No hackers news reader would EVER do X" ... I link to a hackers news reader doing EXACTLY X ... "Well, no REAL hackers news reader" -- it is a informal fallacy about goal moving basically. You can't add "no REAL abc" to excuse counterpoints, because it means that ANYTHING I say / prove / point out, you will always claim "no TRUE hacker news reader would do that", making the argument pointless.

Re: Appeal to tradition. The point is that tradition has no inherent value, and doesn't relate to correctness. If my mother thought 2+2=17... and she taught that to me, and I taught that to my children, that would be a tradition in our family. The point is that just cause something is traditional doesn't mean it is correct.

It is indeed mind boggling when people list async (read: callback hell) as a feature. Complex systems rapidly get unmanageable, so people build nasty hacks to try to paper over the async core (it is still async single threaded at its core, run a dumb busy loop and watch your app stop responding).

Blocking is a feature. Blocking lets you reason easily, and as Go, Erlang, etc... have proven can be done at breathtaking speed and use all your cores... rather than wrapping your world view around async, use a system that allows you to keep your logic blocking and uses microprocesses to distribute work across a pool of threads. It is freeing to be able to just kick up 300k microprocesses if you need them.

Additionally, the node ecosystem tends to be quantity over quality... many of the available modules are simply more trouble than they are worth... while NPM makes getting them easy, it doesn't make deciding if something is worth using any easier.

> I disagree that people will become comfortable with Google Glass - the primary negative reaction is the voyeuristic-rejection of having a camera always pointed at you (that may or may not be recording).

When personal cameras first came on the scene -- the newspapers tried to inflame hysteria -- ANYONE COULD TAKE PICTURES OF ANYONE! There were pushes for regulation, banning, and people where ATTACKED for using cameras in public. Google for "Kodak Fiends" and "The Camerist and the Squaw" -- these were the old version of "Glassholes".

Society creates social norms to deal with this stuff. See again camera phones... a lesser for of "Kodak Fiends" trended in the press, then we adapted, and now no one even worries about it. It will happens for Google Glass over time, history tells the tale.

Git supports many channels for sharing changes.

It is context aware, which is actually really awesome! It understands if it is in a tag, in a script, in quotes, in double quotes, in source, in css, in style and lots of stuff I am forgetting and does the custom escaping required to make it safe for that context. That is freaking magical.

Lots of things that are good for communities are restricting for individuals. Even more interesting, some of them lose significant value when anything less than a super-majority fall in line with them (This for example is why I think the Go community sometimes is very "passionate" about getting people on the right path, they are threatening the herd immunity of sane code and layout... one person goes off, others see their example and copy it... chaos!). I think the Go team was wise enough to see that the value of having sane baked in standards from day one FAR outweighed the complaints they knew would follow.

I think many people put too little value on communal norms, they have substantial value and are worth the adaption time. When in Windows C++ -- follow the conventions, when in Linux C -- again, follow the conventions -- and when in Go -- do that same. Fighting the dominant style for established platforms and languages is a mostly pointless, exhausting and sometimes debilitating task generally only done by those too inexperienced to realize how ridiculous it is. Team leads more experienced tend to just choose whatever is the dominate style / layout (preferably per-written up) for that platform/language realizing the benefits for getting ease of reading, consistency, hiring, firing, flexible labor (consultants) and most importantly not having absolutely worthless debates about style and layout.

I have OCR in production live written in pure Go. It does OCR on small specific portions of images to get keywords out to be put into a DB (1B+ page scans). We use tesseract for full page scans (when needed, when our OCR fails). But Go was so easy to write, and so fast to get live for small page partials that we wrote it in a few weeks (idea to live, just implementing well known algorithms) to avoid having to deal with tesseract overhead in the average case.

I am curious about specifically where you got bound up -- and how we managed to via ignorance or blind luck avoid these rough patches. Additionally, I am not 100% sure I understand why you refactor cycle is so brutal. That generally is one of the things I enjoy about Go, lightspeed refactor / dev / test cycles.

Good thing no one is asking you to use Go, Haskell is always around (and Elixir, I guess... I am too used to Erlang syntax, Elixir feels like an ill fitting glove) and we need lots of great languages -- and they SHOULD feel different and some shouldn't be a great fit for you.

Agreed (Gopher 1+ years)! My heart still leans towards Erlang, but Go is my current daily driver. The vicious pragmatism at every turn is whats keeps me (and the team) loving it.

It isn't the most elegant, not even close. It isn't the most succinct, not even in the running. It isn't the most flexible -- people would mock you for claiming it is. It isn't interesting in the least, remarkably unremarkable as they say.

But when it comes to just simply getting shit done, and quickly understanding and being able to work in other peoples code, it is second to none. It just doesn't get in your way, and out of the box it gives you simple syntax, great tools and easy deploys.

It is opinionated (a more useful word than pretentious), and it is this way across many things. From style to directory structure to versioning of dependencies to generics. If you actually read the reasoning behind them, I think they are rather well defended by very smart people, but to each their own.

If you really have an issue with some of the very opinionated ideas that come to a large degree bundled with Go, that is fair. That is great even! It probably isn't a good fit for you. Which is fine, there are hundreds of other programming languages that work for you, most are the wild west.

For certain people (like myself) the sanity of Go is striking -- each decision is made for unremarkable and straightforward defensible reasons... a lot of them are community driven over personal preference... it is better for the herd (think: herd immunity) if everyone uses one style and everyone uses one layout... etc. It isn't about being "right" or "needed" by every person, it is about being consistent so you can move from project to project and focus on learning the code, not layout or style, just what the code does.

Go was designed from inside Google, with large teams in mind with many projects.

I fully support language specialization -- that is kinda the point, it all ends up bits in the end. Rust is a completely different animal than Go yet I think both are awesome!

The idea that all languages have to cater to all people is silly. Generics are ALWAYS a trade-off. None is hard for developers, C++ style is terrible for compile (tons of code-gen, macro crap, duplication, de-duplication stages), and Java style (box-box-box-box) is slow at runtime.

The misunderstanding that generics are free and there lack of inclusion was an oversight rather than a choice is misguided. The Go team aren't fresh faced neophytes, they move with purpose.

Additionally -- if you want lots of features, there are LOTS of ways great languages for you! Leave the small, crazy cadre of people who don't mind C, think Lua is awesome and think Go is great to their (own) devices, we will be OK.