Anna

Most people see a street. He sees $300-600 per block. A 24-year-old from Chengdu figured out that every hotel, every apartment, every commercial space within walking distance is an untapped asset. One nobody has packaged yet. He straps a rig to his back, walks in, spends twenty minutes scanning the space, and leaves with a file that lets anyone on earth stand inside that room from their couch. The client pastes a link on their booking page. Guests tour the property before they arrive. Cancellations drop. Reviews go up. He gets paid $400 for the scan. $99 every month for hosting. The technology: 3D Gaussian Splatting. Free on GitHub since 2023. The app: Luma AI. Also free. The page he delivers: built by Claude in ten minutes. Total tool cost: $20/month. Month one: $3,500. Month six: $18,000. The streets haven't changed. He just started charging for them.

🧵 Day 26/30 — #SystemDesign Retries seem harmless. An API fails → retry the request. Still fails → retry again. Simple… until thousands of servers start retrying together and accidentally take the entire system down. That’s why production systems use Retry Strategies with Exponential Backoff instead of blind retries. A retry mechanism helps recover from temporary failures like: → Network instability → Timeout issues → Short server overloads → Rate limiting But retrying instantly creates traffic spikes during failures. Exponential backoff solves this by increasing delay after every failed attempt. Example: → Retry 1 → wait 1s → Retry 2 → wait 2s → Retry 3 → wait 4s → Retry 4 → wait 8s This gives systems time to recover instead of getting overwhelmed. Modern systems also add Jitter (randomness in delay) so millions of clients don’t retry at the exact same moment. Without jitter: → Retry storm → Traffic spikes → Cascading failures With jitter: → Requests spread naturally → Better recovery behavior → More stable systems That’s why companies like AWS, Google, Stripe, and Netflix heavily recommend exponential backoff patterns in distributed systems. Retries improve resilience. Uncontrolled retries destroy resilience. #30DaysOfSystemDesign #DistributedSystems #BackendEngineering

@CodeWithAmann Java + Spring and .NET are great for enterprise systems, the choice mostly depends on the ecosystem like AWS or Azure. for high-concurrency apps, I’d choose Go, Node.js, i prefer go because goroutines are fantastic.

Which backend stack has the strongest future?

Database stuff I’d study if I wanted to understand scaling deeply: Bookmark this. B+ Trees LSM Trees Write-Ahead Logging Two-Phase Commit Three-Phase Commit Read Replicas Leader-Follower Replication Partitioning Query Caching Secondary Indexes Vector Indexes (FAISS, HNSW) Distributed Joins Materialized Views Event Sourcing Change Data Capture Follow @asmah2107 to learn more on scalable system design.

今天群里面讨论怎么样学习 Harness，Harness 工程我学习这两个： 1. github.com/walkinglabs/le… 通过这个了解每一个 Harness 的核心机制 2. github.com/badlogic/pi-mo… 学习这个框架的各个模块设计实现，不懂的就让 AI 去解读实现逻辑

Most scrapers die in seconds. Blocked. Flagged. Useless. This one doesn’t. It adapts. Rotates. Fetches. Modern anti-bot systems weren’t ready for this. Fewer blocks. More data. Real advantage. github.com/D4Vinci/Scrapl…

UI/UX Designers, here are my go-to best design resource sites on the internet you should bookmark: Design Library → curations.supply Landing Pages → landing.love Saas Websites → saaspo.com AI Mobile App Builder → sleek.design/?ref=abrahambw Fonts → uncut.wtf Animation → 60fps.design Mobile Apps → mobbin.com/?via=abraham Brands → rebrand.gallery Icons → hugeicons.com/?via=Abraham Design Systems → component.gallery

