extempore

Paul Phillips here. I searched my tweet archive for my tweets about Go. Draw your own conclusions.

- Kill me before I look at go.

- Nobody shot me first so I looked at go. Sigh. After maybe an hour of go I was ahead of where I was after a week with rust.

- The first audible WTF with go: cuddled else is mandatory. Parse error otherwise.

- go is a terrible, terrible language, yet still a major productivity boost. Amdahl's law in another context.

- You often see languages which are fighting the last war. Go is fighting the War of 1812.

- If someone had made up Go within a work of fiction, they'd have been laughed out of the room.

- I had thought Blub was a rhetorical device, but Go is more Blub than Blub.

- reduce: what you will do with your expectations after you start with Go

- Did they miss any chance to introduce an ad hoc inadequate non-solution? Tool directives in comments! What could go wrong!

- Comical levels of confirmation bias in proglangs. Guy doesn't get it, poor impl, isn't useful, "see?" Examples: scala, python, go.

- Some specifics are enumerations in scala, closures in python, and anything devised since 1980 in go.

- Go: compiler directives in comments is "an elegant design". https://t.co/DjCO1UxgC2 http://t.co/BR3kFxRZvc

- Rust and Scala drown you in complexity. Go drowns you in simplicity.

- This comment sums up Go pretty well. https://t.co/Td9Q3wOW43

- go logging package lets you set the global Writer, but not query it. So you can't save/restore it. Nice job.

- This year's gold medalists in type safety's missing-the-point olympics: Go! https://t.co/ktrlBUEwP9

- Turns out Go is the result of a bar bet between Rob Pike and Robert Heinlein. Everybody lost.

- It’s incredible how far Go has lowered my estimation of the vaunted Google engineer. What an institutional failure.

- Go is what you might come up with if your definition of programming was “shuffling electrons”.

- A Go discussion thread is “how to build a space station with crayons” up to homotopy.

- A supposed selling point of Go is that you can learn it in a day. Think of what that tells you about what it can do.

- The existence of Go leads me to realize the infamous Google technical interview is designed to weed out out-of-the-box thinking.

- I added a second file to https://t.co/ktrlBUEwP9 further explaining how go's casting requirements are broken by design.

- But little did I know, I’m just a “lesser” programmer because I enjoy Go’s simplicity" says a commenter. Well, yeah.

- The Go string type can't be passed as a fmt.Stringer. You apparently have to accept interface{} and type match. Amazing.

- An example of go upside: "go get ...gocov" and code coverage instantly worked. In scala it has always been painful/fragile at best.

- Any go code which has error in parameter position which tests err against nil will silently miss a bunch of errors.

- Hostility to abstraction: the Go story

- Sad that google waited this long to put a deep mind on go.

For any who wish to better understand this important point, see https://existentialtype.wordpress.com/2011/04/24/the-real-po... (including the comments)

That was Metaspy, part of Metacrawler.

Source: I wrote Metaspy. That was almost 20 years ago!

He means best-known, not best known. It's a statement about which is better known, not which is better.

This is such an interesting choice of example because this particular implicit is baked into the language, and the discomfort you feel is a fine measure of how good an idea this is. Last I checked there was no way to turn it off.

  scala> def f(x: Float) = x.round
  f: (x: Float)Int

  scala> f(123456789)
  res0: Int = 123456792

But of course it doesn't stop at converting Ints into Floats.

  scala> f(Long.MaxValue)
  res1: Int = 2147483647

So it seems 9223372036854775807 rounds to 2147483647. This can be a real simplifier if your "big data" is getting too big.

> But I would really appreciate it if anyone else has more thoughts about how to filter out images that do not contain people :-)

Google allows image searches to be filtered by is/isn't a face. I think you could tap into that knowledge, although it isn't immediately clear what the route would be.

Here's a detailed rundown of the more obscure google search paramters: https://stenevang.wordpress.com/2013/02/22/google-search-url...

The relevant one to your interest is "tbs=itp:face".

"Criminal" is definitely the word to use when it comes to applescript, though maybe not in quite that way.

Recommended: http://www.amazon.com/Then-Thought-Was-Fish/dp/0985318139

The purpose of criminalizing such activity is not to discourage people from engaging in it. It is to guarantee that everyone is a criminal, thereby ensuring that leverage is always available.

I am intimately familiar with your work on scalac, and that's all I can bring myself to say about that.

That's right, I'm the stodgy conservative one and martin is the fearless innovator. Where is this version of the movie playing? I'd enjoy seeing it.

Your second paragraph lands somewhere between completely wrong and "not even wrong" if it is supposed to have some bearing on the matter. You don't appear to know the first thing about what I've said, what I've done, or what is really going on here.

Reflexive loyalty of this kind, unhinged from any objective reality, is what has brought us today's scalac. You should reconsider whether your having worked on the scala 2.7 eclipse plugin nearly a decade ago qualifies you to take a position on this. Then to position martin as the scrappy underdog - "let's hope he doesn't cave" - just let us know when the novel is finished, and I hope it's better than the movie.

Dotty is unlikely to attain relevance - for me or as a future version of scala - because there's no reason to expect it to be any less of an implementation nightmare than is scalac. It is being written by the same person, applying the same engineering standards and the same checks and balances, so starting with a less unsound type system isn't going to matter.

