Shoothe

I don't see how this reply addresses the core point, it just argues that async await is useful (that's fine but not novel by itself).

It is possible to work around the "color" by using generators [0], that way one algorithm can be used in synchronous and asynchronous way. Async await tightly bind to underlying Promises.

[0]: https://curiosity-driven.org/promises-and-generators#decoupl...

I just searched for "buy Twitter followers" and it seems 10000 followers cost only $40: https://www.socialshop.co/twitter/buy-twitter-followers/

It's funny looking at the page with various packs, just like a normal service: "express delivery", "high quality"!

Lean analytics is not an oxymoron: http://leananalyticsbook.com/

Select a subject that will challenge you on multiple levels simultaneously, for example if you don't know Rust and microcontrollers go through this: https://japaric.github.io/discovery/

> It’d be fair to say that I could’ve written an equivalent service in Ruby in a tenth of the time it took me to write this one in Rust.

Ha, I had the same feeling when I needed to create a simple REST service that'd just process a request using command line tools. Seems easy but Rust's tooling is full of rough edges. Code completion sometimes works sometimes doesn't, cargo cannot install dependencies only (without building source) so it's not good for Dockerfile layers, etc. etc. Borrow checker is not bad at all for people that worked with languages with explicit memory management (where you do ownership tracking in your head anyway).

Long story short I spent 2 days working on the service and had 80% done but figured out the rest would take twice as much if I want this to be production quality. I scraped the project and rewritten it in node, using one or two dependencies in 2 hours.

I'll be trying Rust again surely and I'm glad that articles like this one exist!

For the record Roy Fielding is against using version numbers in URLs: https://www.infoq.com/articles/roy-fielding-on-versioning/

Movim [0] is also a federated social service.

[0]: https://movim.eu/

> standard of sorts in im space.

XMPP? Check out https://conversations.im/ and https://dino.im/

Encrypted, federated and modern.

I'd be interested in looking at the generated IL, especially for nullability info and default interface methods.

Well it may be splitting hair but there is no proof or work and the number of nodes is certainly smaller.

There is also CONIKS and Google's Key Transparency.

This comes to my mind: https://medium.com/@bbc4468/centralized-vs-decentralized-vs-...

Yes, WebAuthentication will supersede U2F and it's backward compatible (meaning you can use your Yubikeys, but the API is different).

I guess they mean extra API that utilize stuff that's in HTTP/2 but not in HTTP/1.1.

I wonder what do they do with Service Worker updates that the browser normally does every day or so. Do they somehow block install and activate events? If not then the attacker just needs to update the worker and the history repeats.

They are not encrypted but signed with an elaborate algorithm (I worked on ActivityPub server implementation).

Twtxt is minimalist but functional: https://github.com/buckket/twtxt

I can second this. I wanted to write a simple provisioning tool a while ago that sets up HTTP endpoint on API Gateway and forwards the call to Lambda and the process was extremely complicated.

It transparently uses messages if a messanger does not implement the XEP so anything supports it. Just without the fancy UI.

You are only giving the site your JID (username) not password and it verifies that you control the JID so you really are jepz@example.com

> The larger issue, I think, is that most open questions now are either of the "How do I do obscure thing X in framework Y under rare condition Z" variety, or beginner "Please do my homework" or "I have a bunch of things in my array it's not printing" sorts of questions.

I think it's due to the fact that the questions "in the middle" are already answered and people find them through searching. No need to and again. Only beginners (that can't search effectively) post on SO or people having rare edge cases (for which asking in SO is a last resort).

I'd like to see various serverless providers adopting this interface (Service Workers) as well. Currently AWS Lambda needs some mapping in API Gateway and a handier function. Google Cloud Functions use express-like interface and so forth.

Maybe it would be useful to mention that debugging can be more difficult when using tail calls as previous stack frames are not available.

I've used two services from IBM: Notes and node DB2 package. Both of them were pretty low quality, the db2 package was so unstable that it constantly segfaulted the entire node process. It's not fixed for years since the issue was reported with reproducible code. Needless to say I wouldn't recommend IBM even to my enemies.

Can anyone share a good IBM experience? I'm honestly interested.

> I can't speak to Let's Encrypt, but the bigger companies that make their money in the CA space are insanely serious about security.

That's really what I'm interested in, very high level security / operations standards. Not that I'm intending on running the CA myself but it's easier to understand daily trade offs knowing how it would be done if extremely high standards were absolutely necessary.

Unfortunately there is not much reading material online on this subject (I understand it may not be super interesting subject for most people) but reading the CPS really shed some light.

Thanks for your comment!

Nor S/MIME and code signing certs. They also won't provide auxiliary services like timestamping.

In OVH you can restrict token access to individual resources (in this case one record) at token creation time.

Just remember that the cert will be logged (Certificate Transparency) so any names there will be disclosed to the public. Wildcards help a little here though.

Rust (rls) works! Excellent. Maybe the Rust team should have a recommended tools page? (obviously curated)

> Also sometimes I just let the compiler tell me by forcing the let variable to something that it is obviously not:

Ha! Very clever! Thanks.

Nope, I'll try that out tomorrow, thanks for the advice!

VS Code's handling of TypeScript really spoiled me but on the other hand it seems like tooling becomes more and more important in programming languages (e.g. Roslyn).

Note that using the interface ITuple instead of the tuple types directly will incur boxing (memory allocation for reference type instance).

I'd definitely read more about how to do it properly. For example I wonder how CAs (e.g. Let's Encrypt) secure their infrastructure.