wakeywakeywakey

I agree overall, but some language/env enhancements (e.g. BigInt) transpile more naturally than syntax-dependent ones like #private.

There is a lengthy debate surrounding private field syntax [1][2]. As a TypeScript user, I prefer regular-JS drop this proposal altogether, rather than use the current syntax. Refactoring and index-access notation become awkward with it.

Anecdotally, the vast majority of serious developers I know transpile to JS.

  [1]: https://github.com/tc39/proposal-class-fields/issues/177
  [2]: https://github.com/tc39/proposal-class-fields/blob/master/PRIVATE_SYNTAX_FAQ.md

TypeScript is one of the fastest-growing technologies in the JS ecosystem right now. It's unlikely the team is using the back button behavior as a way to get membership.

Incidentally, to which porn sites are you referring? Which of your favorite porn sites do you think do the best job with UI/UX?

It seems like they've chosen Rust for the backend. This is a great fit in terms of preventing data races and having a no-GC performance profile.

I invested quite a bit, now I have egg on my face.

You are conflating what you wish were true with reality.

For-profit companies typically build toward what they believe is in-demand and will be well-received by consumers. They perform market analysis to reinforce their intuition. Sometimes they get it right and their stock goes up.

There isn't some elaborate plot on the part of Google, nor are 'they' purposely making something 'no consumer ever demanded.' When they do this, the endeavor fails and we call it a flop.

> https://github.com/facebook/create-react-app/issues/2398

Equating 'create-react-app' package with React is silly. By that logic, I can wrap $library_of_your_choice in scaffolding and then blame it for the bloat I've chosen to add.

> EDIT: see gov.uk. It works quite well without being fancy.

We're at an impasse, since you countered my 'assumption without data' with your 'one-off anecdotal evidence'

> If you load a React frontend, it'll, by default, deploy a service worker.

What?

> That is how the web works.

The web 'experience' has stopped being about fetching static documents in a request/response fashion long ago. Consumers demand rich apps and interactivity, and it appears they're having it their way.

No, thank you. SourceForge used to inject adware into projects. Now, they're trying to profit from the anxiety surrounding the GitHub acquisition talks.

I'll take my chances with Microsoft.

Sleep, exercise.

Just wanted to comment to raise awareness for those of us without 20/20 eyesight.

HN staff: please consider having a typographer/UI designer make a few improvements to the base stylesheet. I realize the codebase may be old, but it's a paragon of Lisp purity so it should be easy to change, no? ;)

This is a scam. Do not click the link.

Moderators please take this down.

I've built large production apps in all 3 frameworks. After using React with TSX -- and getting symbols and refactoring across templates -- there's no going back. IDE support with VSCode is incredible.

I routinely see Angular and Vue projects littered with magic strings/globals in their templates. These are ok on the first pass-through building the app, but refactoring and maintenance are a nightmare.

The state of the art right now IMO really is React + TSX.

"I do."

By this logic, it would be fair to say:

'When I get my paycheck, I earn my salary MINUS whatever "profit" my employer made from my work.'

This is disingenuous by ignoring risk and presupposing that (in this case) I have the same reach/clout/contacts/sales and marketing channels as my employer.

Typed that on my phone, should be:

Object.entries({}).forEach(([k, v]) => { })

Anecdotally, everyone I knew who tried it complained about lock-in (environment too prescriptive and has behavior you can't opt-out of) and no longer uses it.

There is development activity in the repo, but I would say the 'hype' has moved to other projects.

You can use array destructing, when supported:

Object.entries(([k, v]) => { })

An issue with these micro-packages is they introduce new semantics to your code, like throwing exceptions when vanilla JS would return NaN, etc. Once your code base grows, refactoring away from such packages is actually a lot more risky than it appears, and they tend to be sprinkled everywhere.

I've found it better to write my own "utils.js" functions, with clearly-defined semantics, that become part of the project strategy. This also has the benefit of reducing dependency churn and maintenance of package.json.

Could you explain how permissions could be better achieved? Also, could you provide examples of platforms with good permission/security model?

It does not have to be 50/50. If you have been contributing for a while, it's perfectly reasonable to give them less. Figure out what role they'll play, and for how long, then put them on a vesting schedule.

... if someone's paying for it.

They don't need to 'focus' on that, since there are various strategies to achieve it without redesigning the blockchain as a whole. For example, there are light clients [1] you can run which only download part of the blockchain and still provide some guarantees.

[1]: https://github.com/ethereum/wiki/wiki/Light-client-protocol

Try this to remap caps: https://docs.microsoft.com/en-us/sysinternals/downloads/ctrl...

Unoriginal, unfunny article peddling the same tired old crypto tropes.

At least put some effort into it like the "Pyramid Scheme" [1] post or similar.

[1]: http://www.michaelburge.us/2017/11/28/write-your-next-ethere...

The only thing missing from this post is 'we take security very seriously'

To all the positive patsy's of the HN forum: the exception doesn't make the rule.

Instead of being lulled by the veil of consumerism draped over your eyes, realize companies only maximize profits and do 'good' as an accidental side effect of their goings-on.

It still allowed you to boot from USB? How do you recover if you lose that option (other than sending in your laptop to be reflashed)?

What did you do to recover?

In TypeScript, you can also use an empty const enum to simulate nominal typing for opaque types. It gets inlined/removed during compilation:

  const enum _A = {};
  type A = number & _A;

This comes in handy for IDs and other primitives shared by multiple complex types.