glun

Would Altman shine within Microsoft? Seems like raising capital is his main skill set, and theres no need for that now. But from Microsofts point of view this prevents a new competitor from popping up.

It might have been a ”continue where you left off” player that always showed on the main page or something like that.

Continuing is never desirable so I always had to waste a click closing that so it wouldnt obscure part of the screen.

I tried that once, but paying changed the ui in some way that I found to be a huge degradation. Dont remember what exactly it was, but now Im using the adblocker again. Just ublock works fine btw, as long as you keep it and its filters up to date.

Your family is not the intended audience for the code. If the reviewer isn’t either, then they have no business reviewing your code.

Sure, but in those industries the users leave, the company suffers and the executives get fired. VC are attracted to moaty business models where users cant leave.

This only happens when the users are the product or its a marketplace. Most business models dont suffer from shittification. But VCs love investing in the ones that do.

This architecture completely ruins your write performance. Theres a reason double databases, one OLTP and one OLAP, is the norm.

Its also that the longer journey increases the variation in arrival time thus increasing the risk of not making the transfer.

Ive gotten some use out of ChatGPT for system design. I describe my problem, it recommends solutions, I ask follow up questions and add more context etc… Just like I would work with an actual collegue. Then in the end I still have to go to the source docs but the option space is often so large that I find this initial back and forth very helpful.

Coding tools, like Copilot, are completely useless on the other hand. I think they would need to be integrated with the compiler and the IDEs indexes to be of real value. Perhaps you would also need another network architecture than transformers to really understand the tree shaped nature of code as well.

Theyre already noticably plataeuing when it comes to coding, which similarly requires you to navigate tree structures and plan how to connect existing things together using shortest paths rather than inventing things out of thin air.

If you don't want to publish events from uncommitted transactions you'll have to first store them in a local table and then move them to the queue after the commit. But if all consumers have direct access to the database anyway...

The problem is that it should be the caller that decides which category the error falls within, but most languages forces the callee to choose.

> Theoretically, there could be a harmless person on the list that was put by an opponent to destroy them.

Thats exactly why you dont leak the list. Furthermore, making the list public increases the incitaments for adding innocents to it.

Ive been curious about that book ever since Rich Hickey recommended it but couldnt easily get my hands on a copy and kinda forgot about it. This was a great review; Im going to give it another try.

VS Code is actually pretty good at Typescript though, so I could be wrong about JS.

IntelliJ has much superior code completion even for dynamic languages such as Python and Clojure. I seem to recall having tested Javascript too, but I could be misremembering there as its been a while since I didn't use use Typescript.

Whenever I try to use something other than IntelliJ (generally VS Code) I'm always struck by how awful the code completion and auto-imports are. I really hope we can get a lightweight editor with those two functions working properly.

However, I don't see how you can do either of those features well without a lot of indexing of the codebase. And indexing is a major reason why IntelliJ so so clunky.

Looks like it might be roughly what we need. I’m going to dig a little deeper. Thank you.

Maybe 2-4 hours for a first draft and then 3-4 edits of 15-30 minutes each. Much more if I have to research the topic too.

> dull and rambling voice mail message

This is in no way a realistic study. A dull and rambling voice speaking about some random thing not related to you or your work will make people disengage. Doodling presumably keeps people from totally spacing out.

I think you ought to consider whether you should take notes at all. Notetaking is great for remembering actions that you have comitted to doing, or if you need to spread information to people who didn't participate in a meeting. Managers need to do a lot of notetaking.

However, taking notes seriously hinder your ability to engage with the material and build true understanding as you are listening, which would have helped you remember the material right away. If you are in school or are an individual contributor in a company I think you ought to stop taking notes all together.

If you need notes for future practice I would advice you to write them after the meeting/lecture. Actively recalling things from memory is the best form practice.

I've been investigating their generators for work these last two days, and their java generators produce code that doesn't even compile -- when ran on their own schema examples! Total garbage. OneOf (for the polymorphism aspect of inheritance) is the feature that breaks every single one of them.

A pair of noise cancelling headphones does wonders for minimizing distractions in an open office.

Seems like there's a lot of similarities between DOD and relational modelling (as in modelling for a RDMBS). I imagine DOD is kinda like doing batch/bulk operations in pure SQL vs using an ORM.

No I only did it that way because I couldn't get it to work with a CNAME file. However, that guide you linked is much more detailed than what I originally read so I'll give it another go. Thank you.

This also isn't thread safe, but that's not a problem if you don't run parallel tests in the same process. Using the same stateless test doubles in all tests also solves the problem. I often find myself wanting stateful test doubles though.

I think this is a very good point, but I also think good code organization can come a long way in addressing it.

In my opinion, a good test suite should contain mostly module level test[1]. You stub out interactions with other modules (if you both read and write to another module you should use a handwritten test double rather than a mock) but leave your own module mostly unchanged. Perhaps you replace some configuration (like changing the DB driver to run against an in-memory database), perhaps you replace the entire peristence layer, but that should be about it.

The points where your module interact with other modules and external systems can be isolated to a single file or package. Sometimes this means just aliasing a function or class, sometimes it means writing a proper facade. This makes it easy to figure out what needs to change when testing.

I also don't think that this is a problem that dependency injection frameworks are helpful in addressing. Looking at constructors is not much better than reading the method implementations -- you still have to look at every file in the codebase. Manual dependency injection with handwritten or generated (ala Dagger) factories does solve the problem completely though.

[1] I think proper unit tests should be reserved for functions that are computational or algorithmic in nature and complicated calculations/algorithms are rare in the domain I'm currently working in, though this would be different in other domains. You'll also always want some real system level tests, but not too many since they're darn slow.

Thank you. This warms my heart to hear. However, this is the first thing Ive written outside of isolated reddit comments. But I do have a backlog with a few articles that I have mapped out but havent gotten around to writing yet.

Author here. After posting this to reddit I realized that the original title is wrong, and poorly reflects the actual point I'm trying to make. Dependency injection is not dynamic scoping, but the latter can be used to achieve the former. I'm drafting an update to better reflect this. I'm also going to pull out reader monads and env passing into separate sections and give reader monads a better treatment in general.

1000x this.