This feels like an attempt at deflecting blame. VSCode is another Electron application that ended up having better performance than Atom. There's another Electron adjacent application that has good performance, the one you're probably using right now to read this page.

Depending on page content of course

VSCode can pretend to be fast in my desktop, and I would not care because desktops today are computing monsters that rival supercomputers of the past, but Sublime Text is still much faster at any text editing task.

Atom was kinda like emacs. Extensions could do almost anything. VS Code has a limited api that extensions can use

In my experience VSCode is plenty fast. Use it with no extensions and you will have zero problems with performance (though memory use isn't great). The real problems come when you have extensions, especially because it's often impossible to attribute performance issues to them because they can often do a lot of work all in the same "extension host" process.

Memory use is a part of performance, though, so I definitely would say VS Code has serious performance issues. It's why I no longer use it, in fact. It's inexcusable for something to eat as much RAM as VS Code does.

[0] https://news.ycombinator.com/item?id=45916196#45919739

I'm sure expensive pants have their benefits but no matter how much money I have, I will always baby expensive things, and it's very inconvenient to baby clothes (e.g. must be dry cleaned, can't use a washer or dryer, can't risk getting stains on it). There are good reasons why dads gets their clothes from Costco.

It opens a special "aggregate flame graph" view of the profile since pprof does not preserve time information. But it works! We use it for visualizing aggregates across thousands of profiles in production!

edit: This is what they would need to do: https://en.wikipedia.org/wiki/Nuclear_option

Congress cannot pass anything meaningful except one omnibus spending bill each year via budget reconciliation, which has arcane rules around flat budget impact after 10 years. Since congress can't do anything, we naturally move more and more of the details of federal governance to executive agencies and executive orders. While not all of this is bad, it has a few horrible effects.

First, the supreme court is more willing to interfere with executive action, amplifying its power as it finds reason to protect actions by the favored party and cancel actions by the disfavored party. Increasing the power of the supreme court shifts federal power towards an unelected branch that is the slowest to adjust to changing voter preference.

Second, as more power within the executive gets concentrated specifically with the president we enable more and more federal action at the whims of exactly one person. This exposes us to the current situation, where Trump is unfettered in how he wields the executive branch rather than guiding it and having its power distributed across the executive branch.

And we've also got the general popular dissatisfaction with congress and the democratic process because they can't get shit done. A country that has an enormously unfavorable opinion of congress is more primed for collapse into anti-democratic governance.

Yes, if we didn't have the filibuster then the GOP could pass all sorts of nightmare legislation. But I'd prefer legislation enabled through the will of the people to this slow collapse into authoritarianism.

> Since congress can't do anything, we naturally move more and more of the details of federal governance to executive agencies and executive orders.

It's really interesting how wildly different this is than parliamentary systems where Parliament is the ultimate authority and the executive's tenure simply ends if they lose the 'confidence' of a plurality in Parliament.

Instead we have a useless legislature as you described, and an executive whose claim to all this additional power is actually quite dubious, yet that executive controls nearly everything. I don't think a swing to the other party changes this, either (not that the DNC is capable of winning elections enough to ever hold the kind of power the GOP now has). I think from now on, the President will rule by executive action, and use creative avenues like rulings from friendly courts to vaguely legitimize this power.

    package main
    import "fmt"
    type I interface{}
    type S struct{}
    func main() {
        var i I
        var s *S
        fmt.Println(s, i) // nil nil
        fmt.Println(s is nil, i is nil, s == i) // t,t,f: Not confusing anymore?
        i = s
        fmt.Println(s, i) // nil nil
        fmt.Println(s is nil, i is nil, s == i) // t,f,t: Still not confusing?
    }

- `is` for interfaces checks both value and interface type.

- `==` for interfaces uses only the value and not the interface type.

- For structs/value, `is` and `==` are obvious since there's only a value to check.