omneity

You and I and many others, a true legend!

Great work! It would be interesting to have a side by side comparison with a plant grown without monitoring.

The “torque” of these plants is very low usually. You barely feel the pressure.

Source: My finger, unscathed after an encounter with a Dionaea.

Thanks for sharing your experience! I'm quite opinionated on this topic so buckle up :D

We avoided the fork & patch route because it's both labor intensive for a limited return on investment, and a game of catching up. Updating the forked framework is challenging on its own right, let alone porting existing customer payloads to newer versions, locking you de-facto to older versions. I did maintain a custom fork at a previous workplace that was similar in scope to Browserless[0] and I can tell you it was a real pain.

Developing your own framework (besides satisfying the obvious NIH itch) allows you to precisely control your exposure (reduce the attack surface) from a security perspective, and protects your customers from upstream decisions such as deprecations or major changes that might not be aligned with your customer requirements. I also have enough experience in this space to know exactly what we need to implement and the capabilities we want to enable. No bloat (yet)

> you will burn the user's fingerprint depending on scale

It's relative to your activity. See my other comment about scale and use cases, for personal device usage this is not an issue in practice, and users can automate several websites[1] using their personal agents without worrying about this. For more involved scenarios we have appropriate strategies that avoid this issue.

> we fix leaks and bugs of automation frameworks

Sounds interesting! I'd love to read a write up, or PRs if you have contributed something upstream.

0: https://www.browserless.io/

1: https://herd.garden/trails

That's super cool, thank you for sharing! It's based on playwright though right? Can you verify if the approach you are using is also subject to the bug in TFA?

My original point was not necessarily about bypassing anti-bot protections, and rather to offer a different branch of browser automation independent of incumbent solutions such as Puppeteer, Selenium and others, which we believe are not made for this purpose, and has many limitations as TFA mentions, requiring way too many workarounds as your solution illustrates.

Thanks, that's so true! We learned this the hard way building Monitoro[0] and large data scraping pipelines in the past, so we had the opportunity to build up the required muscle.

One thing to note, there are different "tiers" of websites, each requiring different counter-measures. Not everyone is pursuing the high competition websites, and most importantly as we learned in several cases scraping is fully consensual or within the rights of the user. For example:

* Many of our users scrape their own websites to send notifications to their discord community. It's a super easy way to create alerts without code.

* Sometimes users are locked in their own providers, for example some companies have years of job posting information in their ATS they cannot get out. We do help with that.

* Public data websites who are underutilized precisely because the data is difficult to access. We help make that data operational and actionable. We had for example a sailor setup alerts on buoys to stay safe in high waters. A random example[1]

0: https://monitoro.co

1: https://wavenet.cefas.co.uk/details/312/EXT

Thank you for the question! It depends on the scale you're operating at.

1. For individual use (or company use but each user is on their device) typically the traffic is drown out in regular user activity since we use the same browser and no particular measure is needed, it just works. We have options for power users.

2. For large scale use, we offer tailored solutions depending on the anti-bot measures encountered. Part of it is to emulate #1.

3. We don't deal with "blackhat bots", so we don't offer support to work around legitimate anti-bot measures such as social spambots etc.

This is reminding me a lot of shoes.rb (in a good way)

Awesome work!

"Real neurons" but whose neurons are they sourcing? And are all neurons born equal? Should we have a NeuronArena where people submit samples for eval?

@dang, agreed that the product cannot be discussed on technical merits as of now, but I suggest some of the ancillary topics (irrelevant of their technical implementation) such as neuron sourcing might be worth opening.

Very interesting approach, congrats on your release!

Have you noticed any practical performance overhead related to the usage of Proxy objects? Granted, that might not be the area of focus you have in mind for Aberdeen. I'm just asking as I mused on a similar idea some time ago and always felt hindered by this point.

My second question is related to composition and reactivity (computed fields and other transformations happening _outside_ the components). Do you see any particular pattern working well with Aberdeen?

Trade. Phoenicians set up trade posts and like their descendants - the Carthaginians, developed a large trading network over the mediterranean sea.

> This seems difficult to square with your claim that Ocado "just copied AutoStore".

I just looked at videos of the two technologies and it seems difficult to ignore the relationship.

Perhaps this is a case of "technically correct", i.e. that they technically did not infringe the patents, but that in practice they leveraged as much as they could around the patent claims?

Warehouses is definitely not where I expected robots with retractable blades to first appear.

The demo video: https://www.youtube.com/watch?v=oWXco05eK28

I don't systematically pick one or the other location for these guards, but wouldn't it make more sense to have it in one place, the function itself, both for DRY and to ensure it being checked, rather than on every call site?

Such a requirement "oh yeah always guard your arguments for calls against this function for the "same" thing your compiler is doing anyway" shouldn't be implicit and duplicated everywhere if it's always meant to be fulfilled.

> The strictness even allows us to remove the if check inside the function, since now TypeScript gives us the compile-time guarantee that obj will always have property key.

This is a dangerous suggestion. While the author does acknowledge it is a compile-time guarantee only, that doesn’t imply it is safe to remove the if inside the function.

An API call, reading a file, calling less well-behaved libraries or making some system calls can all result in objects that pass compile-time checks but will cause a runtime exception or unexpected behavior.

