evangow

This is a great question. I would love to see more documentation on what this means for transactional emails.

Adding systems in place to handle unsubscribing from transactional emails will mean quite a bit of engineering time/effort for many companies.

They defined bulk senders in the 3rd paragraph: "bulk senders — those who send more than 5,000 messages to Gmail addresses in one day"

Many people know javascript, so when they want to build something, they use the language they already know.

If you know you are at risk for specific cancers, then you would likely get tested more regularly and could potentially catch them at an earlier stage when they're usually more treatable.

I haven't looking into this specifically, so I have no idea if that works for the types of cancers this tests for. My point is applies to testing just generally speaking

You can make a REST endpoint match a client's needs, but if you have multiple clients (for example, 1 for mobile and 1 for desktop) that all need different amounts of data (for example, the mobile client shows a simplified view with less data), then you would need to write 2 different REST endpoints to handle each clients. Multiply that by the number of pages with a difference.

I would love it if the would remove the key from the array.

2 tables that reference each other and the foreign key columns both have a NOT NULL constraint.

Since we're here talking about Postgres and SQL standards. Here's my wishlist:

- Support for arrays of foreign keys. This one has been worked on a couple of times but hasn't made it into a release. https://commitfest.postgresql.org/17/1252/ - I think this would be an absolutely phenomenal way of handling sorting, instead of having to use linked lists and CTEs or some type of "order/position" column

- Support for deferring NOT NULL and CHECK constraints to the end of a transaction (just ran into this problem yesterday)

Edit: typos

I haven't used PrivateLink before, but from my brief look, it looks like it would work.

Security

Any plans to introduce a way to connect to a Neon database without making it publicly accessible via the internet?

I build marketing software for authors (called StoryOrigin if you want to look it up for credibility purposes), so I'm quite familiar with the space.

Exactly what you've described is already out there: https://www.atticus.io/ (released last year - I have no affiliation.)

Gotcha. That makes sense since each site is deployed separately and not a subdomain of a single deploy. Thanks for sharing!

I'm curious as to how you all are providing SSL for custom domains

1) https://github.com/react-page/react-page (comes with a Slate plugin actually) 2) https://grapesjs.com/

I'm not seeing anything here about generating VAT-compliant invoices here or in the documentation.

Different countries have different requirements for what must be included on the invoice and specific language to use (e.g. how a reverse-charge is supposed to be worded).

There's a great overview on this here: https://github.com/wbond/vat_moss-python/blob/master/overvie...

Related. I can't wait for [Temporal](https://github.com/tc39/proposal-temporal) - which hit Stage 3 a few months ago - to bring sanity to time in the browser. Combined with Intl, it will be much easier to build universal calendaring.

I think the major thing that will take time behind getting Temporal to Stage 4 is aligning with IETF on [a draft update RFC 3339](https://github.com/ryzokuken/draft-ryzokuken-datetime-extend...)

You can do IP to location if you deploy a Lamda@Edge and get the cloudfront headers

https://aws.amazon.com/about-aws/whats-new/2020/07/cloudfron...

Awesome! I've always thought it would be interesting to port Nand2Tetris to the web to make it more easily accessible. Glad someone finally ported the virtual computer building part!

This is a very cool project, but I'm not sure exactly what I would use it for. I could see it being useful if didn't start your project out using a tool for schema migrations and need to back reverse engineer things to create fake migrations.

I'm curious, does anyone here use it that would care to explain their use case?

I was surprised that it didn't mention graph databases either, which is pertinent to the conversation around the evolution of SQL in the article, because querying graph databases requires re-thinking (or evolving) the query language. I'm excited by the work Neo4J and AgensGraph is doing. I haven't played around with AgensGraph, but I hope it takes off since it builds on Postgres

I use await-to-js[1] to clean this stuff up. You can pair it with destructuring arrays like so:

const [err, result] = await to(funcThatReturnSomeType());

if(err) doSomethingWithErr(err);

doSomething(result);

[1] https://www.npmjs.com/package/await-to-js

I haven't used it, but I believe JIMP might work for you if you're looking for a JS solution to image manipulation

https://github.com/oliver-moran/jimp

Thanks for sharing! Looks like Jacob has open-sourced a svelte-based rich text editor based on Quill. Link below for anyone who is curious.

https://github.com/typewriter-editor/typewriter

One area where the virtual DOM seems to be important is for rich text editors, where the VDOM can basically take the input, diff it using an immutable structure, then render it to properly structured HTML.

An example use case where this would be valuable: a user hightlights text, bolds it, then highlights it again plus some more text, and bolds it. A naive approach would have: <b><b>This text is bolded</b> plus I bolded this</b> when what you want would simply be: <b>This text is bolded plus I bolded this</b>

Libraries like DraftJS and SlateJS use immutable data structures to parse the input/formatting in the VDOM and reconcile them into "blocks" (basically javascript objects containing the formatting) that deduplicate formatting.

The talk below on DraftJS is pretty good.

https://www.youtube.com/watch?v=feUYwoLhE_4

What's the recommended way to handle a rich text application in Svelte? Is there anything like the above for Svelte?

They're hard at work on Android support on SlateJS.

https://github.com/ianstormtaylor/slate/issues/2062

You have no idea how relevant this is to me at exactly this moment! About an hour ago, I found out that a competitor (a larger incumbent player) released a feature today that I had built and released 6 months ago!

I've been panicking the last couple of hours, but now it's back to the grind. I've got a lot more feature ideas in mind, and this is just that extra push to do the things I've been putting off.

You could probably say that the "goldrush" has ended. To keep the metaphor going, this is like saying you can't just walk into a river, pan for gold, and make it rich anymore. Now, it takes serious a serious amount of time and investment to do well in the self-publishing world. Is there money to be made? Heck yes! But now, it's also more costly to get it.

I'm the indie developer of a marketing tool/community (https://storyoriginapp.com/) for self-published authors like the ones mentioned in this article.

Not necessarily related to the article, but for other interested in the learning more about the self-publishing world.

Courses and training for authors on how to use Amazon ads, Facebook ads, build an email list, etc. has become incredibly easy to find. Some of the bigger names in the space are Mark Dawson, Nick Stephenson, Joanna Penn, Derek Murphy, and the 20BookTo50K community.

Authors are now essentially internet marketers who also happen to write books.

You might be interested in the video linked below on how DraftJS (which was the forerunner of SlateJS) uses the virtual DOM created by React along with contentEditable to make the same tooling work across browsers.

https://www.youtube.com/watch?v=feUYwoLhE_4