rand_r

Apple has no control over your bank account and you have no control over Apple. You are both free to engage with each other or not.

The main problem with traditional stacktraces is that, while you get line numbers, local variables at every stack frame are not preserved. So unless the error is obvious like FileNotFound, you’re left guessing as to how the error happened.

While still being hella verbose and probably too much effort for most code, the upfront investment would obviate the need for adding debug print statements or dropping into a breakpoint to inspect the code after an exception.

That said, the post does feel like copium for the ridiculous verbosity in Go and re-inventing chained exceptions.

When you include SpaceX and Starlink, it’s pretty obvious he is successful beyond anything we’ve witnessed before, but people take his accomplishments for granted somehow.

The main failure case is that it’s a painful or possibly impossible to setup your own public internet server from home, but ISPs are probably happy about that and games have figured out a work-around.

If IPv6 was a project at work, it would probably get killed as not a priority.

I hope no one is recommending x.get as a general practice, because that is pretty naive.

If it’s actually possible to live in typed nirvana with Django I’ll bang my head against the wall some more.

We’re using Django 3.2 btw + FactoryBoy.

Actually there’s a number of annoyingly dynamic Python libraries out there where methods are created dynamically that it feels a bit like playing whack-a-mole. Is the situation like TypeScript where you need a MyLibrary.types.ts for each library?

Only a few posts; never really had the time after the initial batch. Would like to update it at some point.

In terms of code architecture, it drastically simplifies frontend code, and overall reduces backend code and boilerplate. It's extremely elegant and nice to use over creating custom endpoints for every use-case, but the N+1 SQL query problem is a giant thorn.

The architectural beauty of GraphQL is that you can write isolated, functional nodes that only have to know about their object type. For example, the User node only has to know how to get the user's last_login, active status, and return a reference to another node type like a profile Image.

Inside the User node, you are free to write code (e.g. Java or Python) that can compute which Image node is the right one to return. i.e. you can write:

  class UserNode:
      def get_user_profile_image() -> ImageNode:
          return some_arbitrary_function()

/r/UncleBens can claim to have developed their own thing, but not the obvious ones like /r/Apple, etc.

Even if GPs wanted to prescribe a safer painkiller, they are hamstrung by drug policy. So, they choose something that is a short term solution but has long term consequences because there are NO alternatives that aren’t a headache (i.e opioids).

- Feature Flag service, wrapping LaunchDarkly

- Remote Storage service, wrapping S3

The application code uses the simplified services, with little knowledge of the underlying providers (e.g. S3 or LaunchDarkly). The tests use a test implementation of the simplified services.

This pattern simplifies both the application code and test code and is an all-around win.

It's been a game changer personally, and made me excited about software architecture and coding.

So, yes there’s adaptations, but it’s way overrated compared to the media hype.

  for item in array:
      item.foo = bar

  for item in array:
      item.foo = item.foo * 2

  for item in array:
      my_bar_func(item.foo)

  for item in array:
      item.foo = bar

Like what in the actual fuck. How are they unable to do a simple grid properly? It’s just rectangles. The UI is there to copy from Zoom even.

Seems simple enough :)