rekwah

This feels like Theranos loading up their board with big names.

As long as we can launch a big trash ball to knock the other trash ball away...

Now do this with DuckDB.

Asc vs Desc sort order doing a lot of lifting here.

I'm fine with forks but hard to see @jeffail's marketing/persona of Benthos forked too. It was quirky, to say the least. Difficult line to walk, forking code brings repo docs but it feels insincere reading not on the original.

Congrats on the launch! I can definitely understand the pain point; frequent plan/pricing iteration in the early days always leaves a pile of "grandfathered entitlements" that get carried around.

Two questions.

1) Entitlements seem to permeate systems in few ways (pricing pages & billing systems as you've called out) but also into feature flags systems like LaunchDarkly (my plan offers access to beta feature channel) and authorization systems (RBAC, FGA, etc). Do you see replacing those systems with your SDK or Planship is more of an integrator that helps keep them synchronized?

2) I couldn't tell from glancing through your SDK docs (might have missed it) but do you provide any audit/temporal history? If I store user events in a data warehouse (timestamp, customer_id, action_performed), can I determine a customers plan from that historical timestamp or only their current plan?

I started looking into this but DeleteObject doesn't support these conditional headers on general purpose buckets; only directory buckets (Express Zone One).

just put it there, it might be useful later

Also note that we have never mentioned anything about cardinality. Because it doesn’t matter - any field can be of any cardinality. Scuba works with raw events and doesn’t pre-aggregate anything, and so cardinality is not an issue.

This is how we end up with very large, very expensive data swamps.

Postgres wire format is indirectly getting there. Plenty of tools use that with wildly different storage engines on the other end.

A clean room implementation would likely yield different results but there appears to be some appetite for a solution.

Don't leave us hanging. Did you get a discount?! ;)

"1Password Unlocks $620M Round, Reaches $6.8B Valuation" would be my guess.

Curious if cuelang just ended up being too much of a hurdle for onboarding. I like it and have used it quite a bit but there's something about the syntax that makes it impenetrable for many.

If a selling point is run from "one file", that's quite difficult to do in python. There are things like pyinstaller but you end up shipping the entire interpreter in the bundle.

Reminds me of Zach Holman's post "Double Shipping".

https://zachholman.com/posts/double-shipping

As the author of a popular ULID implementation in python[1], the spec has no stewardship anymore. The specification repo[2] has plenty of open issues and no real guidance or communication beyond language implementation authors discussing corner cases and the gaps in the spec. The monotonic functionality is ambiguous (at best), doesn't consider distributed id generation, and is implemented differently per-language [3].

Functionally, UUIDv7 might be the _same_ but the hope would be for a more rigid specification for interoperability.

[1] https://github.com/ahawker/ulid

[2] https://github.com/ulid/spec

[3] https://github.com/ulid/spec/issues/11

We do this in the United States as well. We're still building tanks the military doesn't even want.

I know https://github.com/bytebuilders/vue-openapi-form exists but no first hand experience with it.

There's also a number of them out there that generate a form from json schema. I'm most familiar with https://github.com/formschema/native which we use/extend at https://routegy.com for microapps.

PLP. I had this for awhile (20-30-20) with the Dell U3011 back when that was a large monitor.

I have PL now with an ultra-wide but still think about trying to include a third monitor, I miss that setup.

SQLModel is a glue/shim layer for defining models that are both pydantic & SA compatible so you don't have to duplicate the effort.

This makes me of Melancholia[0] although the outcome may or may not be different (#nospoilers)

[0]https://www.imdb.com/title/tt1527186/

https://4dayweek.io/ is a job board for positions like this.

Original Show HN is https://news.ycombinator.com/item?id=26900533

Thinking of https://4dayweek.io/, perhaps?

4-day workweeks would be nice but what I really want is 50 hour weeks (2hr extra per day) with a summer vacation in June/July/August.

Let's say the typical job has 3w vacation: 40hr x (52w - 3w vacation) => 1960hr/yr

Now to get back to that same territory: 50hr x (52w - 12w vacation) => 2000hr/yr

Yes please.

Interesting concept. I could imagine a slightly modified approach being used as a learning tool for making large/complex codebases more approachable.

Want to understand how Clickhouse works? We've got this challenge with 20 stages that teaches you the concepts, using the CH codebase itself, not re-implemented in the language of your choosing. Learn the storage format & use the internal codebase classes/data structures to implement some things.

Now, the learner has a more holistic view of how the technology works and hopefully an increased likely hood of contributing back to the open source project.

You can expand this a bit to make it n-level depth (until you blow the stack).

  def tree():
    return defaultdict(tree)

  >>> t = tree()
  >>> t['a']['b']['c'] = 10
  >>> t
  defaultdict(<function tree at 0x10c40df28>, {'a': 
  defaultdict(<function tree at 0x10c40df28>, {'b': 
  defaultdict(<function tree at 0x10c40df28>, {'c': 10})})})

It's a perfectly cromulent word.

I always think about The Forever War[0] whenever the topic of extending life spans comes up.

While we don't have the jumps due to time dilation, I contemplate how the human mind would adapt to the changes of society over an even longer period of time. The societal and technological advances of the 20th century were immense. I'm assuming even more changes for the 21st (if we don't blow ourselves up). How much longer can we go before our brains revert to the "mean" and stagnate somewhere in the middle?

[0] https://en.wikipedia.org/wiki/The_Forever_War

Looks similar to ULID[0] (I am the author of a popular python implementation[1]).

It appears to have a similar constraint that two ID's generated within the same timestamp (ms, ns) have no strong guarantee of ordering. That might not be a deal breaker depending on your use case but something to consider.

* https://github.com/ulid/spec

* https://github.com/ahawker/ulid

SAFe always makes me laugh with its diagram for "lean" enterprises.

https://www.scaledagileframework.com/wp-content/uploads/2021...

I've always wanted to try implementing something like this but the fear of trying to run database migrations over thousands of databases frightens me.