Strongly recommend the LLM-as-a-Verifier writeup. Biggest takeaway for me is that increasing scoring granularity makes the verifier more effective. This indicates that LLM judges / verifiers are developing new (and better) capabilities. This did not work well 1-2 years ago. In fact, LLM-as-a-Judge best practice was that lower scoring granularity (e.g., binary, ternary, or 1-5 Likert score) worked way better than granular scores (e.g., 1-100 scale). This was a constant recommendation I gave for setting up LLM judges properly. It seems like recent frontier LLMs now are better at scoring at finer granularities, making this best practice (potentially) obsolete. One caveat to this finding is that the scoring setup used in this writeup is a specific setup based upon logprobs. Instead of just using the score token outputted by the LLM as the result, they compute the logprob of each possible score token and take a weighted average of scores (with weights given by probabilities). Then, they go further by expanding this weighted average across repeated verifications and multiple criterion: Reward = (1 / CK) * ∑_{c=1}^{C} ∑_{k=1}^{K} ∑_{g=1}^{G} score_logprob * score_value where C is the total number of evaluation criterion, K is the number of repeated verifications, and G is the scoring granularity (i.e., number of unique scoring output options). The reward determines if a particular output passes verification across criteria. When using this logprob setup, we see consistent gains in verifier accuracy by: - Increasing scoring granularity G. - Increasing repeated verifications K. - Increasing the number of evaluation criterion C. The last two findings are in line with prior work, but the fact that higher scoring granularity is helpful is interesting! In the LLM-as-a-Verifier paper, this system is used at inference time in a pairwise fashion as described below. "To pick the best trajectory among N candidates for a given task, a round-robin tournament is conducted. For every pair (i, j) the verifier produces Reward(i) and Reward(j) using the formula above. The trajectory with the higher reward receives a win, and the trajectory with the most wins across all \binom{N}{2} pairs is selected."

I just put Perplexity Computer through its paces by having it run a complete SEO audit on my site—and it honestly did the kind of work I’d usually expect from a $2,000+ agency report. No tool-hopping, no spreadsheet chaos. I fed it a single, well-structured prompt, and within seconds it came back with a full strategic teardown. Prompt: “Perform an end-to-end SEO audit of my website. Review technical SEO, on-page content, internal linking, and performance signals. Then categorize and rank issues by impact and required effort, and deliver a prioritized implementation roadmap.” 📊 What it delivered: • Technical SEO problems (crawlability/indexation, broken links) • On-page optimization misses (titles, meta, headings/content structure) • Page-by-page keyword alignment gaps • A concrete internal linking upgrade plan • A prioritized fix list (high / medium / low impact) • Clear next steps for both developers and the content team This wasn’t a pile of metrics—it read like an SEO strategy doc you could start executing immediately.

6 graph feature engineering techniques in ML: (covered with code below)

Since we open-sourced pi-autoresearch, @Shopify teams have been running it on everything. Results so far: Unit tests: 300x faster React component mounting: 20% faster CI build time: 65% reduction Made pnpm run faster Autoresearch never stops trying things you'd never have time to try. Repo: github.com/davebcn87/pi-a…

💚 Today DeskMinder is free to download on the App Store. Try it before getting Lifetime 🚀

Children are seen bothering a robot, and it fails to escape from them.

essential topics for backend engineers working with distributed systems - tcp/ip, udp socket programming - rest, grpc for service communication - kafka, rabbitmq for async messaging - concurrency in go/java (goroutines, executorservice) - thread safety and memory models - distributed databases (cassandra, mongodb) - sharding and partitioning strategies - caching patterns (redis, memcached) - consensus algorithms (raft, paxos) - distributed locks and coordination - service discovery and load balancing - circuit breakers and retry logic - distributed tracing (jaeger, zipkin) - monitoring with prometheus and grafana - oauth2, jwt for auth - ssl/tls and secure communication - rate limiting strategies - event-driven architecture (cqrs, event sourcing) - kubernetes for orchestration - cloud-native patterns - api versioning and backward compatibility start with the fundamentals, then build up to distributed patterns. most of these apply across languages and frameworks.

Java Interviewers love Singletons . Sharing 7 such Singleton interview questions that you should be prepared to answer: 1. What is double-checked locking? 2. Are enums Singleton? 3. Why do we use readResolve() in Singletons? 4. How to overcome issues with reflection and cloning in Singletons? 5. Explain the Bill Pugh Singleton Design and how it works internally. 6. How does Singleton affect garbage collection, and what are the memory management implications? 7. How would you implement a thread-safe Singleton in a multi-module application where the Singleton instance is shared across different modules, and what potential issues might arise?

Top 7 skills required for Java devs to get a job these days. Which one are you struggling with ? 1. Core Java (8–22) : Streams, records, virtual threads, collections, OOP 2. Spring Boot: REST APIs, validation, profiles, AOP, actuator, config management, devtools, custom starters, error handling. 3. Microservices: Feign/WebClient, API versioning, service discovery, config server, circuit breakers, retries, distributed tracing, API Gateway,SAGA, CQRS. 4. Spring Security : JWT, OAuth2, role-based auth 5. Hibernate/JPA : Mappings, lazy/eager, JPQL, performance tuning 6. DSA : Arrays, trees, graphs, DP, hashing 7. Concurrency : Thread pools, locks, CompletableFuture, Loom