kmiroslav

Does any Go editor support that?

Nothing about the language or its tooling prevents you from building such an IDE or a plugin to one of the existing IDEs. And there is absolutely nothing in Java that makes IntelliJ so awesome. These things are totally orthogonal.

No, they're not.

There are a few necessary conditions for this kind of symbiosis to work well:

- The language has to be statically typed. Without type information, the IDE is completely blind and can barely help you at all without human supervision.

- The IDE has to be written on top of the same runtime as the language it's editing. This is what makes Eclipse/IDEA and Visual Studio so spectacular: they understand the bytecode they are working with.

These are necessary conditions but they're not sufficient. You can still write crappy IDE's if these conditions are met, but thankfully, IDEA/Eclipse/Visual Studio are technical wonders that multiply the productivity of their users.

For example, in Go, the simple action of selecting the the surrounding expression simply doesn't exist anywhere. It's the most basic automatic action that's trivial to do with the proper language and IDE, and yet nonexistent in Go. Along with tens of others.

That's the price to pay when a language is designed without any consideration for its tooling nor basic things we learned about language design these past twenty years.

Everything is perfectly usable without an IDE, you are just more productive with one than without one. Regardless of the language.

In this particular case, the IDE could automatically remove the imports when you remove the corresponding symbol from your source, or automatically add the import when you introduce a new symbol.

The "can be supplied by any external tool" is a cop out that was acceptable in the 20th century but this is 2016, we have a higher bar for developer productivity.

It's a simple reflection of the fact that the Go creators have never used a modern IDE.

Anyone using a modern IDE pretty much never even thinks about imports, which are (and should be) automatically managed by the tool, not by the programmer.

This is like saying that if somebody leaves their door unlocked, it's their fault if they get robbed and the robber shouldn't be held responsible.

It's R&D expense. Nothing new here.

It only takes one of these moon shots to be successful to bring in extraordinary revenues, and Google has always been crystal clear that following such path was in their DNA.

Hard to imagine that R is more popular than Javascript.

But the information is not sent to the server, it's simply pasted in the text field.

I don't quite follow. The author says that by entering the URL "http://avlidienbrunn.se/@twitter.com/@hehe.php", the extension is fooled into autofilling as if the browser was on twitter.com.

What's the difference with simply going to "http://twitter.com"?

This looks more like a bug than a vulnerability, what am I missing?

There are still a lot of Javascript developers around :-)

Pretty sure that pendulum is never swinging back in the dynamically type side.

The simple truth is that today, statically typed languages have all the advantages that once used to be the exclusivity of dynamically typed languages, while the reverse is still not true.

In 2016, there is really very little reason to pick a dynamically typed language for any serious project.

Javascript is going to be around for a while because of inertia, but it's pretty much the last mainstream dynamically typed language we'll see.

Because if you like a language and that language is popular, you're more likely to find a job using that language, which in turn will make you happier.

Dart is awesome. Just because currently the community is still small doesn't mean much.

Well, it does mean something. Go is evidence that languages can gain momentum very fast so the fact that Dart still hasn't should be a bit of a concern (and probably partially caused by Typescript's popularity).

Jonathan Schwartz?

Doesn't that make the parameter anonymous, though? Can you println that _ and see the value of the current element?

Groovy and Kotlin use the implicit "it" parameter for lambdas that take just one parameter, which is very convenient:

    listOf(1, 2, 3, 4).filter { it % 2 == 0 }

That's pretty amazing.

You know, it wouldn't surprise me in the least if you're the only developer who ever created a language and whose day job is not writing code.

Hat's off to you, seriously impressive.

The DMCA complaint from the NRA looks legitimate, it's the decision from DigitalOcean to shut down the entire Surge network instead of just taking down the offending content that seems disproportionate.

It's easy to do this when you don't need to interact with the outside world and you don't even care about memory protection.

I'm having a hard time imagining how a Python tool could be a solution to a performance problem at the Google scale.

It's still not the same as perforce's mappings. Even with shallow repos, git will force you to download the entire world each time you pull or fetch.

Why are programs even structured as sequential lines?

Same reasons books are structured as sequential lines: easier to read for humans.

And the reason why source code is still heavily text based and why introducing more WYSIWIG to it would be disastrous is that all the peripheral tooling would become a nightmare (diffs, code reviews, source control, etc...).

You're right, I misused the term. Statistically, I'm sure the votes were counted accurately and that margin of error is extremely small and would not invalidate that vote.

I was referring to the fact that when a result is so close, the vote might have a different outcome simply based on who shows up to vote that day. If there's a revote, more people against leaving might show up because they didn't realize they would lose. And then if a third vote is held, the result might swing again.

Our country is clearly split right now, but the road ahead for the brexit outcome is terrifying and full of unknowns, as the commentator acutely outlined. Is it worth going through so much turmoil when there is barely an inch above a majority that voted this way?

My answer would be a resounding "yes" if the result was 70%/30%. But 52%/48%? Maybe we should spend some time thinking this through before enacting Article 50. And all the current leaders seem to think this way right now given how discreet they have become as the reality is slowly sinking in.

Technically, sure.

Practically... it's a 52%/48% vote. Hardly a mandate. Some people say a revote might yield an opposite result, which means the current outcome is probably under the margin of error.

It wouldn't exactly be a miscarriage of democracy to not follow through and see how things unfold in the next couple of years, and maybe vote again to see if the gap widens or if our country remains split in the middle on the issue.

At any rate, this comment about the situation is frighteningly deep and chilling.

Interesting, I didn't know about `delete`.

Come to think of it, the trick to make something private in order to "remove" it is one of these very few areas where C++ makes you pay for something you don't use, so I'm not surprised that there is now a special keyword (well, a repurposed keyword) to address that.

Too soon to tell.

Sure, a few countries will try to follow suit and try to leave the EU but imagine a future when, in a couple of years, Britain's economy has dropped below #10, unemployment is at an all time low, the deficit has ballooned, etc...

What do you think EU members will think by then? They will certainly want to stick around.

The bottom line is that the current decision was made by voters who are swayed by immigration and talking points from crafty politicians but who have little understanding of how global economy works.

Let's see what the situation is in 2018.

"Huge code base" is a pretty vague metric. Huge in what, lines of code? Binary size?

I'd argue that neither of these are really a good measure, I'm more interested in the concepts that a source file captures than its size in kb, because these concepts correlate directly to how easy it will be to evolve that code base in the future. There is a point of diminishing return in trying to make the code too compact, which basically means you're optimizing in one dimension at the detriments of all the others.

I was talking about programming languages.

Obviously, message passing is alive and well for network protocols.

Nothing wrong with looking at nature and trying to get inspiration from it (e.g. neural nets) but ever since we realized that flight was easier to implement with chemical combustion than by flapping wings, we know that just because something works in nature doesn't mean it will be easy to replicate for human use.

If anything I feel the failure of OO languages

What failure exactly?

OOP has flaws but it has certainly proven to be extremely versatile and adaptable over these past decades since even today, it's still the dominant paradigm to solve modern problems in computing.