Yes, MPS and "language workbenches" in general are chasing something similar. Ideas like these are entirely in the details though, and so far I haven't found anything which does it for me. I could easily be missing it, in part because systems like MPS have a high up-front investment, and I have regretted such investments more often than not.

There is "a spec" yes. Now let's see someone implement a compatible implementation based on that. We're not talking about fiddling at the boundaries here. For instance type inference is completely unspecified. There is no aspect of scala compilation which is not heavily influenced by how type inference unfolds, yet there is nothing. And that is the tip of the iceberg.

If you're always hearing about how amazingly small scala's specification is, now you know why.

Martin has been determinedly ignoring me for so long (at least two years, probably more) I've pretty well forgotten it was ever otherwise. He is undoubtedly correct that ignoring me achieves better damage control than any active response could.

I will continue to merge from scalac for as long as I can, because with no meaningful specification it is the only way to retain compatibility.

I didn't say I'm dropping reflection, I said I'm dropping the scala-reflect layer. It's a gigantic and useless abstraction penalty. I'll fold the pseudo-compiler into the compiler.

We'll see about collections. Here's where it stands: https://github.com/paulp/psp-std

> Paul, why do you say it's wrong that Float(Long.max - Int.max) is equal to Float(Long.max)?

I don't. You have inserted coercions.

I'm aware of how many bits things have. It's hard to make it through five years on a compiler without gaining some awareness of such details. I consider the introduction of lossy type conversions into the global scope to be a kind of insanity. People should be recoiling from such practices, not looking for ways to justify them.

For the record, martin has never hired me for anything. I co-founded a company with him.

> I would actually say that he is making it worse, in some respects. Many, actually.

Oh, for sure. The key though is that the value of "it" which I am making worse is not a value of "it" which I have any interest in making better. Nor would I ever suggest otherwise.

In your mind I may be nothing but an input into your total utility function, but there's no reason for you to expect me to care about maximizing it.

I also vote for both.

Typesafe hasn't lost my confidence. Typesafe has been responsible for important progress which is already being taken for granted. People either have forgotten how low assurance was in the 2.8 days, or they weren't using scala yet.

The problem is on the other side of the Atlantic. Scala is unfixable now no matter the abilities of the people working on it because of the bad decisions which have been made to this point and the unwillingness to revisit them even when the failings were grossly apparent.

Organizations modeled on dictatorships can work fine but they're painfully vulnerable to the dictator's blind spots. As the years go by, the dictator becomes accustomed to being able to settle any question by fiat. He becomes less and less concerned with evaluating the true worth of his own ideas. As long as his power is unquestioned and there is a steady supply of people to do the work, why should he? He's the Decider. He decides.

As I told him at some point "That well does run dry eventually" and indeed it did, for me at least.

It's not a question of whether they should exist at all but of whether they should infiltrate the collections hierarchy to the extent that someone has to maintain code which looks like this. And there's plenty of it: this is only an example.

  trait ParIterableViewLike[+T,
                            +Coll <: Parallel,
                            +CollSeq,
                            +This <: ParIterableView[T, Coll, CollSeq] with ParIterableViewLike[T, Coll, CollSeq, This, ThisSeq],
                            +ThisSeq <: IterableView[T, CollSeq] with IterableViewLike[T, CollSeq, ThisSeq]]
  extends GenIterableView[T, Coll]
     with GenIterableViewLike[T, Coll, This]
     with ParIterable[T]
     with ParIterableLike[T, This, ThisSeq]

The offhand dismissal of Raymond Chen as an "incompetent programmer" captures the hacker news zeitgeist.

I gave a talk recently which has a premise the importance of flow state. Linking into the middle of it: http://www.slideshare.net/extempore/keynote-lambdaconf2014/1...

I take the position that a slow compiler exacts a cost far beyond the obvious, because it inhibits flow state.

Yeah, it's configurable between "Demand my password again if 15 minutes has passed" and "Demand my password again immediately." You can tell you're going in the wrong direction when you first have to "enable restrictions" hoping to relax the restriction. I take it you've never actually tried to configure this option.

It translates to myObk.explode(10).times.

toIndexedSeq takes a type parameter (I'm not sure why - it appears unncessary) which means the result of toIndexedSeq is not known when it is attempting to infer the Ordering. toSeq doesn't take one, it's known to be Seq[Int].

The other looks like some quirk of partial application. It's unlikely there's any fundamental reason, only an implementation imperfection.

> Some things that should be simple and straightforward, like iterating through an array, are impossible.

Impossible?

  array foreach f
  array map f

Or if you miss java enough:

  var i = 0
  while (i < array.length) { f(array(i)) ; i += 1 }

I can't even imagine what it is you think is impossible.

They have of course spurned your counsel about catering to windows users throughout the last decade, all the way from "close the stores and give the money back to the shareholders" to somewhere in the neighborhood of the most successful company ever. All the while thinking it is still 1990 (the significance of which is a little hazy.)

If they didn't follow this advice when they were on life support, what would possess them to follow it now? It's hard to imagine that one could overlook the evidence (here, and everywhere) that if success is the goal, mimicking windows should be closer to a prohibition than a mandate.

If you lose it you might look on amazon, where you can find this book with four different covers. (!)

http://www.amazon.com/s?ie=UTF8&rh=i%3Astripbooks%2Cp_27...