• 0 Posts
  • 59 Comments
Joined 1 year ago
cake
Cake day: July 14th, 2023

help-circle







  • This is why I said anything built on public work, should be public goods as well.

    What if I don’t want certain people to build on my work, or to constrain the ways in which the build on it? (Non-commercial, share-alike, attribution, etc. clauses) Should I be able to?

    That’s not a good comparison. Crypto was a (bad) solution looking for a problem. GenAI already has use-cases.

    I didn’t mean to compare the technology – though there are some similar scam vectors, but that’s a different conversation.

    I meant that there was a strong contingent of crypto fans back then who were saying – correctly – that “the mainstream system is corrupt and wields legislation as a weapon against consumers”. But their proposed alternative was a system that removed all regulation, including consumer protections.

    I worry that there’s a trend in tech circles today that echoes that sentiment when it comes to AI.

    I’m also rather disappointed that a substantial group of people who I used to assume I was aligned with – pirates and open-sourcerers – turned out to only be there for the free shit and not for the ethos.

    An ethos which, to me, is something like: everyone has a right to participate in culture and be a part of the conversation, and everyone has a duty to acknowledge the work that enabled their own and do their best to be a good custodian of the upstream works.








  • It is strange and striking that climate change activists have not committed any acts of terrorism. After all, terrorism is for the individual by far the modern world’s most effective form of political action, and climate change is an issue about which people feel just as strongly as about, say, animal rights. This is especially noticeable when you bear in mind the ease of things like blowing up petrol stations, or vandalising SUVs. In cities, SUVs are loathed by everyone except the people who drive them; and in a city the size of London, a few dozen people could in a short space of time make the ownership of these cars effectively impossible, just by running keys down the side of them, at a cost to the owner of several thousand pounds a time. Say fifty people vandalising four cars each every night for a month: six thousand trashed SUVs in a month and the Chelsea tractors would soon be disappearing from our streets. So why don’t these things happen?


  • But LoSavio had opted out of the arbitration agreement and was given the option of filing an amended complaint.

    This is why it’s important to opt out of arbitration!

    Also notice the potential for fuckery in the statute of limitations here:

    the relevant statutes of limitations range from two to four years, and LoSavio sued over five years after buying the car. Under the delayed discovery rule, the limitations period begins when “the plaintiff has, or should have, inquiry notice of the cause of action.”

    But when Tesla declined to update his car’s cameras in April 2022, “LoSavio allegedly discovered that he had been misled by Tesla’s claim that his car had all the hardware needed for full automation.”

    Without that specific moment to point to, to reset the clock through delayed discovery, Tesla could just say “Yeah, we lied, but you bought the lie for 5 years, so now we’re in the clear!”


  • kibiz0r@midwest.socialtoProgrammer Humor@programming.devLet's do micro service
    link
    fedilink
    English
    arrow-up
    4
    arrow-down
    1
    ·
    edit-2
    2 months ago

    I’m talking about user interactions, not deployments.

    In a monolith with a transactional data store, you can have a nice and clean atomic state transition from one complete, valid state to the next in a single request/response.

    With a distributed system, you’ll often have scenarios where the component which receives the initial request can’t guarantee the final state of the system by the time it needs to produce a response.

    If it did, it would spend most of its effort orchestrating other components. That would couple them together and be no more useful than a monolith, just with new and exciting failure modes. So really the best it can do is tell the client “Here’s a token you can use to check back on the state of this operation later”.

    And because data is often partitioned between different services, you can end up having partially-applied state changes. This leaves the data in an otherwise-invalid state, which must be accounted for – simply because of an implementation detail, not because it’s semantically meaningful to the client.

    In operations that have irreversible or non-idempotent external side-effects, this can be especially difficult to manage. You may want to allow the client to resume from immediately before or after the side-effect if there is a failure later on. Or you may want to schedule the side-effect, from the perspective of an earlier component in the chain, so that it happens even if a middle component fails (like the equivalent of a catch or finally block).

    If you try to cut corners by representing these things as special cases where the later components send data back to earlier ones, you end up introducing cycles in the data flow of your microservices. And then you’re in for a world of hurt. It’s better if you can represent it as a finite state machine, from the perspective of some coordinator component that’s not part of the data flow itself. But that’s a ton of work.

    It complicates every service that deals with it, and it gets really messy to just manage the data stores to track the state. And if you have queues and batching and throttling and everything else, along with granular permissions… Things can break. And they can break in really horrible ways, like infinitely sending the same data to an external service because the components keep tossing an event back to each other.

    There are general patterns – like sagas, distributed transactions, and event-sourcing – which can… kind of ease this problem. But they’re fundamentally limited by the CAP Theorem. And there isn’t a universally-accepted clean way to implement them, so you’re pretty much doing it from scratch each time.

    Don’t get me wrong. Sometimes “Here’s a token to check back later” and modeling interactions as a finite state machine rather than an all-or-nothing is the right call. Some interactions should work that way. But you should build them that way on purpose, not to work around the downsides of a cool buzzword you decided to play around with.


  • kibiz0r@midwest.socialtoProgrammer Humor@programming.devLet's do micro service
    link
    fedilink
    English
    arrow-up
    11
    arrow-down
    1
    ·
    2 months ago

    Microservices can be useful, but yeah working in a codebase where every little function ends up having to make a CAP Theorem trade-off is exhausting, and creates sooo many weird UX situations.

    I’m sure tooling will mature over time to ease the pain of representing in-flight, rolling-back, undone, etc. states across an entire system, but right now it feels like doing reactive programming without observables.

    And also just… not everything needs to scale like whoa. And they can scale in different ways: queue up-front, data replication afterwards, syncing ledgers of CRDTs… Scaling in-flight operations is often the worst option. But it feels familiar, so it’s often the default choice.


  • lmao, you asked.

    I’m not a security expert, but my tech career has involved a lot of automated testing in weird scenarios, including iframe-based Facebook games and browser-based mobile apps. Automated tests face a lot of the same challenges that a malicious third-party would, so I know a little bit about how to get past them – or rather, how to deliberately create vulnerabilities (in the dev build of your system) so that your tests can get past them.

    Edit: I am curious why someone downvoted me on that one though. I can understand how my comment about the ban being dumb but TikTok also shipping a keylogger could anger people on one side or the other. But just explaining how in-app browsers revive a security problem that’s been long-solved in standalone browsers?