Readit News logoReadit News
zinclozenge commented on Ursa: A leaderless, object storage–based alternative to Kafka   streamnative.io/products/... · Posted by u/netpaladinx
rohan_ · a month ago
Was the key unlock here the ability to append data to an object?

(https://aws.amazon.com/about-aws/whats-new/2024/11/amazon-s3...)

zinclozenge · a month ago
Having built a prototype of a system like Ursa myself, this isn't something that you need to use at all, especially because it seems like this is only available in S3 Express One Zone.
zinclozenge commented on Show HN: Emdash – Slack/Zoom alternative for distributed team collaboration   emdash.io/... · Posted by u/pz
mtlsnk · 7 months ago
This looks great. What is the reason for adding the https://sso.tax? Why did you make SSO an enterprise feature?

Is it due to some (technical) reason that would require a monetary compensation to be profitable?

SSO has security benefits (on top of the maintainability aspect) which would also benefit small businesses.

zinclozenge · 6 months ago
If they're offering SSO using a 3rd party provider like Auth0 then they probably have to charge for it because of how expensive it is.
zinclozenge commented on Holocron is an object storage based leader election library   github.com/kellabyte/holo... · Posted by u/tosh
zinclozenge · a year ago
I love this stuff. Seems like TektiteDB also has an implementation as well https://github.com/spirit-labs/tektite/tree/main/cluster
zinclozenge commented on Launch HN: Stack Auth (YC S24) – An Open-Source Auth0/Clerk Alternative   github.com/stack-auth/sta... · Posted by u/n2d4
n2d4 · a year ago
Everything is open-source.

We implement providers when a paying customer requests them (Team plan for OIDC-compatible providers, Growth plan for everything else, including SAML). Once we've implemented them, though, everyone benefits.

To our surprise, as of right now we haven't received any requests for SAML from our customers.

zinclozenge · a year ago
Ah gotcha, that's a nice way of approaching it. Best of luck to you guys.
zinclozenge commented on Launch HN: Stack Auth (YC S24) – An Open-Source Auth0/Clerk Alternative   github.com/stack-auth/sta... · Posted by u/n2d4
zinclozenge · a year ago
Do you guys only offer SAML in your hosted SaaS?
zinclozenge commented on Versioned finite-state machines with Postgres (2019)   raphael.medaer.me/2019/06... · Posted by u/mirzap
wchargin · a year ago
Hmm… consider the following. Your FSM is acyclic iff you can assign each state an integer depth such that a state at depth d only ever transitions to states at depths strictly greater than d. So consider the following tables:

    CREATE TABLE states (
        state order_state PRIMARY KEY,
        depth int NOT NULL,
        UNIQUE(state, depth)
    );
    CREATE TABLE transitions (
        start_state order_state NOT NULL,
        event order_event NOT NULL,
        end_state order_state NOT NULL,
        start_depth int NOT NULL,
        end_depth int NOT NULL,
        CONSTRAINT transitions_start_depth_correct
            FOREIGN KEY(start_state, start_depth) REFERENCES states(state, depth)
            ON UPDATE CASCADE,
        CONSTRAINT transitions_end_depth_correct
            FOREIGN KEY(end_state, end_depth) REFERENCES states(state, depth)
            ON UPDATE CASCADE,
        CONSTRAINT transitions_depth_increases CHECK(end_depth > start_depth),
        PRIMARY KEY(start_state, event)
    );
Let's bang on it for a quick test. You can define a state machine; here's one that roughly matches the regex `^(AB|BA)$` (I know I'm being a bit sloppy):

    fsm=> CREATE DOMAIN order_state AS text;
    CREATE DOMAIN
    fsm=> CREATE DOMAIN order_event AS text;
    CREATE DOMAIN
    fsm=> -- "CREATE TABLE"s as above, then:
    fsm=> INSERT INTO states(state, depth) VALUES('start', 1), ('a', 2), ('b', 2), ('done', 3), ('error', 3);
    INSERT 0 5
    fsm=> INSERT INTO transitions(start_state, event, end_state, start_depth, end_depth) VALUES('start', 'A', 'a', 1, 2), ('start', 'B', 'b', 1, 2), ('a', 'B', 'done', 2, 3), ('b', 'A', 'done', 2, 3), ('a', 'A', 'error', 2, 3), ('b', 'B', 'error', 2, 3);
    INSERT 0 6
And, as you need to modify it, you can increase a node's depth to make room for intervening nodes:

    fsm=> UPDATE states SET depth = 4 WHERE state = 'error';
    UPDATE 1
    fsm=> TABLE transitions;
     start_state | event | end_state | start_depth | end_depth 
    -------------+-------+-----------+-------------+-----------
     start       | A     | a         |           1 |         2
     start       | B     | b         |           1 |         2
     a           | B     | done      |           2 |         3
     b           | A     | done      |           2 |         3
     a           | A     | error     |           2 |         4
     b           | B     | error     |           2 |         4
    (6 rows)
But you can't decrease a node's depth too far:

    fsm=> UPDATE states SET depth = 2 WHERE state = 'error';
    ERROR:  new row for relation "transitions" violates check constraint "transitions_depth_increases"
    DETAIL:  Failing row contains (a, A, error, 2, 2).
    CONTEXT:  SQL statement "UPDATE ONLY "public"."transitions" SET "end_state" = $1, "end_depth" = $2 WHERE $3::pg_catalog.text OPERATOR(pg_catalog.=) "end_state"::pg_catalog.text AND $4 OPERATOR(pg_catalog.=) "end_depth""
And you can't introduce transitions that don't increase depth:

    fsm=> INSERT INTO transitions(start_state, event, end_state, start_depth, end_depth) VALUES('done', 'AGAIN!', 'start', 3, 1);
    ERROR:  new row for relation "transitions" violates check constraint "transitions_depth_increases"
    DETAIL:  Failing row contains (done, AGAIN!, start, 3, 1).
Now, I don't know that I would immediately recommend this for high-throughput production use. You're storing "unnecessary" state not once but many times (each state's depth appears `1 + \deg(v)` times), plus additional indices and lookups. But I do think it meets the desired consistency goals!

zinclozenge · a year ago
Amazing! I also learned about domains with your comment.
zinclozenge commented on Versioned finite-state machines with Postgres (2019)   raphael.medaer.me/2019/06... · Posted by u/mirzap
zinclozenge · a year ago
I always wondered about this, a while ago I saw a library similar to this that modeled FSMs in Postgres, and had a comment saying "todo: cycle detection". And made me wonder if it's even possible to do this.
zinclozenge commented on Show HN: Mesop – Open-source Python UI framework   google.github.io/mesop/... · Posted by u/willchen
zinclozenge · a year ago
I've seen a bunch of people recommending alternatives that are also Python based, makes me wonder if there's similar things for other languages like Go, Rust, etc
zinclozenge commented on Python Cloudflare Workers   blog.cloudflare.com/pytho... · Posted by u/jasoncartwright
zinclozenge · a year ago
I'd be curious to see a direct performance comparison between their python and JS workers. Based on my own experience with pyodide, I'd wager there might be up to a 2x performance penalty.
zinclozenge commented on Claude 3 surpasses GPT-4 on Chatbot Arena for the first time   arstechnica.com/informati... · Posted by u/rntn
suby · a year ago
For coding I've found ChatGPT4 a bit better than Claude 3 Opus because it tends to understand my intentions more and I trust it to make better suggestions for code changes.

I think Claude has better writing style, and it's refreshing not having to fight with the thing to get it to give me full code snippets. I also hate how difficult it is to get the arrow keys to scroll up or down on chatgpt.

zinclozenge · a year ago
This tends to be my experience, but mainly when it comes to areas that neither model know about. Claude 3 Opus will happily make something up, but ChatGPT4 will point out where it's lacking.

u/zinclozenge

KarmaCake day826December 18, 2016View Original