HN user

AntonCTO

49 karma

https://www.linkedin.com/in/antonbessonov/

Posts0
Comments49
View on HN
No posts found.

Because either you have:

1. An E2E system where the provider has de facto access to the encrypted data, or

2. You shift key management to the users and let them risk data loss.

Either way:

a. The provider can release an app version at any time that accesses the data on the client side, and

b. Most of your users cannot differentiate between E2EE and SSL/TLS, nor are they interested in doing so, nor they care about it.

There isn't much information about correlation. What are the state-of-the-art tools and techniques for observability in stateful use cases?

Let's take the example of an SFU-based video conferencing app, where user devices go through multiple API calls to join a session. Now imagine a user reports that they cannot see video from another participant. How can such problems be effectively traced?

Of course, I can manually filter logs and traces by the first user, then by the second user, and look at the signaling exchange and frontend/backend errors. But are there better approaches?

Seedance 1.0 1 year ago

Photoshop requires skills. The comparison with Photoshop is absurd.

We are destroying software by believing we are right and others are wrong.

We are destroying software by being absolute.

We are destroying software by assuming we know what we are doing.

Everything is relative; every solution has its own trade-offs. This blog post is very absolute - it ignores trade-offs and sells itself as the truth.

but if they are then they *have to* give the results of their work back to the common pool they took from

Well, here we go. Your "open" isn't so open in the end.

they basically disqualified themselves from the start by nerfing the "core" version so bad it was useless

Ran the core version for around 3 years in production for a smart city project. The company I worked for has been running it for around 6 years. Not sure what you are talking about. Of course, we would love to use features like stale replicas for exports. But this isn't something we absolutely need.

At large? As you can see, there is room for a community with a different view on that. My personal definition of an "open source license" is that, as the name implies, I can access the code, preferably without much gatekeeping (e.g., creating a free account in a private GitLab instance). And, to be honest, I prefer the BSL with an Additional Use Grant over any other license, because this is the most reliable option to ensure that the project has a future and won’t be abandoned because no one wants to invest their time for free.

Some commands are used so often that it makes sense to further shorten them by placing them in `.bash_aliases` or a similar file for your favorite shell:

```

alias gs='git status'

alias gl='git log'

alias gd='git diff --color-words'

alias ga='git add'

alias gc='git commit'

```

I'd like to highlight dprint [0]. It is not as opinionated as Prettier, and its AST-node-specific configuration is awesome [1]. Deno uses it under the hood for `deno fmt` (and switched from Prettier [2]), and the TypeScript team uses it for formatting their code base (switched from formatting by ESLint [3]).

[0] https://dprint.dev/

[1] https://dprint.dev/plugins/typescript/config/

[2] https://github.com/denoland/deno/issues/3818

[3] https://github.com/microsoft/TypeScript/pull/54820

TL;DR: It is too buggy.

I tried it and ran into many issues. For example:

- Incompatibility of transpiled artifacts with the Node runtime (many bugs were fixed, but I haven't tried again). I don't trust bun as a runtime.

- Broken monorepo support.

- No direct react support; you still need react-scripts/webpack/whatever. They have documentation on transpiling react, but it isn't the same.

- No type checking, as with many other tools.

Also, filter their issue tracker for bugs: https://github.com/oven-sh/bun/issues?q=is%3Aissue+is%3Aopen...

Unfortunately, bun is unusable due to a myriad of bugs. I closely monitor every bun release, hoping it will function well beyond simple node use cases. The idea is amazing, and I would love to switch to bun, but looking at the issues - no, not yet. How can I trust bun to be a secure runtime with all these bugs?

Checked the docs after many months again:

- Workspace: check

- Bundling: check

- Minifying (server, browser): check

- Node runtime: check

- Browser runtime: check

- Loaders (assets, .node, .wasm): check

- Hot reload: check

It's probably worth trying to replace webpack + pnpm.

EDIT: Question: it is on roadmap to store downloaded file globally, like pnpm and maven do? This would be awesome!

Off-topic: Which equipment was used for the video?

Congratulations on the launch! It seems very intriguing! I have a some open questions:

- Where is the company based and what is the jurisdiction? Probably you forgot to add the imprint :o)

- Is there a difference between edge and non-edge locations?

- Can data storage be tied to a location?

- Is it tied to github or can it be used with self-hosted gitlab?

- Is there a rough ETA for databases, especially postgres(-like)?

Thanks in advance!

Bun v0.7.0 3 years ago

I don't see the limits in your ignorance. Bad names doesn't have anything in common with programming culture or aesthetic.

Bun v0.7.0 3 years ago

English isn't my first or even second language. --smol creates a lot of confusion in my head. It doesn't even make any sense. Why not --less-ram or similar?

What does UWU means? Why using an artificial language instead of established one?

Thank you for providing such a thorough and valuable explanation, along with high-quality arguments, on this topic! Your insights will be extremely helpful to HN folks and developers in their exciting projects!

RAID10 for 22TB disks with only two drives at "1" level? I would expect no less than 3 drives at such capacity. Otherwise there is a huge chance to lose the second drive while 1. changing the disc (=time, could be even days) and 2. replication.

What are your thoughts on implementing RAID 0 over four RAID 1 arrays, each consisting of three disks, resulting in a total of 12 drives?