Hows your ability to get an enterprise to mandate their 5000 employees to use it? That's what most of these types of rounds are about.
4,905 karma · joined October 6, 2012
https://bearly.ai - LLM toolkit https://synth.app - Research browser
Email: pnegahdar@gmail, or parham@bearly.ai
Hows your ability to get an enterprise to mandate their 5000 employees to use it? That's what most of these types of rounds are about.
It could be interleaved in any of the many analytics tools in there too.
You have to trust the client in E2E encryption. There's literally no way around that. You need to trust the client's OS (and in some cases, other processes) too.
- Implement the radio as the designer sent in the figma file (e.g. something like the radix demo one they're commenting on: https://www.radix-ui.com/primitives/docs/components/radio-gr...)
- Make sure it looks the exact same across all browsers
How doable is it with vanilla css? The example they gave was rendered to a black/white circle, most teams wouldn't ship that.
This was interesting!
While I love Let's Encrypt it feels so silly to use a third party to verify I can generate a Cloudflare API key (even .well-known is effectively "can you run a webserver on said dns entry").
Edit: TIL about https://en.wikipedia.org/wiki/DNS-based_Authentication_of_Na...
In my area, an &Pizza is $12 on their App, $19 on Doordash (delivery or pickup). A Chipotle burrito is $9.50 vs $12.35 on doordash delivery (plus every addon is a $1 more expensive).
You can easily pay an extra $4/$5 (30%) per item you order on there.
Just to be clear for folks who care more about the general python around this: any class that has a method __index__ that returns an int can be used as an index for array access. e.g:
class FetchIndex:
def __index__(self):
return int(requests.get("https://indextolookup.com").text.strip())
a = ["no", "lol", "wow"]
print(a[FetchIndex()])
The builtin `int` also has a __index__ method that returns itself.Dunders are part of what makes typing in python so hard.
1) fetch calls
2) obfuscation (like sketchy lookup tables and hex string construction)
Like for (1) the hostname should be statically resolvable and immutable. So you can list the hostnames it fetches from as well.
Is this feasible or am I underestimating the difficulty? Javascript seems to have no shortage of static analysis tools.
This is true for any investment pretty much.
Hah! Says something about my self control!
Yeah it's usually trouble once a week. I recently needed to pay for parking using a QR code had to finish it in the 1 minute I had. Another appointment asked me to fill some online form and their reaction when I said "my phone is blocked from the internet" was funny. Turns out they still have paper forms when needed.
Basically in "downtime" mode all the time with a few "Always allowed" app. One thing is, you're phone (and it's browser) is pretty damn useless. Overtime you realize that a lot of things you need to lookup don't need to be looked up, etc but it can be frustrating at first.
I was recently thinking about type safety and validation strategies are particularly thorny in languages where the typings are just annotations. E.g. the Typescript/Zod or Python/Pydantic universes. Especially in IO cases where the data doesn't originate in the same type system.
In a language like Go (just an example, not endorsing) if you parse something into say a struct you know worst case you're getting that struct with all the fields set to zero, and you just have to handle the zero values. In typescript-likes you can get a totally different structure and run into all sorts of errors.
All that is to say, the runtime validation is always somewhere (perhaps in the library, as they often are?), and the feature here isn't no runtime validation but typed cli arguments. Which is cool and great.
I assumed it was to slightly correct this problem and on the surface it seems like it'd be useful for big data places where process-eventually is enough, e.g. it could be a relatively big market. Is it?
This seems to be the case in llms too. They're getting better and better (with a lot of research) at avoiding doing the bad things. I don't see why its fundamentally intractable to fence system/user/assistant/tool messages to prevent steering from non-trusted inputs, and building new fences for cases we want the steering.
Why is this piece of software particularly different?
What do you mean by this? I'd assume the process would be very very incremental. One function + accompany tests at a time, verify and continue and keep moving up the tree.
It's an interesting problem because I imagine in the future lots of things will be ported like this.