One thing I've learned from these large migration projects is that v1 always seems like total crap, while v2 appears to be the perfect dream. However, as you begin building v2, you start to realize that v1 was not actually that bad and had many great but unappreciated features. Additionally, you come to understand that many v1 features took a long time to develop, were battle-tested, and would require significant effort to rebuild in v2 with minimal benefits.
So, what I've learned is not to completely discard v1. Instead, it's better to refactor or rebuild only the parts that pose issues, even though it may not be as sexy or exciting as starting v2 from scratch.
In practice, I would begin by cloning v1 and deploying it to a development environment to start tweaking it. I would also ensure to implement numerous automated tests to safeguard against any potential issues caused by refactoring. Of course, if you can keep using the same database that's even better as you can test refactored features with real customer data and even run both builds in parallel to spot any differences.
I think I'm closer to the target audience as I usually learn either by "ear" or by watching someone play the song. Actually, what I prefer is looking/finding the chords first, and then I fill up the melody and everything in-between. So, an app like this is very helpful. My only feedback is I find the UI piano at the bottom of the screen hard to read without black keys
Ocarina of Time does a fantastic job going from the bright world of young Link to the more serious and darker world of adult Link. This adds a ton of depth to the game. And let's not forget the clever game mechanic of swapping between young and adult Link to solve puzzles.
I think the problem is how the vast majority of inbound job requests are spam or irrelevant, while at the same time there are a few gems out there that can't seem to reach the right candidates.
Personally I think it's because we're "looking" at it from the wrong angle. A bit like in programming when you're stuck and you need to take a step back and approach the problem differently. IMHO the fundamental construct is probably something way more abstract, i.e. "information", with some laws that we aren't even aware of yet that will probably challenge the principle of locality.
Seems like a lot of shit happened if you read between the lines. IMO the lessons would have been more impactful with insights into what really happened. For instance: "#1 Earn the right to build the next thing" --> A.K.A we built the wrong thing. What did you build and why didn't it work?
Still, overall great lessons. In the end, it seems like Clubhouse is more of a feature that can be added to an existing product rather than a full product by itself. That doesn't necessarily make it a failure but much harder to turn into a long-term company. Reminds me a bit of Dropbox in that sense.
My startup was acquired and it was fucking hell. Next time I get acquired I'll make sure to have everything in writing and planned for me to get out within one year.
I also was surprising to not see the solution to the cache invalidation. The blog post describes how the tracing/logging mechanism works, but what about the actual cache consistency/invalidation strategy? I.e. what about many-to-many where one fetch returns inconsistent results.. how do you even know it's inconsistent? What about data queried while there's a transaction rollback.. when is it updated in the cache?
Sorry if it sounds like silly questions, I was genuinely curious to learn about the strategy since the blog started with "When it comes to cache invalidation, we believe we now have an effective solution to bridge the gap between theory and practice"
Yeah.. in a world with infinite time and no compromise, documentations + diagrams are nice. In practice, working on this means not working on something else, potentially more important. Trade-offs are hard and not fun :(
So, what I've learned is not to completely discard v1. Instead, it's better to refactor or rebuild only the parts that pose issues, even though it may not be as sexy or exciting as starting v2 from scratch.
In practice, I would begin by cloning v1 and deploying it to a development environment to start tweaking it. I would also ensure to implement numerous automated tests to safeguard against any potential issues caused by refactoring. Of course, if you can keep using the same database that's even better as you can test refactored features with real customer data and even run both builds in parallel to spot any differences.