> Does a family making 250K-300K in Seattle really count as "rich"? ...A family earning 200-250K in Seattle will definitely feel this tax.

A family of 4 could live pretty well on half that in Seattle. Maybe they aren't "rich" as in "filthy rich", but I don't see how they'd actually feel it, other than savings goals having to be slightly less aggressive.

At $250,000 / year, your pre-tax monthly income would be about $28,833 and a tax of 2.25% would shrink that by $468. I don't see how I could honestly say I felt the tax if I made only half of 250k and they double it to 4.5%.

That sounds like how people become low level managers, too.

Leaking air also isn't as much of a problem, since a pump just pumps more in, as long as the leak isn't too bad.

eff.org Offline For Maintenance We're currently offline for server maintenance. Please check back soon.

2017-06-29

It lets you define types for more safely interacting with other Javascript code. It doesn't magically make browsers have consistent behavior.

What I'm getting at is how it handles type safety at the browser API boundary. e.g. how does it handle a situation like:

`eventTgt.addEventListener('whatever', fn, true)`

vs

`eventTgt.addEventListener('whatever', fn, { passive: true })`

Does it just allow 'Any' for the type of the third param and thus somewhat punt on type safety at the browser API boundary or is there some attempt at defining an algebraic type for that param?

Or as another example, how would it handle the object passed to `fn` above, presumably some sort of event type, having different properties in different browsers?

In the standard types for the DOM [1], only types for standardized browser APIs are made available. Browser inconsistencies wrt. standards are dealt with polyfills, either written in JS because they already exist, or you can write them in Scala.js too if you prefer.

But Scala.js doesn't force the standard typings on you. If you prefer another strategy, you can write your own types for the browser. You could use overloads in your example above.

That wouldn't prevent you from using the wrong overload on the wrong browser at the type system level, though, obviously. Doing so might be possible if you're willing to go very far with Scala's path-dependent types, but I won't go into details here. Scala.js users tend to prefer the earlier solutions.

[1] https://github.com/scala-js/scala-js-dom

> It lets you define types for more safely interacting with other Javascript code

You define types for everything.

Why would someone use ClojureScript instead of this? Unless they're a Clojure expert.

Why koi instead of tilapia?

Because some places have winter, no?

Clearly they must be racist, too.

And homophobic.

Ok, now do it for someone with 5 and 10 years of experience.

That question is easier with experience, because you know more about how positions look like in practice and what you disliked in the past.

Here's my honest answer:

I don't know, because based on my experience, your company won't even exist as a separate entity five years from now, and if it doesn't lay most of us off before the acquisition, the purchasing company will just afterward. So I'll probably be sitting right where we are right now, answering the same question again. But maybe--just maybe--the company will last that long, and grow, and I'll be sitting in your seat, asking it. But since I am where I am, that obviously hasn't happened yet.