As for the thesis of TFA itself, it sounds quite reasonable. In fact a high “level” of typing can give a false sense of security as that doesn’t necessarily translate automatically to more stable applications.

"And as a bonus we'll have the first pick on every little thing your citizens are thinking about."

It's probably subjective to your own use, but for me Gemma3 is not particularly usable (i.e. not competitive or delivering a particular value for me to make use of it).

Qwen 2.5 14B blows Gemma 27B out of the water for my use. Qwen 2.5 3B is also very competitive. The 3 series is even more interesting with the 0.6B model actually useful for basic tasks and not just a curiosity.

Where I find Qwen relatively lackluster is its complete lack of personality.

Related: For those who want to build their own AI search for free and connect it to any model they want, I created a browser MCP that interfaces with major public search engines [0], a SERP MCP if you want, with support for multiple pages of results.

The rate limits of the upstream engines are fine for personal use, and the benefit is it uses the same browser you do, so results are customized to your search habits out-of-the-box (or you could use a blank browser profile).

0: https://herd.garden/trails/@omneity/serp

> Need local stuff? Llama(maybe Gemma)

You probably want to replace Llama with Qwen in there. And Gemma is not even close.

> Mistral has been consistently last place, or at least last place among ChatGPT, Claude, Llama, and Gemini/Gemma.

Mistral held for a long time the position of "workhorse open-weights base model" and nothing precludes them from taking it again with some smart positioning.

They might not currently be leading a category, but as an outside observer I could see them (like Cohere) actively trying to find innovative business models to survive, reach PMF and keep the dream going, and I find that very laudable. I expect them to experiment a lot during this phase, and that probably means not doubling down on any particular niche until they find a strong signal.

Haxe is not just an experiment. It is a mature language and ecosystem used in production. You will find it powering many games for example.

I used it a long long time ago on one of my first freelance gigs (with a PHP target). It was already quite solid and saved me the need to use a PHP framework.

I also remember using it as a typed javascript pre-compiler, at a time where FB Flow and MS Typescript were still fighting over developer mindshare. I would probably still use it if TS didn't take over the ecosystem entirely.

https://haxe.org/use-cases/who-uses-haxe.html

Well it can be a good learning experience for OP, that's reason enough. By the way, I use CyberChef occasionally and I love it, strongly recommended!

Little did I know. Thanks!

The idea is great but its personality needs some more sass. And maybe some contextual cues just so that it does the exact opposite of what would have been most helpful then :)

I feel like a text editor + clippy would be an even more potent combo! After all, that was clippy's original context.

International operations? Is DoorDash entering new markets?

No idea about SOTA but naively it doesn't seem like a very difficult problem:

- Ensure all TLA+ specs produced have the same inputs/outputs (domains, mostly a prompting problem and can solved with retries)

- That all TLA+ produce the same outputs for the same inputs (making them functionally equivalent in practice, might be computationally intensive)

Of course that assumes your input domains are countable but it's probably okay to sample from large ranges for a certain "level" of equivalence.

EDIT: Not sure how that will work with non-determinism though.

A fascinating thought. But then who verifies that the TLA+ specification does indeed match the human specification?

I’m guessing using an LLM as a translator narrows the gap, and better LLMs will make it narrower eventually, but is there a way to quantify this? For example how would it compare to a human translating the spec into TLA+?

I always found Kufi to be a form of space-filling curves[0], which was the original purpose: a form of decoration that can fill a surface such as edges around a building[1, 2], without depicting humans in stone, a form of art historically forbidden in Islam due the prevalence of statue idolatry at the time. Hence the prevalence of geometry (Zellij [3]) and calligraphy in areas historically islamic.

Hilbert curves [4] could be the substrate (the coordinate system), and Kufi writing could be indeed encoded information maybe by XORing each point between the curve and the kufi word.

I'm just blabbering around. But it's difficult to disassociate the two in my mind.

0: https://www.shutterstock.com/image-vector/kufi-ayat-kursi-al...

1: https://i0.wp.com/majnouna.com/wordpress/wp-content/uploads/...

2: https://i.pinimg.com/236x/f2/f7/e9/f2f7e99d6bfe75042313adbe6...

3: https://zellige.info/

4: https://www.researchgate.net/profile/Christoph-Schierz/publi...

Worth noting that Kufi writing originates from the region of Kufa in modern-day Iraq, also the source of the Kufiyyeh headdress.

https://en.wikipedia.org/wiki/Kufa

Interesting. Maybe a new product line will come out of this.

Serverless in the context of Postgres means to decouple storage and compute, so you could scale compute "infinitely" without setting up replica servers. This is what Neon offers, where you can just keep hitting their endpoints with your pg client and it should just take whatever load (in principle) and bill you per request.

Supabase gives you a server that runs classic Postgres in a process. Scaling in this scenario means you increase your server's capacity, with a potential downtime while the upgrade is happening.

You are confusing _managed_ Postgres for _serverless_.

Others in the serverless Postgres space:

- https://www.orioledb.com/ (pg extension)

- https://www.thenile.dev/ (pg "distribution")

- https://www.yugabyte.com/ (not emphasizing serverless but their architecture would allow for it)