I'm relocating back to Bengaluru after some time, and I'm currently looking for a place in Koramangala.
What I'm looking for:
• Furnished studio or 1BHK, preferably 4th or 6th Block (around BBMP Park)
• Flexible 3–6 month lease
• Budget: ₹20–30k per month
• Quiet interior street, 2nd/3rd floor, good sunlight and ventilation (I work from home)
If you know of a flat opening up, a landlord renting directly, or a reliable managed/coliving option in that area, I'd appreciate a pointer, feel free to comment or message me.
@BenjDicken It would be fun to see some hands on debugging under-performative queries by reading query execution plans
-> adding indexes and see the usage of indexes to improve the time taken by query execution.
When you design a distributed system, one of the most important aspects is how you divide it into components.
But how to do it in the right way?
One pattern keeps recurring: splitting components into a control plane and a data plane.
The data plane includes any functionality on the critical path that must run for each client request. It must be highly available, fast, and scale with the number of requests. If it goes down, your users can’t get their work done. If it is slow, your users have a bad experience.
A control plane is not on the critical path. Its main job is to help the data plane do its work by managing metadata and configuration and coordinating complex, infrequent operations. Most of the time, it prioritizes consistency over availability.
An example can make things clear.
An API gateway routes external requests to internal services. That is the data plane. However, it also includes a management endpoint that lets you add, remove, and configure API keys for rate limiting. That is the control plane.
The data plane needs to handle thousands of requests per second with low latency. The control plane might only see a few configuration changes per day.
Separating the control plane from the data plane sounds good in theory, but it’s hard to do in practice.
You can read more about how to implement the pattern in the latest issue of @EngPolymathic
Performance Hints
Over the years, my colleague Sanjay Ghemawat and I have done a fair bit of diving into performance tuning of various pieces of code. We wrote an internal Performance Hints document a couple of years ago as a way of identifying some general principles and we've recently published a version of it externally.
We'd love any feedback you might have!
Read the full doc at: https://t.co/jej95g236P
I spent the last few days prompting ChatGPT to understand how its memory system actually works.
Spoiler alert: There is no RAG used
https://t.co/zxvRRP2GK8
This is great advice on choosing Startups vs BigTech.
The biggest caveat is that FAANG in your 20s often makes your skills deteriorate and your risk tolerance plummet and/or lifestyle creep enough that the golden handcuffs keep you in.
That said, very much agree tho that too many people say they're joining a "startup" and then join a unicorn+ growth co which isn't early enough to get real reward. You need to go earlier to and trust great teams.
It obviously does not generalize to everybody and the very best people can just start great companies with no experience.
kids, always remember that money has log(money) utility, not linear utility.
and almost all careers offer [10^n, 10^n+1] money, but rarely exceed some bound.
ex: quant may be the best way to make 10 million, but the worst way to make 100.
Noticing myself adopting a certain rhythm in AI-assisted coding (i.e. code I actually and professionally care about, contrast to vibe code).
1. Stuff everything relevant into context (this can take a while in big projects. If the project is small enough just stuff everything e.g. `files-to-prompt . -e ts -e tsx -e css -e md --cxml --ignore node_modules -o prompt.xml`)
2. Describe the next single, concrete incremental change we're trying to implement. Don't ask for code, ask for a few high-level approaches, pros/cons. There's almost always a few ways to do thing and the LLM's judgement is not always great. Optionally make concrete.
3. Pick one approach, ask for first draft code.
4. Review / learning phase: (Manually...) pull up all the API docs in a side browser of functions I haven't called before or I am less familiar with, ask for explanations, clarifications, changes, wind back and try a different approach.
6. Test.
7. Git commit.
Ask for suggestions on what we could implement next. Repeat.
Something like this feels more along the lines of the inner loop of AI-assisted development. The emphasis is on keeping a very tight leash on this new over-eager junior intern savant with encyclopedic knowledge of software, but who also bullshits you all the time, has an over-abundance of courage and shows little to no taste for good code. And emphasis on being slow, defensive, careful, paranoid, and on always taking the inline learning opportunity, not delegating. Many of these stages are clunky and manual and aren't made explicit or super well supported yet in existing tools. We're still very early and so much can still be done on the UI/UX of AI assisted coding.