recommendable | recommendation engine using Likes and Dislikes | Recommender System library

A single query for a selector should be very, very, very fast, so I wouldn't expect this to be a problem, but it will depend a lot on the DOM you're using it in. Test your use cases to see if you find a performance problem.

I would at a minimum make it possible to specify where in the DOM to look, rather than looking through the entire thing on every change. That minimizes calls to your mutation observer, and minimizes the amount of searching it does when it's called. If a particular use case has to look through the entire thing, well, then it can use documentElement, but I'd at least make it possible to avoid that. (There's also no reason to declare element in a scope above the scope where it's actually used, and "query string" has a specific meaning in web programming that isn't what you're using it for here, so I'd just use "selector" or "selector string".)

Here's an idea of how you might do that:

What you can do is send the template earlier on as a string, compile it and store as template (in some Map). Then when a new message comes in, you just need to pass in the data to get the html content where you can then set as innerHtml to some div at your desired location.

If you need my thoughts i will say the stack may be an issue. You want to realise a reactive feeling in your application but at the expense of your api, as it continously compile those templates to send to your various clients as html.

Another bad effect to consider is those html tend to be heavy when sending to the various clients, whereares sending just the data that changed is quite light weight.

Best approach will be use a client framework that is best suited for such reactivity you need. A library/framework like React will permit you manage the events, and show new data using components available on the client. You will only need to send data concerning the event like the sender info and content.

Check out this page on handlebars website specify best suits for handlebars. https://handlebarsjs.com/installation/when-to-use-handlebars.html

It's fine, your concerns are unfounded.

WaitToReadAsync implementation comes from the UnboundedChannelReader instantiated by Unbounded channel, which implements a special awaiter that is signaled when the writer writes.

Furthermore, since this is essentially just awaited, the thread gets reused and a continuation created until the awaiter is signaled.

The implementation of channels is about as optimised and succinct as you will get. That's not to say you can't roll-your-own using whatever other synchronization primitives you like. But the chances of you getting an implementation as streamed-lined, lightweight, reusable, cached and powerful as channels would be slim.

In short, threads are being returned to the thread pool, and no extraordinary spin-blocking or polling is performed.

I like your solution as it is easy to implement. You don't actually have to manually check for duplicate uids, as firestore has a built in feature that does that for you.

Here is an example:

You can do it using split, which creates lists based on the provided function. Here I just introduced another column using the years and named them to according to your preference. Then, split the rest using only the column names.

I think you can execute the stored procedure as a batch, but you need to do this in plain jdbc:

In Unit Tests, it's all: "You're on your own", however a good way is to use the prophecy framework to inject stubs into your class.

If you don't need the objects in your test, this is totally the way to go, if you depend on them, you'd rather want to use a Functional / Integration test, where you get the Dependency Injection by the framework shipped (but for the trade-off of speed), but depends on what you want to test / what's your scope is.

Yes, you can use DRF serializer to validate the data as well as you can fill with default values.

Assume you have a serializer as follows,

In this particular case you can use the ternary conditional: