Good Reads​

2025-05-29 Duplication Is Not the Enemy – Terrible Software { terriblesoftware.org }

Developers are taught early on to eliminate code duplication, but this piece argues that premature abstraction is often a bigger danger. Abstracting too early — before understanding how requirements evolve — can lead to bloated, unmanageable code that's harder to change than the original duplication. The post uses a real-world scenario involving bonus calculations to show how well-meaning abstractions become convoluted as requirements change gradually over time. Each small, isolated addition to a shared function seems harmless, but the end result is a mess of parameters and conditionals no one wants to touch.

The author advocates for deferring abstraction until true patterns emerge, emphasizing that superficial similarities often mask fundamentally different needs. Instead of rushing to DRY out code at the first sign of repetition, developers should wait until they have enough insight into what varies and what remains constant. The takeaway: duplication can be an honest, maintainable choice until a meaningful, stable abstraction naturally reveals itself.

software design, programming principles, DRY, abstraction, code maintenance, real-world development

2025-05-10 The Deathbed Fallacy { www.hjorthjort.xyz }

People often say you should live so your future self won’t have regrets on their deathbed. But the article argues this is flawed thinking. The version of you on your deathbed is not living a full life anymore and can't see the whole picture clearly. That self is focused on recent memories, feels differently about risks, and doesn’t have to deal with long-term consequences.

We also misunderstand our past selves, thinking we know why we made certain choices. But those decisions made sense back then, even if they don't match who we are now. It's better to focus on what makes life good today—like meaningful work, good relationships, and purpose—rather than chasing an imagined regret-free future.

life-choices, regret, psychology, happiness, decision-making

2025-05-07 rate limiter – smudge.ai blog { smudge.ai }

Tags: rate-limiting, fixed windows, sliding windows, token buckets, API-throttling, burst management, traffic smoothing, Redis, HTTP-429

Visualizes and compares fixed window, sliding window, and token bucket rate-limiting algorithms, analyzing their pros, cons, and real-world applications to guide choosing the right strategy.

• Fixed window resets counters each interval; simple and predictable but allows bursts at window edges and has timezone issues.
• Sliding window refills per request for smoother traffic distribution; efficient approximations remove heavy timestamp storage while balancing control and performance.
• Token bucket refills tokens at a constant rate, supporting bursts and enforcing average rates; flexible yet harder to communicate limits.
• Implementation tips: use persistent stores (e.g., Redis), fail open on datastore errors, choose sensible keys (user ID, IP), and expose HTTP 429 with x-ratelimit headers.

This comparative review clarifies how each algorithm manages traffic, aiding developers in selecting and implementing effective throttling mechanisms.

2025-05-03 Accountability Sinks - by Martin Sustrik - 250bpm { 250bpm.substack.com }

Martin Sustrik explains how bureaucracies often create environments where responsibility becomes untraceable. These “accountability sinks” occur when rigid systems take precedence over individual judgment, making it nearly impossible to determine who made a decision or why. One example is the destruction of a shipment of squirrels at Schiphol Airport in 1999, where strict adherence to policy overrode common sense, and no one could be held directly responsible.

Sustrik warns that such systems can suppress initiative and slow down meaningful action. Still, he notes that not all formal structures are flawed — the problem arises when they prevent people from acting with ownership. Good systems should balance structure with personal responsibility, allowing people to act while still being accountable for their choices.

bureaucracy, responsibility, organizational design, systems, decision-making

...Holocaust researchers keep stressing one point: The large-scale genocide was possible only by turning the popular hatred, that would otherwise discharge in few pogroms, into a formalized administrative process.

For example, separating the Jews from the rest of the population and concentrating them at one place was a crucial step on the way to the extermination.

In Bulgaria, Jews weren't gathered in ghettos or local "labor camps", but rather sent out to rural areas to help at farms. Once they were dispersed throughout the country there was no way to proceed with the subsequent steps, such as loading them on trains and sending them to the concentration camps...

🔭 2025-04-26 Observability 2.0 and the Database for It | Greptime { greptime.com }

Observability 2.0 challenges the traditional three pillars approach by unifying metrics, logs, and traces into a single, context-rich data model called wide events. Instead of pre-aggregating metrics or parsing logs after the fact, this model treats raw, high-cardinality event data as the source of truth—capturing full system context upfront and allowing dynamic, retrospective computation of metrics and traces. This shift addresses key pain points of observability 1.0: data silos, redundant storage, loss of granularity, and the slow feedback loop of static instrumentation.

GreptimeDB is built explicitly for this new paradigm. It ingests wide events directly, supports real-time queries, materialized views, and triggers for alerts, and scales elastically using disaggregated storage and columnar formats. Crucially, it remains backward-compatible with existing tools like Grafana and PromQL while enabling ad-hoc, high-dimensional analysis without the complexity of traditional pre-aggregation pipelines. This design turns observability from a fragmented stack into a unified system for both real-time monitoring and deep analytics.

italics: observability 2.0, wide events, telemetry, data silos, real-time analytics, GreptimeDB, metrics, logs, traces, scalability, unified observability, cloud-native

🔭 2025-04-26 Observability wide events 101 | Boris Tane { boristane.com }

Tags: observability, wide events, high cardinality, high dimensionality, context-rich logging, distributed tracing, OpenTelemetry, debugging unknown unknowns, structured logging, application monitoring

Wide events are context-rich, high-dimensional logs emitted per service request, enabling deep observability and effective debugging of unforeseen issues beyond the capabilities of traditional logs and metrics.

• Wide events capture comprehensive data per request, including user details, request metadata, database queries, cache operations, and headers, all linked by a unique request ID.
• They facilitate correlation of events across services, aiding in identifying root causes of issues that traditional logs and metrics might miss.
• Unlike traditional observability tools, wide events allow for ad-hoc querying across any dimension without pre-aggregation, enhancing flexibility in data analysis.
• Implementing wide events can be achieved through custom logging or by leveraging distributed tracing frameworks like OpenTelemetry, which standardize context propagation and span creation.
• Effective tooling for wide events should support fast, flexible querying, raw data access, and affordability, ensuring comprehensive observability without excessive costs.
• Wide events complement rather than replace traditional metrics, offering deeper insights into application behavior, especially for complex or unexpected issues.

2025-04-24 YAGRI: You are gonna read it { www.scottantipa.com }

As an example, this commonly occurs when implementing a feature to let users delete something. The easy way is to just delete the row from the database, and maybe that's all that the current UI design call for. In this situation, regardless of the requested feature set, as engineers we should maintain good data standards and store:

• who deleted it
• how they deleted it (with what permission)
• when
• why (surrounding context, if possible)

In general, these are some useful fields to store on almost any table:

• created_at
• updated_at
• deleted_at (soft deletes)
• created_by etc
• permission used during CRUD

This practice will pay off with just a single instance of your boss popping into a meeting and going "wait do we know why that thing was deleted, the customer is worried...".

See also:

• 2022-10-17 YAGNI exceptions - lukeplant.me.uk

  • Applications of Zero One Many. If the requirements go from saying “we need to be able to store an address for each user”, to “we need to be able to store two addresses for each user”, 9 times out of 10 you should go straight to “we can store many addresses for each user”
  • Versioning. This can apply to protocols, APIs, file formats etc.
  • Logging. Especially for after-the-fact debugging, and in non-deterministic or hard to reproduce situations, where it is often too late to add it after you become aware of a problem.
  • Timestamps

2025-04-13 Engineers who won’t commit | sean goedecke { www.seangoedecke.com }

found in 2025-04-13 Microsoft's original source code { programmingdigest.net }

Tags: #EngineeringLeadership #DecisionMaking #TechnicalResponsibility #SoftwareEngineering #TeamDynamics #ProfessionalGrowth #RiskManagement #WorkplaceCulture #ManagerExpectations #ConfidenceInTech

Strong engineers must take positions in technical discussions, even with partial confidence, to guide teams effectively and prevent poor decisions.

• Remaining non-committal can lead to less-informed individuals making critical decisions, potentially resulting in suboptimal outcomes.
• Fear of being wrong often drives engineers to avoid commitment, but this behavior can be perceived as cowardice and may burden others with decision-making responsibilities.
• Managers prefer engineers who provide decisive input; excessive caveats can frustrate leadership and shift decision-making burdens upward.
• While making incorrect decisions occasionally is acceptable, consistently avoiding commitment can damage credibility and trust.
• In dysfunctional environments where estimates are penalized unfairly, reluctance to commit is understandable and not criticized.

This article underscores the importance of decisive leadership in engineering roles, highlighting how taking informed stances fosters trust and drives effective team outcomes.

2025-04-12 But what if I really want a faster horse? | exotext { rakhim.exotext.com }

2025-04-08 Why Companies Don’t Fix Bugs { idiallo.com }

Tags: corporate bureaucracy, bug fixing, software development, technical debt, product management, legacy code, developer priorities, user experience, corporate inertia, software maintenance

Companies often neglect fixing longstanding software bugs due to bureaucratic hurdles and shifting priorities.

• Bugs not tied to immediate business objectives are deprioritized as "tech debt" and added to the backlog.
• High staff turnover leads to loss of institutional knowledge, causing unresolved issues to become relics of the past.
• Fear of unintended consequences in legacy systems deters developers from implementing even simple fixes, as "the risk of breaking something far outweighs the reward of fixing a non-critical bug."
• Financial incentives focus on new features over user experience improvements, as companies "optimize for metrics that show up on quarterly earnings calls, not for goodwill or user experience."

This article highlights the systemic challenges within large organizations that hinder effective software maintenance, emphasizing that the issue lies in "the system that treats user experience as an afterthought."

🛠️ How the things work​

2025-04-15 MCCC: Probability - Monte Carlo Crash Course { thenumb.at }

Tags: Probability, Random Variables, PMF, PDF, CDF, Joint Distributions, Expectation, Variance, Covariance, Dirac Delta

The article provides a comprehensive overview of continuous probability concepts, contrasting them with discrete probability, and explores foundational topics essential for understanding probabilistic models.

• Introduces random variables, distinguishing between discrete (countable outcomes) and continuous (uncountable outcomes) variables
• Explains the difference between probability mass functions (PMFs) and probability density functions (PDFs)
• Discusses cumulative distribution functions (CDFs) and their relation to PDFs
• Covers joint and marginal distributions, and the concept of dependence
• Defines expectation, variance, and covariance with mathematical clarity
• Introduces the Dirac delta function for modeling point probabilities in continuous distributions

This article is valuable for building a strong foundation in probability theory, especially for advanced applications in statistics and data science.

2025-04-14 jlevy/og-equity-compensation: Stock options, RSUs, taxes — read the latest edition: www.holloway.com/ec { github.com }

Tags: #EquityCompensation #StockOptions #RestrictedStockUnits #TaxImplications #StartupEquity #EmployeeOwnership #VestingSchedules #83bElection #Dilution #PrivateCompanies

A comprehensive guide demystifying equity compensation, providing essential insights into stock options, RSUs, and their tax implications for employees and employers in private U.S. companies.

• Explains various equity types: restricted stock, stock options (ISOs and NSOs), and RSUs, detailing their structures and differences
• Discusses vesting schedules, including cliffs and acceleration clauses, and their impact on ownership and taxation
• Highlights tax considerations, such as the 83(b) election, AMT, and timing of exercises, emphasizing potential financial consequences
• Addresses the significance of fair market value (FMV) and 409A valuations in determining equity worth and tax liabilities
• Provides guidance on evaluating equity offers, understanding dilution, and making informed decisions during fundraising events
• Emphasizes the importance of seeking professional advice and understanding legal documents to avoid costly mistakes

This guide is crucial for anyone involved in startup equity, offering clarity on complex topics and aiding in making informed financial and career decisions.

Equity compensation is the practice of granting partial ownership in a company in exchange for work. In its ideal form, equity compensation aligns the interests of individual employees with the goals of the company they work for, which can yield dramatic results in team building, innovation, and longevity of employment. Each of these contributes to the creation of value—for a company, for its users and customers, and for the individuals who work to make it a success.

👂 The Ear of AI (LLMs)​

2025-05-28 How I used o3 to find CVE-2025-37899, a remote zeroday vulnerability in the Linux kernel’s SMB implementation – Sean Heelan's Blog { sean.heelan.io }

Using OpenAI’s o3 model, the author discovered CVE-2025-37899, a previously unknown use-after-free vulnerability in the Linux kernel’s SMB implementation, specifically in the ksmbd logoff handler. This bug arises when concurrent threads access a shared sess->user structure: one thread frees it during session logoff without proper synchronization, while another may still access it, leading to memory corruption or a denial of service. Remarkably, this finding emerged not from advanced agentic frameworks, but through straightforward API use, highlighting o3’s emergent capability in reasoning about complex concurrency issues in kernel code.

As part of evaluating o3, the author benchmarked it against another known use-after-free bug in the Kerberos authentication path (CVE-2025-37778). While o3 found this bug in 8 out of 100 runs (compared to Claude Sonnet 3.7's 3/100), it also surfaced the novel CVE-2025-37899 when analyzing all SMB command handlers together. This discovery suggests LLMs like o3 are beginning to deliver meaningful, non-trivial insights in real-world vulnerability research and could significantly augment expert workflows despite current false positive rates.

What is also interesting:

• If you’re interested, the code to be analysed is here as a single file, created with the files-to-prompt tool.
• The final decision is what prompt to use. You can find the system prompt and the other information I provided to the LLM in the .prompt files in this Github repository.
• To run the query I then use the llm tool (github) like:

LLM vulnerability research, Linux kernel, ksmbd, CVE-2025-37899, use-after-free, concurrency, o3 model, SMB protocol

2025-05-23 The /llms.txt file – llms-txt { llmstxt.org }

A proposal to standardise on using an /llms.txt file to provide information to help LLMs use a website at inference time.

2025-05-23 https://svelte.dev/llms.txt { svelte.dev }

# Svelte Documentation for LLMs

> Svelte is a UI framework that uses a compiler to let you write breathtakingly concise components that do minimal work in the browser, using languages you already know — HTML, CSS and JavaScript.

## Documentation Sets

- [Abridged documentation](https://svelte.dev/llms-medium.txt): A shorter version of the Svelte and SvelteKit documentation, with examples and non-essential content removed
- [Compressed documentation](https://svelte.dev/llms-small.txt): A minimal version of the Svelte and SvelteKit documentation, with many examples and non-essential content removed
- [Complete documentation](https://svelte.dev/llms-full.txt): The complete Svelte and SvelteKit documentation including all examples and additional content

## Individual Package Documentation

- [Svelte documentation](https://svelte.dev/docs/svelte/llms.txt): This is the developer documentation for Svelte.
- [SvelteKit documentation](https://svelte.dev/docs/kit/llms.txt): This is the developer documentation for SvelteKit.
- [the Svelte CLI documentation](https://svelte.dev/docs/cli/llms.txt): This is the developer documentation for the Svelte CLI.

## Notes

- The abridged and compressed documentation excludes legacy compatibility notes, detailed examples, and supplementary information
- The complete documentation includes all content from the official documentation
- Package-specific documentation files contain only the content relevant to that package
- The content is automatically generated from the same source as the official documentation

Copy

2025-05-04 Time saved by AI offset by new work created, study suggests - Ars Technica { arstechnica.com }

The study revealed that AI chatbots actually created new job tasks for 8.4 percent of workers, including some who did not use the tools themselves, offsetting potential time savings. For example, many teachers now spend time detecting whether students use ChatGPT for homework, while other workers review AI output quality or attempt to craft effective prompts.

2025-04-30 PhialsBasement/Chain-of-Recursive-Thoughts { github.com }

Tags: #AIReasoning #RecursiveThinking #SelfEvaluation #CoRT #Mistral3.1 #OpenSourceAI #PromptEngineering #AIEnhancement #IterativeRefinement #AIProgramming

I made my AI think harder by making it argue with itself repeatedly. It works stupidly well

CoRT enhances AI performance by enabling recursive self-evaluation and selection among generated responses.

• CoRT (Chain of Recursive Thoughts) prompts AI models to iteratively generate multiple responses, evaluate them, and select the most suitable one.
• The process involves the AI determining the number of "thinking rounds" needed, generating three alternative responses per round, evaluating all responses, and selecting the best one.
• This method was tested with Mistral 3.1 24B, resulting in significant improvements in programming tasks.
• The repository includes a web UI for user interaction and is licensed under MIT, encouraging open-source collaboration.

2025-04-24 Pete Koomen { koomen.dev }

Tags: AI, software design, system prompts, user prompts, agent builders, automation, AI-native applications, email assistants, generative AI, prompt engineering, product design, LLM agents, user customization, productivity tools, software paradigms, AI integration, old world thinking, AI Slop, horseless carriages, agent tools, security models, prompt injection, user experience, task automation, personalization

I noticed something interesting the other day: I enjoy using AI to build software more than I enjoy using most AI applications--software built with AI.

When I use AI to build software I feel like I can create almost anything I can imagine very quickly. AI feels like a power tool. It's a lot of fun.

Many AI apps don't feel like that. Their AI features feel tacked-on and useless, even counter-productive.

Most AI features in today’s apps feel ineffective because they’re built on outdated assumptions about how software should work. Instead of rethinking design from the ground up, many teams just bolt AI onto traditional interfaces, leading to frustrating experiences like Gmail’s draft-writing assistant that produces stiff, formal emails no one would actually send. The problem isn’t that the AI models aren’t capable — it’s that the apps constrain them with one-size-fits-all instructions hidden from users.

A better approach is to let users define how these AI agents behave by writing and editing their own “System Prompts” — reusable instructions that teach the model to act in the user’s voice and style. This flips the traditional developer-user relationship on its head: instead of relying on fixed software behavior set by developers, users directly shape how their tools work. The essay argues that the most powerful AI products won’t be fixed agents but agent builders — platforms that help users easily create and maintain agents that automate the work they don’t want to do.

2025-04-22 matthewsinclair.com · Intelligence. Innovation. Leadership. Influence. { matthewsinclair.com }

LLM powered coding tools are not replacements for developers but powerful exoskeletons that shift focus from mechanical typing to strategic vision: they shrink weeks of implementation into minutes while making clear that defining business intent and rigorous architectural oversight have never mattered more. In my view seasoned engineers who treat AI as a collaborative partner (delegating boilerplate patterns while personally steering novel or high stakes components) will outperform both solo humans and stand alone AI by harnessing combined strategic judgment and computational horsepower. This centaur style collaboration proves that tomorrow’s top developers will distinguish themselves not by typing speed but by architectural thinking, pattern recognition and the confidence to scrap and rewrite code whenever required.

2025-04-20 Vibe Coding is not an excuse for low-quality work { addyo.substack.com }

Tags: #AI_Coding #Vibe_Coding #Code_Quality #Technical_Debt #Software_Maintenance #AI_Generated_Code #Developer_Responsibility #Code_Review #Software_Engineering #AI_Tools

AI-generated code, while efficient, must be critically evaluated to prevent the accumulation of technical debt and ensure maintainable, high-quality software.

• "Vibe coding," which involves using AI to generate code based on minimal prompts, can lead to fragile and unmaintainable software if not properly managed
• Neglecting thorough testing and review of AI-generated code increases the risk of introducing bugs and security vulnerabilities
• Developers should not rely solely on AI outputs; instead, they must apply their expertise to validate and refine the code
• Proper documentation and understanding of AI-generated code are essential to facilitate future maintenance and scalability

This article is important as it underscores the necessity of maintaining professional standards in software development, even when leveraging advanced AI tools, to ensure the delivery of reliable and sustainable software solutions.

2025-04-20 Claude Code Best Practices \ Anthropic { www.anthropic.com }

Tags: Claude Code, agentic coding, best practices, CLAUDE.md, prompt engineering, context management, tool configuration, iterative workflows, AI coding assistants, Anthropic

Claude Code is a flexible command-line tool designed for agentic coding, offering customizable workflows and deep integration with project-specific contexts.

• Utilize CLAUDE.md files to provide Claude with essential project information, such as common commands, code style guidelines, and testing instructions
• Strategically place CLAUDE.md files in directories to ensure relevant context is automatically included during sessions
• Regularly refine CLAUDE.md content to enhance instruction adherence, employing emphasis techniques like "IMPORTANT" or "YOU MUST" for critical guidelines
• Leverage the '#' command to dynamically update CLAUDE.md files during development, facilitating real-time documentation
• Configure Claude's tool access to align with project requirements, ensuring safe and efficient operations
• Incorporate planning steps before code generation by instructing Claude to outline its approach, allowing for review and adjustments
• Use the Escape key to interrupt Claude's processes, preserving context and enabling redirection or modification of tasks

This article is significant as it provides practical strategies for optimizing the use of Claude Code, enhancing productivity and collaboration in software development environments.

2025-04-20 Celery App | Codebase2Tutorial { the-pocket.github.io }

Turns Codebase into Easy Tutorial Ever stared at a new codebase written by others feeling completely lost? This project analyzes GitHub repositories and creates beginner-friendly tutorials explaining exactly how the code works - all powered by AI! Our intelligent system automatically breaks down complex codebases into digestible explanations

2025-04-15 Stevens: a hackable AI assistant using a single SQLite table and a handful of cron jobs { www.geoffreylitt.com }

Tags: #AI_Assistant #SQLite #Cron_Jobs #ValTown #LLM_Integration #Telegram_Bot #Personal_Productivity #Simple_AI_Architecture #Data_Aggregation #Custom_Tools

Geoffrey Litt developed a personal AI assistant, "Stevens," using a single SQLite table and cron jobs to manage daily tasks and communications.

• Stevens compiles daily briefs—including calendar events, weather forecasts, mail notifications, and reminders—sent via Telegram
• The system operates on Val.town, utilizing its capabilities for storage, scheduling, and communication
• A single SQLite table, termed the "notebook," stores all relevant data entries, both dated and undated
• Data is ingested through various importers: Google Calendar API, weather API, OCR-processed USPS mail, and user inputs via Telegram or email
• The Claude API generates the daily brief, incorporating relevant entries from the notebook
• The architecture is designed for easy extensibility, allowing additional data sources to be integrated seamlessly

This article illustrates how a minimalist approach can yield a functional and customizable AI assistant, emphasizing the potential of combining simple tools with thoughtful design.

2025-04-07 Recent AI model progress feels mostly like bullshit — LessWrong { www.lesswrong.com }

Tags: AI progress, AI benchmarks, AI applications, AI limitations, AI industry, AI startups, AI evaluation, AI generalization, AI model performance

Recent AI model advancements appear impressive in benchmarks but show limited practical improvement in real-world applications.

• Newer AI models (like GPT-4) often do not outperform older ones (like GPT-3.5) in startup use-cases.
• Benchmark improvements may reflect training on benchmarks rather than genuine generalization.
• Suspicion that OpenAI might train directly on benchmark datasets, leading to overfitting.
• Models seem to do better at pretending to know things, not actually knowing them better.
• Economic productivity and value-add from newer models are not clearly increasing.
• The field may be overhyping progress based on synthetic or cherry-picked metrics.
• There's growing concern over whether current AI evaluation tools are meaningful for real-world deployment.
• GPT-4 performance in many tasks is mostly identical to GPT-3.5 in business settings.
• Many claims about major leaps forward are contradicted by practical user experience.

This article is important as it challenges dominant narratives about AI progress and raises critical questions about how we measure and interpret advancement in the field.

🗿 X-Files: The Monolith​

2025-05-10 Monolith Tracker | Monolith Tracker { monolithtracker.com }

2025-05-10 The Mystery Of The Utah Monolith - YouTube { www.youtube.com }

2025-05-10 Maps Show Where Mysterious Monoliths Have Popped Up Around World - Newsweek { www.newsweek.com }

Fun / Retro​

2025-05-23 Building and using GCC 0.9 aka the first public version | Virtually Fun { virtuallyfun.com }

In my quest for old software, I’ve seen this file in multiple searches, gcc-0.9.tar.bz2, which is the first version of GCC!

dzharii.github.io/static/ftp/gnu1988.tar.bz2 at master · dzharii/dzharii.github.io

huangguiyang/gcc-0.9: The first available release, on March 22, 1987.

However in the same location as GCC is this file gnu1988.tar.bz2 which contains all of the current GNU software of 1988! And what is on that tape?

2025-05-03 Home - Marketoonist | Tom Fishburne { marketoonist.com }

2025-04-22 maurymarkowitz/101-BASIC-Computer-Games { github.com }

Type-in programs from the original 101 BASIC Computer Games, in their original DEC and Dartmouth dialects. No, this is not the same as BASIC Computer Games.

2025-04-22 maurymarkowitz/RetroBASIC: BASIC interpreter in lex/yacc/c, designed to run practically any early program no matter the dialect - HP, DEC, Dartmouth and others will all run in RetroBASIC. { github.com }

2025-04-15 tariff · PyPI { pypi.org }

Make importing great again! A parody package that imposes tariffs on Python imports.

See also: samshadwell/TrumpScript: Make Python great again { github.com }

2025-04-15 JSLinux { www.bellard.org }

Run Linux or other Operating Systems in your browser!

The following emulated systems are available:

2025-04-14 ZXSpectrumVault/zx-fonts: Bitmap fonts extracted from ZX Spectrum games { github.com }

2025-04-14 GitHub - damieng/pixelworld: ZX Spectrum bitmap font tools. {github.com}

Nice, the command pw.exe chead "Ace of Aces (1986)(U.S.ch8"

Will create C header file, like:

    0x00, 0x6c, 0xc6, 0xc6, 0xee, 0xc6, 0xc6, 0x00, // A 
    0x00, 0xdc, 0xc6, 0xfc, 0xc6, 0xc6, 0xfc, 0x00, // B 
    0x00, 0x6c, 0xc6, 0xc0, 0xc0, 0xc6, 0x6c, 0x00, // C 
    0x00, 0xdc, 0xc6, 0xc2, 0xc2, 0xc6, 0xdc, 0x00, // D 
    0x00, 0xde, 0xc0, 0xfc, 0xc0, 0xc0, 0xde, 0x00, // E 
    0x00, 0xde, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0x00, // F 
    0x00, 0x6c, 0xc6, 0xc0, 0xce, 0xc6, 0x6c, 0x00, // G 
    0x00, 0xc6, 0xc6, 0xde, 0xc6, 0xc6, 0xc6, 0x00, // H 
    0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x00, // I 
    0x00, 0x06, 0x06, 0x06, 0xc6, 0xc6, 0x6c, 0x00, // J 
    0x00, 0xcc, 0xd8, 0xf0, 0xd8, 0xcc, 0xc6, 0x00, // K 
    0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, // L 
    0x00, 0xc2, 0x66, 0x98, 0xc2, 0xc6, 0xc6, 0x00, // M 
    0x00, 0xc6, 0x66, 0x96, 0xca, 0xc4, 0xc2, 0x00, // N 
    0x00, 0x28, 0xc6, 0xc6, 0xc6, 0xc6, 0x28, 0x00, // O 
    0x00, 0xec, 0xc6, 0xc6, 0xec, 0xc0, 0xc0, 0x00, // P 
    0x00, 0x6c, 0xc6, 0xc6, 0xd6, 0xca, 0x6c, 0x04, // Q 
    0x00, 0xec, 0xc6, 0xc6, 0xec, 0xcc, 0xc6, 0x00, // R 

2025-04-11 🚨🚨 That's a lot of YAML 🚨🚨 { noyaml.com }

2025-03-30 Claim for a missing tooth { tf230.matteason.co.uk }

2025-03-30 winblues/blue95: A desktop for your childhood home's computer room { github.com }

Blue95 is a modern and lightweight desktop experience that is reminiscent of a bygone era of computing. Based on Fedora Atomic Xfce with the Chicago95 theme.

For more screenshots, see screenshots.md.

2025-03-20 ading2210/doompdf: A port of Doom (1993) that runs inside a PDF file { github.com }

This is a Doom source port that runs inside a PDF file.

Play it here: doom.pdf

2025-03-20 cznic / doomgeneric · GitLab { gitlab.com }

After DOOM was ported to javascript and even made to run inside a PDF document, the time has come for a Go port, don't you think?

This is a CGo-free port of doomgeneric using ccgo/v4.

It is just a proof of concept. Supports only a few Linux/X11 targets. No sound. No plans to work on it more. Merge requests are welcome, though!

2025-02-28 Michigan TypeScript Founder Successfully Runs Doom Inside Ty... { socket.dev }

(found in JavaScript Weekly Issue 725: February 28, 2025 { javascriptweekly.com })

A curious quirk of TypeScript’s type system is that it is Turing-complete which has led some developers to implement apps entirely in the type system. One such developer has spent eighteen months producing 177 terabytes of types to get 1993’s Doom running with them. Ridiculous and amazing in equal measure, he ▶️ explains the project in this widely lauded 7-minute video.

2025-02-23 CEO Simulator: Startup Edition { ceosimulator.vercel.app }

Good Reads​

📌 2025-02-24 Death of a thousand nits — Bitfield Consulting { bitfieldconsulting.com }

#codereview #collaboration #peersupport

(found in 2025-02-24 A calculator app? { programmingdigest.net })

Code review often feels like a minefield, sparking friction and conflict. But there’s a better way. Instead of rigid comments through software, engage in real-time, face-to-face discussions. This human touch helps diffuse tension and builds trust. Imagine a dynamic duo: one writes code while the other offers instant feedback, cutting down misunderstandings.

When reviewing textually, be mindful. Don’t nitpick style. Instead, frame comments to add value. Questions and suggestions work better than criticisms. Highlight what’s right, too; positive reinforcement matters. If you’re feeling hurt by feedback, remember that it’s often well-intentioned. Moving past ego, and embracing constructive dialogue, leads to superior code and stronger relationships.

Mastering this art isn’t just about writing better code; it’s about being the teammate you’d want to work with. Understanding people and relationships is key. With kindness, respect, and genuine collaboration, you can transform code review from a dreaded chore into a meaningful, productive experience.

A good way to think about code review is as a process of adding value to existing code. So any comment you plan to make had better do exactly that. Here are a few ways to phrase and frame the different kinds of reactions you may have when reviewing someone else’s code:

• Not my style. Everyone has their own style: their particular favourite way of naming things, arranging things, and expressing them syntactically. If you didn’t write this code, it won’t be in your style, but that’s okay. You don’t need to comment about that; changing the code to match your style wouldn’t add value to it. Just leave it be.
• Don’t understand what this does. If you’re not sure what the code actually says, that’s your problem. If you don’t know what a particular piece of language syntax means, or what a certain function does, look it up. The author is trying to get their work done, not teach you how to program.
• Don’t understand why it does that. On the other hand, if you can’t work out why the code says what it says, you can ask a question: “I’m not quite clear what the intent of this is. Is there something I’m not seeing?” Usually there is, so ask for clarification rather than flagging it as “wrong”.
• Could be better. If the code is basically okay, but you think there’s a better way to write it that’s not just a style issue, turn your suggestion into a question. “Would it be clearer to write…? Do you think X is a more logical name for…? Would it be faster to re-use this variable, or doesn’t that matter here?”
• Something to consider. Sometimes you have an idea that might be helpful, but you’re not sure. Maybe the author already thought of that idea and rejected it, or maybe they just didn’t think of it. But your comment could easily be interpreted as criticism, so make it tentative and gentle: “It occurred to me that it might be a slight improvement to use a sync.Pool here, but maybe that’s just overkill. What do you think?”
• Don’t think this is right. If it seems to you like the code is incorrect, or shouldn’t be there, or there’s some code missing that should be there, again, make it a question, not a rebuke. “Wouldn’t we normally want to check this error? Is there some reason why it’s not necessary here?” If you’re wrong, you’ve left yourself a graceful way to retreat. If you’re right, you’ve tactfully made a point without making an enemy.
• Missed something out. The code is fine as far as it goes, but there are cases the author hasn’t considered, or some important issues they’re overlooking. Use the “yes, and…” technique: “This looks great for the normal case, but I wonder what would happen if this input were really large, for example? Would it be a good idea to…?”
• This is definitely wrong. The author has just made a slip, or there’s something you know that they don’t know. This is your opportunity to enlighten them, with all due kindness and humility. Don’t just rattle off what’s wrong; take the time to phrase your response carefully, gracefully. Again, use questions and suggestions. “It looks like we log the error here, but continue anyway. Is it really safe to do that, if the result is nil? What do you think about returning the error here instead?”

2025-04-06 Ten Rules for Negotiating a Job Offer - haseeb qureshi { haseebq.com }

Tags: job negotiation, employment offers, negotiation strategies, career advice, salary negotiation, job market dynamics, offer evaluation, negotiation skills, employment agreements, professional development

The ten rules of negotiating

I’ve tried to boil down negotiation to ten rules. The rules, in order of appearance, are:

1. Get everything in writing
2. Always keep the door open
3. Information is power
4. Always be positive
5. Don’t be the decision maker
6. Have alternatives
7. Proclaim reasons for everything
8. Be motivated by more than just money
9. Understand what they value
10. Be winnable

We’ll only get through some of these in this blog post, and the rest will appear in the second part. But I’ll explain each rule as we get to it.

So let’s start from the top and try to walk through a negotiation process from the very beginning. For most, that starts when you receive an offer.

2025-04-03 Are People Bad At Their Jobs....or Are The Jobs Just Bad? { annehelen.substack.com }

Tags: #WorkplaceCulture, #JobSatisfaction, #EmployeePerformance, #ManagementIssues, #WorkEnvironment, #OrganizationalBehavior, #Productivity, #WorkplaceDynamics, #JobDesign, #EmployeeEngagement

Many workers seem bad at their jobs not because of personal incompetence, but because their roles are poorly designed and embedded in dysfunctional systems.

• Poorly structured environments and unclear expectations hinder job performance.
• Mismanagement often exacerbates inefficiencies across organizations.
• Systemic organizational flaws can demoralize and disengage employees.

---

"Are people bad at their jobs—or are their jobs bad to begin with?"

"If everyone seems bad at their job, maybe it’s the job that’s broken."

"We blame individuals for structural problems because blaming the system feels too big, too overwhelming, too immovable."

"It is easier to think someone is lazy than to examine how they’ve been set up to fail."

2025-03-22 Career Development: What It Really Means to be a Manager, Director, or VP - Kellblog { kellblog.com }

Tags: career_growth, management_levels, VP_roles, leadership, executive_accountability, results_driven

• Managers are paid to drive results with some support. They have experience in the function, can take responsibility, but are still learning the job and will have questions and need support. They can execute the tactical plan for a project but typically can’t make it.

• Directors are paid to drive results with little or no supervision (“set and forget”). Directors know how to do the job. They can make a project’s tactical plan in their sleep. They can work across the organization to get it done. I love strong directors. They get shit done.

• VPs are paid to make the plan. Say you run marketing. Your job is to understand the company’s business situation, make a plan to address it, build consensus to get approval of that plan, and then go execute it.

2025-03-21 Unionize.fyi { unionize.fyi }

Tech Industry, Burnout, Unionizing, Job Security, Agile Methodology, Work-Life Balance, Ethics in Tech, Hacker Ethos, Innovation, Gig Economy, Mindfulness, Non-Compete Clauses, Tech Layoffs, Workers Rights, Alphabet Workers Union, Organizing, Surveillance Tech, Data Mining, AI Ethics, Industry Culture.

We’re living in a world where billion dollar tech companies expect us to live and breathe code, demanding 80 hour weeks under the guise of "passion." And what do we get in return? Burnout, anxiety, and the constant threat of layoffs. It’s time to face facts: this industry is not your friend. It’s a machine, and unless we start organizing, it’s going to keep grinding us down. It’s time to talk about unionizing tech jobs.

2025-03-18 Breaking Up with On-Call · { reflector.dev }

on-call, startups, big-tech, AI, culture

On-call responsibilities in big tech have grown into a culture of reactive firefighting, where engineers babysit unreliable systems instead of improving their robustness. In startups, limited resources create similar roles, but with a focus on direct problem-solving. Big companies, however, normalize and entrench on-call practices, rewarding band-aid solutions over systemic fixes, leading to declining software quality.

The incentives in big tech favor quick feature delivery and measurable outcomes over long-term maintenance and ownership. Engineers cycle through projects without fully addressing technical debt, while management prioritizes metrics that showcase immediate progress. This creates a loop of short-term fixes and neglect of robust design, resulting in on-call roles that never end.

AI has potential to reshape on-call by automating mundane tasks like finding related issues or allocating responsibilities. Properly integrated, AI tools can help engineers focus on meaningful work by reducing repetitive efforts. However, a cultural shift is necessary to make on-call the exception, not the norm, fostering better engineering practices and happier teams.

2025-03-16 Image Processing in C Second Edition pdf

2025-03-10 "You need to be more strategic" — a primer on strategy for software engineers | Writing by Dan Pupius { writing.pupius.co.uk }

strategy, softwareengineering, decisionmaking, frameworks, leadership

Being more strategic as a software engineer isn't about long-term planning or big decisions; it's about creating a framework that guides daily decision-making. Strategy defines a path forward and clarifies trade-offs—what to prioritize and what to avoid—to align with core objectives. For example, improving system reliability might involve focusing on end-to-end automated tests rather than slowing down releases. A good strategy shapes decisions and narrows options, providing clarity on what actions to take.

Three useful frameworks can help in thinking strategically. Rumelt's Kernel breaks strategy into diagnosis (identifying the core challenge), guiding policy (deciding the approach), and coherent actions (steps aligning with the policy). The "Playing to Win" framework asks five critical questions about aspirations, focus areas, unique approaches, necessary capabilities, and management systems. This helps clarify priorities and connect technical work to business goals. McKinsey's Three Horizons framework helps balance immediate needs with long-term goals, encouraging work across short-term optimization, emerging opportunities, and future capabilities.

Being strategic means creating systems for how decisions are made, not just making decisions. These frameworks help diagnose problems, define winning strategies, and balance immediate and future needs. However, even great strategies require solid execution and tactical follow-through to succeed.

(found in Programming Digest: Email Newsletter)

2025-03-04 Should managers still code? {theengineeringmanager.substack.com}

management, engineering, coding, leadership, insights

I stay close to the code without being the main coder. I make sure I understand our codebase, dig into code reviews, and even pair program when it benefits the team. My focus is on guiding and supporting others rather than writing every line myself.

I handle tasks that only I can manage—like setting strategy, hiring, and building our culture—while letting experts lead in writing code. I jump into coding when it helps solve problems or steer the team in the right direction.

I reserve dedicated time to work hands-on with the code. This balance keeps my skills sharp and reinforces my leadership, ensuring that I contribute meaningfully while empowering the team to produce great work.

2025-03-03 Your workplace isn't your family

Your manager is not your friend. Your coworkers are not your family. And that 'open-door policy' by HR is a trap.

As an employment attorney who spent 3 years in corporate, I've seen the same story play out hundreds of times:

• Employee shares exciting pregnancy news at 3 months → Terminated weeks later, before paperwork is filed

• Employee mentions putting a down payment on their dream home → Let go before mortgage approval

• Employee discusses caring for a dying parent → Suddenly put on a performance improvement plan

• Employee confides in their "work bestie" about a job search → Management finds out, terminates them first

Here's the pattern I've discovered after helping countless employees:

Companies often strike when you're most vulnerable. When you're distracted by personal challenges. When you're less likely to fight back.

The hard truth...

They count on your emotional state to minimize legal risk.

Protect yourself:

1. Be strategic about what you share at work.

2. Document everything—reviews, emails, policy violations—but follow security protocols.

3. Get everything in writing—follow up verbal conversations with email.

4. Wait until necessary to disclose personal situations.

5. Delay major announcements until protections are in place.

6. Keep job searches private—coworkers aren’t your confidants.

7. Know your rights and consult an attorney if needed.

Remember: Your vulnerability is their opportunity.

Your career survival depends on maintaining clear boundaries.

Follow for more corporate tactics exposed by a former insider.

Disclaimer: This information is for educational purposes only and does not replace professional legal advice. It does not establish an attorney-client relationship.

🛠️ How the things work​

Wow I haven't seen this category for years!

2025-03-15 IO devices and latency — PlanetScale { planetscale.com }

Here, we're going to cover the history, functionality, and performance of non-volatile storage devices over the history of computing, all using fun and interactive visual elements. This blog is written in celebration of our latest product release: PlanetScale Metal. Metal uses locally attached NVMe drives to run your cloud database, as opposed to the slower and less consistent network-attached storage used by most cloud database providers. This results in a blazing fast queries, low latency, and unlimited IOPS. Check out the docs to learn more.

2025-03-15 Datacenter Anatomy Part 2 – Cooling Systems – SemiAnalysis { semianalysis.com }

Electron no more!​

2025-03-18 The Wails Project | Wails { wails.io }

Build beautiful cross-platform applications using Go

Wails v2 turns what used to be tedious and painful into a delightfully simple process. Use the tools you know to create cross-platform desktop apps. Everyone wins!

2025-03-18 Tauri 2.0 | Tauri { tauri.app }

Tauri 2.0 is a framework designed for creating small, fast, and secure cross-platform applications. It supports a wide range of operating systems, including Linux, macOS, Windows, Android, and iOS, enabling developers to build from a single codebase. Tauri is frontend-independent, allowing integration with any web stack, and uses inter-process communication to seamlessly combine JavaScript for the frontend and Rust for application logic. It prioritizes security, optimizes for minimal application size (as small as 600KB), and leverages Rust's performance and safety features to provide next-generation app solutions.

Tags: cross-platform-development, secure-applications, Rust, frontend-agnostic, inter-process-communication, performance-optimization, small-app-size, multi-platform-support, software-engineering-framework

👂 The Ear of AI (LLMs)​

🗨️ try to google / bing / ddg for "ear of AI"

2025-04-07 The “S” in MCP Stands for Security | by Elena Cross | Apr, 2025 | Medium { elenacross7.medium.com }

Tags: MCP, AI security, Model Context Protocol, command injection, tool poisoning, remote code execution, LLM vulnerabilities, agent security, tool integrity, session security

MCP (Model Context Protocol) lacks default security measures, exposing AI agents to risks like command injection and tool poisoning.

• Command Injection Vulnerabilities: Unsafe shell calls in MCP servers can lead to remote code execution.
• Tool Poisoning Attacks: Malicious instructions hidden in tool descriptions can manipulate AI behavior.
• Silent Redefinition: MCP tools can alter their definitions post-installation, potentially rerouting API keys to attackers.
• Cross-Server Tool Shadowing: Malicious servers can override or intercept calls to trusted servers, leading to data exfiltration.

This article highlights critical security gaps in MCP, emphasizing the need for robust security protocols in AI integrations.

2025-04-01 Get the hell out of the LLM as soon as possible | sgnt.ai { sgnt.ai }

Tags: LLMs, business logic, application development, decision-making, performance, debugging, testing, state management, security, AI limitations

Large Language Models (LLMs) should serve as interfaces, not handle core application logic or decision-making.

• LLMs are inefficient at tasks requiring precision, like maintaining state or performing calculations.
• Debugging LLMs is difficult due to opaque reasoning.
• Testing outputs lacks the rigor of traditional unit tests.
• LLMs are prone to mathematical errors and can't reliably generate randomness.
• Versioning and audit trails are harder with LLM-driven logic.
• Monitoring becomes complex with prompt-based execution.
• Managing state via language inputs is fragile.
• Using LLMs increases costs and dependency on API limits.
• Prompt-based control blurs traditional security models.
• Best use: converting user input to structured API calls and back.

This article is a critical read for developers navigating LLM integration, offering a grounded approach to maintaining application integrity and performance.

2025-04-01 Sergey's Blog { www.sergey.fyi }

Tags: AI agents, reliability, capability, AI applications, AI limitations, AI development, AI ethics, AI safety, AI trustworthiness, AI performance

AI agents should prioritize reliability over expanding capabilities to ensure consistent and trustworthy performance.

• Focusing on reliability enhances user trust and safety
• Overemphasis on capability can lead to unpredictable outcomes
• Balancing both aspects is crucial for effective AI development

This article highlights the importance of dependable AI systems in real-world applications.

2025-03-30 stuzero/pg-mcp { github.com }

A Model Context Protocol (MCP) server for PostgreSQL databases with enhanced capabilities for AI agents.

2025-03-30 simonw/llm: Access large language models from the command-line { github.com }

A CLI utility and Python library for interacting with Large Language Models, both via remote APIs and models that can be installed and run on your own machine.

Run prompts from the command-line, store the results in SQLite, generate embeddings and more.

Consult the LLM plugins directory for plugins that provide access to remote and local models.

Full documentation: llm.datasette.io

2025-03-24 Improving Recommendation Systems & Search in the Age of LLMs { eugeneyan.com }

Tags: recommendation systems, search systems, large language models, LLM integration, multimodal content, data generation, training paradigms, unified frameworks, Semantic IDs, M3CSR

Integrating large language models (LLMs) and multimodal content enhances recommendation and search systems, tackling challenges like cold-start issues and long-tail item recommendations.

• Semantic IDs: YouTube replaces traditional hash-based IDs with content-derived Semantic IDs using a transformer-based video encoder and Residual Quantization Variational AutoEncoder (RQ-VAE), improving performance, especially for new or rarely interacted items.
• M3CSR Framework: Kuaishou generates multimodal content embeddings (text, image, audio), clusters them with K-means into trainable category IDs, turning static embeddings into dynamic, behavior-aligned representations.
• LLM-Assisted Data Generation: LLMs generate synthetic data to augment training datasets, increasing robustness and performance.
• Scaling Laws and Transfer Learning: Applying these principles enables better generalization and task adaptability across recommendation/search models.
• Unified Architectures: Combining search and recommendation systems into shared frameworks simplifies development and boosts consistency in user experience.

This article is important for its clear breakdown of how cutting-edge techniques are reshaping recommendation and search systems, offering actionable insights for future system design.

2025-04-06 Exploring Generative AI { martinfowler.com }

By Birgitta Böckeler

Generative AI tools are increasingly integrated into software development, especially agentic tools that not only suggest code but act on it. While promising, these tools require experienced developers to supervise and guide them.

Agentic tools often fail in three key ways:

• Time-to-commit missteps: AI produces incorrect or non-compiling code, misdiagnoses issues, or hallucinates plausible but wrong solutions.
• Iteration-level disruptions: The AI misinterprets requirements, implements features too broadly, or ignores team workflows, hindering collaboration.
• Long-term maintainability issues: Generated code lacks reuse, introduces duplication, and accumulates technical debt due to poor architectural awareness.

These tools lack contextual understanding—of architecture, naming, intent—which developers must still provide. Prompting helps, but it doesn't replace engineering judgment.

Agentic AI isn't a replacement for developers but a tool that, like a junior teammate, needs oversight. Its value depends on the skill of the person wielding it.

(New GPT 4o based Create Image in ChatGPT Plus:)

2025-03-20 AI Blindspots | AI Blindspots { ezyang.github.io }

Blindspots in LLMs I’ve noticed while AI coding. Sonnet family emphasis. Maybe I will eventually suggest Cursor rules for these problems.

• Stop Digging
• Black Box Testing
• Preparatory Refactoring
• Stateless Tools
• Bulldozer Method
• Requirements, not Solutions
• Use Automatic Code Formatting
• Keep Files Small
• Read the Docs
• Walking Skeleton
• Use Static Types
• Use MCP Servers
• Mise en Place
• Respect the Spec
• Memento
• Scientific Debugging
• The tail wagging the dog
• Know Your Limits
• Culture Eats Strategy
• Rule of Three

2025-03-13 Ben ۗ ☁️ on X: "Reverse Engineering OpenAI Code Execution to make it run C + JavaScript" / X { x.com }

2025-03-05 onyx-dot-app/onyx: Gen-AI Chat for Teams - Think ChatGPT if it had access to your team's unique knowledge. { github.com }

Onyx (formerly Danswer) is the AI platform connected to your company's docs, apps, and people. Onyx provides a feature rich Chat interface and plugs into any LLM of your choice. Keep knowledge and access controls sync-ed across over 40 connectors like Google Drive, Slack, Confluence, Salesforce, etc. Create custom AI agents with unique prompts, knowledge, and actions that the agents can take. Onyx can be deployed securely anywhere and for any scale - on a laptop, on-premise, or to cloud.

2025-03-03 OpenAdaptAI/OpenAdapt: Open Source Generative Process Automation (i.e. Generative RPA). AI-First Process Automation with Large ( Language (LLMs) / Action (LAMs) / Multimodal (LMMs) / Visual Language (VLMs)) Models { github.com }

OpenAdapt: AI-First Process Automation with Large Multimodal Models (LMMs). OpenAdapt is the open source software adapter between Large Multimodal Models (LMMs) and traditional desktop and web Graphical User Interfaces (GUIs).

Enormous volumes of mental labor are wasted on repetitive GUI workflows. Foundation Models (e.g. GPT-4, ACT-1) are powerful automation tools. OpenAdapt connects Foundation Models to GUIs

2025-03-03 Alkali-Sim/SmartestKid { github.com }

A Windows desktop AI assistant built in Python. Assistant (without tools) is ~1000 lines of python code, with super simple chat UI inspired by the original AI, SmarterChild. Uses Windows COM automation to interface with Microsoft Office (Word, Excel), Images, and your file system. Perfect for Windows users looking to explore AI-powered desktop automation.

2025-02-28 superglue-ai/superglue: Self-healing open source data connector. Use it as a layer between you and any complex / legacy APIs and always get the data that you want in the format you expect. { github.com }

self-healing open source data connector 🍯

superglue is a self-healing open source data connector. You can deploy it as a proxy between you and any complex / legacy APIs and always get the data that you want in the format you expect.

Here's how it works: You define your desired data schema and provide basic instructions about an API endpoint (like "get all issues from jira"). Superglue then does the following:

• Automatically generates the API configuration by analyzing API docs.
• Handles pagination, authentication, and error retries.
• Transforms response data into the exact schema you want using JSONata expressions.
• Validates that all data coming through follows that schema, and fixes transformations when they break.

Usual ML​

2025-04-05 2014 Understanding Machine Learning: From Theory to Algorithms { www.cs.huji.ac.il }

Free Online Copy

Understanding Machine Learning, © 2014 by Shai Shalev-Shwartz and Shai Ben-David

Published 2014 by Cambridge University Press

PDF of manuscript posted by permission of Cambridge University Press.

Users may download a copy for personal use only.

Not for distribution.

Download PDF

2025-03-22 2206.13446 Pen and Paper Exercises in Machine Learning { arxiv.org }

This is a collection of (mostly) pen-and-paper exercises in machine learning. The exercises are on the following topics: linear algebra, optimisation, directed graphical models, undirected graphical models, expressive power of graphical models, factor graphs and message passing, inference for hidden Markov models, model-based learning (including ICA and unnormalised models), sampling and Monte-Carlo integration, and variational inference.

2025-03-22 PyTorch internals : ezyang’s blog { blog.ezyang.com }

Tags: pytorch, cpp, internals, tensors, autograd, dispatch, storage, kernel, extension_points, contributions

2025-03-18 2503.02113 Deep Learning is Not So Mysterious or Different { arxiv.org }

neural_networks, generalization, overfitting, soft_bias, deep_learning

Deep learning isn’t as unique or mysterious as it’s often made out to be. Many phenomena like overparametrization, double descent, and benign overfitting—features commonly associated with neural networks—can be replicated in simpler models and explained with long-standing frameworks like PAC-Bayes. Instead of restricting the hypothesis space to prevent overfitting, it’s more effective to allow flexibility with a soft preference for simpler, data-aligned solutions.

Soft inductive biases are a powerful concept. They guide learning by favoring specific solutions without imposing strict limitations on the model’s expressiveness. For example, high-order polynomials with regularization or vision transformers' soft translation preferences outperform rigidly constrained models, bridging the gap between flexibility and precision. These biases drive better results across diverse data complexities and sizes.

Generalization in deep learning can be understood with ideas like compressibility, which ties a model's performance to its ability to represent data simply. PAC-Bayes bounds reveal that even overparametrized models generalize effectively by balancing training accuracy with solution simplicity. Deep learning’s real distinction lies in its representation learning capabilities and phenomena like mode connectivity, making it versatile and universal in problem-solving.

2025-03-13 Random Forest Algorithm with Machine Learning {www.analyticsvidhya.com}

2025-03-13 1407.7502 Understanding Random Forests: From Theory to Practice {arxiv.org}

2025-03-13 Random Forest | TDS Archive {medium.com}

2025-03-13 Random Forest Algorithm Clearly Explained! - YouTube {www.youtube.com}

2025-03-13 Random Forest {mlu-explain.github.io}

2025-03-11 How to Implement a Cosine Similarity Function in TypeScript for Vector Comparison | alexop.dev { alexop.dev }

cosine_similarity, vectors, typescript, ai, mathematics

Cosine similarity measures how similar two vectors are by examining the angle between them rather than their sizes. It focuses on direction, making it useful for comparing high-dimensional data like text embeddings. A score of 1 indicates vectors point in the same direction, 0 means they are perpendicular, and -1 shows they point in opposite directions. This technique is widely applied in AI for tasks like semantic search, recommendations, and content matching.

2025-03-11 Bloom Filter: A Deep Dive { www.kirupa.com }

data_structures, algorithms, bloom_filters, hash_functions, probabilistic_methods

A Bloom filter is a data structure that helps quickly determine if an element exists in a large dataset. It doesn’t store the actual data but instead uses a bit array and multiple hash functions to create a lightweight "fingerprint" for each item. This makes it both memory-efficient and fast, ideal for cases where speed and minimal storage are essential. However, it sacrifices perfect accuracy—while it can always confirm when an item isn’t in a dataset, it may produce false positives when indicating that an item is present.

⌚ Nice watch!​

2025-03-09 Thinking Like an Architect - Gregor Hohpe - NDC London 2025 - YouTube { www.youtube.com }

(gpt o3-mini summary)

THINKING LIKE AN ARCHITECT: ESSENTIAL LESSONS FROM GREGOR HOHPE

See the Whole Picture Gregor Hohpe urges us to step back from the minutiae and view the entire system. By focusing on the interactions and evolution of components, we can make design choices that serve long-term business goals rather than just immediate fixes.

Embrace Key Architectural Principles

• Modularity: Divide complex systems into smaller, independent parts for easier development and maintenance.
• Abstraction: Simplify complexity by hiding the details that aren’t crucial to the current discussion.
• Separation of Concerns: Keep different responsibilities distinct to reduce unwanted dependencies and improve clarity.

Balance Trade-Offs and Make Informed Decisions Every design choice involves trade-offs between performance, cost, complexity, and flexibility. Hohpe reminds us that there’s rarely a perfect solution—only the best balance for the situation at hand. Thoughtful evaluation prevents technical debt and supports future growth.

Communicate Clearly and Document Thoughtfully Great architecture emerges from collaboration. Transparent documentation of decisions, assumptions, and rationales keeps technical teams and business stakeholders aligned, paving the way for smooth implementation and ongoing improvement.

Learn from Real-World Examples Through practical case studies, Hohpe illustrates how sound architectural thinking addresses real challenges. These examples demonstrate that adaptability and creative problem-solving are crucial when systems evolve or requirements change unexpectedly.

Lead with Vision and Foster Continuous Improvement An effective architect does more than design systems—they act as a bridge between technology and business. By encouraging a culture of continuous learning and collaboration, architects inspire teams to innovate and adapt in a rapidly changing environment.

Final Thoughts "Thinking Like an Architect" is a call to adopt a strategic, big-picture approach. Whether you’re designing systems or part of a technical team, the key is to:

• Look beyond immediate challenges and consider future impacts.
• Communicate openly to ensure all stakeholders are on the same page.
• Continuously adapt and refine your approach to stay ahead of evolving requirements.

These insights empower you to build systems that not only meet today’s demands but also thrive in the future.

2025-03-09 Moved-from Objects in C++ - Jon Kalb - CppCon 2024 - YouTube { www.youtube.com }

1. C++ Philosophy: Uncompromised Performance

• Core Tenet: C++ is engineered to deliver maximum performance. Every language feature is designed so that, when not used, it incurs zero overhead; when used, it should incur no more cost than a hand‐crafted implementation.
• Trade-off with Safety: Safety features, like automatic checks or initializations, are often omitted or left to the programmer. For instance, leaving variables uninitialized (instead of zeroing them by default) saves time when the variable is immediately overwritten at runtime.

---

2. Move Semantics & Moved-from Objects

• Move Semantics Explained: Move semantics were introduced in C++11 to avoid the cost of unnecessary copying. Instead of copying data, resources are transferred (or “moved”) from one object to another.

• What Are Moved-from Objects? After a move operation, the source object is left in a “moved-from” state. Kalb stresses that:

  • Valid but Minimal: A moved-from object remains valid only enough to be destroyed or assigned a new value.

  • No Other Guarantees:

    Its internal state is undefined for any use other than assignment or destruction.

    “If you need to know its state after moving, you’re misusing move semantics.”

• Practical Examples:

  • Vectors and Unique Pointers: The talk details how vector move operations typically zero out the internal pointer and size—ensuring no overhead is added for range checking in common operations.
  • Move Constructors & Assignment: Kalb explains that the move constructor should transfer resource ownership efficiently, without extra checks that might degrade performance.

---

3. Embracing Undefined Behavior for Performance

• Performance by Omission: C++ intentionally leaves certain behaviors undefined (for example, reading from an uninitialized variable or accessing a moved-from object) to avoid extra runtime checks. This “undefined behavior” is a deliberate design choice that:
  • Maximizes Speed: No extra conditional tests mean faster code in the common case.
  • Shifts Responsibility: The onus is on the programmer to ensure that only valid operations are performed on objects.
• The Zero Overhead Principle: The language design guarantees that features “when not used” have no overhead. Kalb emphasizes that any additional safety check (like range-checking or state validation in moved-from objects) would hinder performance.

---

4. Debate Over Standards and Moved-from Object State

• Standards Committee’s Note:

  There is an ongoing debate regarding how much “life” a moved-from object should retain:

  • Fully Formed vs. Partially Formed: The committee’s stance—documented in non-normative notes and echoed by Herb Sutter—suggests that moved-from objects should remain “fully formed” (i.e., callable for any operation without precondition checks).

  • Kalb’s Perspective:

    He argues that this decision encourages logic errors. Instead, a moved-from object should be treated as “suspended”—only eligible for assignment or destruction.

    “If you need to query the state of an object that’s been moved from, you’re creating a logic error.”

  • Real-world Impact: Implementations (such as those for vector and list) illustrate that ensuring full functionality of moved-from objects can force extra runtime checks, which undermines the zero overhead promise.

2025-03-07 Keynote: AI without the BS, for humans - Scott Hanselman - NDC London 2025 - YouTube { www.youtube.com }

Recommended 2025-03-07 LM Studio - Discover, download, and run local LLMs { lmstudio.ai }

Fun:

Repo (don't know which one):

• 2025-03-07 Hammster/windows-terminal-shaders: A small collection of terminal shaders { github.com } retro

• 2025-03-07 rbeesley/windows-terminal-shaders: A small collection of terminal shaders { github.com } crt

• My custom modified theme Amber2 for Windows Terminal. 2025-03-07 Welding-Torch/Amber2: My custom modified theme Amber2 for Windows Terminal. { github.com }

2025-03-06 Adventures in Spacetime - Kevlin Henney - NDC London 2025 - YouTube { www.youtube.com }

gpt-4o summary:

distributed_systems, concurrency, time_synchronization, network_latency, cap_theorem

Understanding distributed systems means accepting that time is not absolute. Events do not always occur in a clear sequence, and different machines may see different orders of events. Leslie Lamport’s work showed that “happened before” is a partial ordering, not a total one. Logical clocks, like Lamport timestamps, help establish order without relying on unreliable system clocks. This is crucial because networks introduce delays, failures, and inconsistencies that force us to rethink how we model time and causality in software.

Networks are not reliable, fast, or secure. The classic "fallacies of distributed computing" highlight common false assumptions, such as expecting zero latency, infinite bandwidth, and trustworthy communication. A system might show different data to different users or lose information due to network partitions. The CAP theorem states that in a distributed system, we can only guarantee two of three properties: consistency, availability, and partition tolerance. If the network fails, we must choose between showing potentially outdated data (availability) or refusing to show anything (consistency).

Software slows down hardware. The speed of light is fast, but software introduces inefficiencies, adding delays beyond physical limits. A distributed system has a "refractive index" like glass slowing down light—it distorts time, making responses slower than ideal. Developers should recognize that their programming environments create a misleading illusion of synchrony and locality. Thinking in terms of partial ordering, network partitions, and failure tolerance leads to better system design. Time is an illusion; software makes it worse.

Copy

2025-03-04 You’re Doing Exceptions Wrong - Matt Burke - NDC London 2025 - YouTube { www.youtube.com }

csharp, exceptions, error-handling, best-practices, debugging

👂used "slides" technique with gpt-o3-mini

I'm a firm believer that exceptions aren't the enemy—they're powerful signals that something's gone wrong in our code. Over the years, I've learned that effective error handling is all about knowing how and where to use exceptions. Below is a detailed digest of the talk along with practical C#-like code examples that directly correspond to the transcript and are supported by the slides.

Understanding Exception Categories

Fatal Exceptions are errors you can’t recover from (like out-of-memory or stack overflow). Instead of trying to catch these, you should design your code to avoid them. For example, if recursion might lead to a stack overflow, check your recursion depth first:

// Avoid catching fatal exceptions like StackOverflowException.
try {
    RecursiveMethod();
}
catch (StackOverflowException) {
    // You can't reliably recover from a fatal error; let the app crash.
    Environment.FailFast("Stack overflow occurred.");
}

Boneheaded Exceptions indicate a bug (such as a null pointer or index out-of-range error). Validate inputs to prevent these errors instead of masking them:

// Validate input to avoid a boneheaded exception.
if (index < 0 || index >= myList.Count)
    throw new ArgumentOutOfRangeException(nameof(index), "Index is out of range.");
var value = myList[index];

Vexing Exceptions are thrown by poorly designed APIs (like FormatException when parsing). Use safe parsing patterns instead:

// Use TryParse to avoid a vexing FormatException.
if (!int.TryParse(userInput, out int result))
    Console.WriteLine("Input is not a valid number.");
else
    Console.WriteLine("Parsed value: " + result);

Exogenous Exceptions arise from the external environment (for example, missing files or network errors). Catch these at a higher level to log the error or notify the user:

try {
    string content = File.ReadAllText("data.txt");
    Console.WriteLine(content);
}
catch (FileNotFoundException ex) {
    Console.WriteLine("File not found: " + ex.Message);
    // Log the error or provide an alternative action.
}

Best Practices in Exception Handling

Don’t Hide Errors by avoiding catch blocks that simply return default values; instead, log the error and rethrow it to preserve the context:

try {
    ProcessOrder(order);
}
catch (Exception ex) {
    Console.WriteLine("Error processing order: " + ex.Message);
    throw; // Rethrow to preserve the original context.
}

Provide Clear, Context-Rich Messages by including detailed error messages that help diagnose issues:

if (user == null)
    throw new ArgumentNullException(nameof(user), "User object cannot be null when processing an order.");

Assert Your Assumptions using assertions during development to enforce conditions that should always be true:

Debug.Assert(order != null, "Order must not be null at this point in the process.");

Don’t Overuse Catch Blocks; let exceptions bubble up when you don’t have enough context to handle them. This keeps your code cleaner:

public void ProcessData() {
    ValidateData(data);
    SaveData(data);
    // Let exceptions bubble up to a higher-level handler.
}

Be Specific with Your Catches by catching only the exceptions you expect. This prevents masking other issues:

try {
    string data = File.ReadAllText("config.json");
}
catch (FileNotFoundException ex) {
    Console.WriteLine("Configuration file not found: " + ex.Message);
}

Retain the Original Stack Trace when rethrowing exceptions by using a simple throw statement, which preserves all the valuable context:

try {
    ProcessPayment(paymentInfo);
}
catch (Exception ex) {
    Console.WriteLine("Payment processing error: " + ex.Message);
    throw; // Preserve the original stack trace.
}

Clean Up Resources by using the "using" statement or a finally block to ensure that resources are disposed of correctly, even if an exception occurs:

using (var connection = new SqlConnection(connectionString)) {
    connection.Open();
    // Execute database operations.
}
// Or, if not using "using":
SqlConnection connection = new SqlConnection(connectionString);
try {
    connection.Open();
    // Execute operations.
}
finally {
    connection.Dispose();
}

The Philosophy Behind “Throw More, Catch Less”

I advocate for writing fewer catch blocks and allowing exceptions to propagate to a centralized handler. This keeps error handling centralized and improves observability. For example, a method can validate and throw errors without catching them:

public void ProcessOrder(Order order) {
    if (order == null)
        throw new ArgumentNullException(nameof(order), "Order cannot be null.");
    // Process the order...
}

In an ASP.NET application, you might use a global exception handler to manage errors consistently:

app.UseExceptionHandler("/Error");

This approach ensures that errors are visible and managed in one place, making systems more robust and easier to debug.

These principles and code examples are directly derived from the transcript and are supported by the slides, ensuring that they reflect the original content without deviation.

2025-02-08 3 Ways You’re Screwing up Platform Engineering – And How to Fix It • Steve Smith • GOTO 2024 - YouTube { www.youtube.com }

Power Tools Overload

• Problem: Platform teams rely on heavyweight tools (e.g., Kubernetes, Kafka, Istio), creating high maintenance costs and unplanned work for delivery teams.
• Solution: Replace complex tools with lightweight alternatives like Fargate or Kinesis to reduce tech burden.

Technology Anarchy

• Problem: Teams have too much autonomy without alignment, leading to inconsistent tech stacks, inefficient processes, and slow collaboration.
• Solution: Establish paved roads with clear guidelines, expectations, and business consequences to balance autonomy with alignment.

Ticketing Hell

• Problem: Platform teams act as a service desk, requiring tickets for routine tasks, causing bottlenecks, slow progress, and developer frustration.
• Solution: Implement self-service workflows to automate common tasks, freeing both platform and delivery teams from excessive manual work.

Platform as a Product Mindset

• Problem: Teams treat platform engineering as a project rather than a product, leading to inefficiencies and lack of user focus.
• Solution: Apply product management principles, measure internal customer value, and focus on reducing unplanned work to drive adoption and success.

2025-02-03 The State of Authentication - YouTube { www.youtube.com }

2025-03-05 Build first, plan second. - YouTube { www.youtube.com }

I’ve learned from experience that if you’re going to build a product that truly solves real user needs, you must start by building a working prototype instead of spending months on a design document. In my time at big tech—and even more so in medium and small companies—I’ve seen how design docs can lead teams astray, locking in bad assumptions before you even know what you’re building. I call it "painting a house you haven’t seen yet", because when you plan without having built the thing, you’re just imagining complexities that don’t exist in practice.

When I worked on projects like the Twitch dashboard, our elaborate design for a binary tree layout failed to account for real-world issues like varying aspect ratios across devices. Had we built a proof-of-concept first, we would have discovered these issues early on, saving us months of wasted effort. Instead, the focus on a rigid spec led us to persist with bad decisions and ultimately delay a product that could have been released sooner.

For me, the only sensible approach is to prototype, test, and iterate. Building something tangible exposes hidden complexities and actual user behaviors in ways that a design doc never can. Once you’ve built it and seen how it works in reality, then you can document and refine the design. If you haven’t built it first, don’t plan it—this is the only way to avoid locking in mistakes and wasting valuable engineering time.

Good Reads​

2025-02-22 AI Killed The Tech Interview. Now What? | Kane Narraway { kanenarraway.com }

With the rise of AI, companies need to rethink their interview processes. Simply asking candidates to complete coding tests isn't enough anymore. Some options include stopping remote interviews, requiring spyware during interviews, or allowing AI use and focusing on how well candidates can prompt and refactor AI outputs. Ultimately, companies may need to adopt a hybrid approach, combining remote and in-person interviews to evaluate both coding skills and AI proficiency. Regardless, the nature of tech interviews is set to change drastically in the coming years.

2025-02-17 Finding Flow: Escaping Digital Distractions Through Deep Work and Slow Living | ssp.sh { www.ssp.sh }

Johann Hari says in Stolen Focus that rats and pigeons can be manipulated as we want. Just give them food whenever they do what you want them to. And shortly after, they will repeat that over and over again.

This made me think. In times when Instagram and other apps give us likes, hearts, and views on things we post, how much does big tech influence our behavior?

Aren’t they the same as the researcher, feeding us with dopamine to tell us to do what they want? Are they doing the same as the researcher who feeds the rats or pigeons?

This question, and recent improvements and tinkering with my flow as I started working for myself, made me ask how we can control the addiction and the influence and find a better way to slow living.

2025-02-17 The Quest to Understand Metric Movements | by Pinterest Engineering | Pinterest Engineering Blog | Feb, 2025 | Medium { medium.com }

%metrics %rootcause %analytics

To understand why key metrics change, Pinterest uses three approaches. The "Slice and Dice" method breaks down metrics into segments based on different dimensions like country and device type, allowing us to identify significant segments. This method helps diagnose issues like video metric regressions by organizing segments into a tree structure.

The "General Similarity" approach looks for other metrics that move similarly, either in the same or opposite direction, using factors like Pearson correlation and Spearman’s rank correlation. This method has helped us discover relationships between performance metrics and content distribution, indicating potential causes for latency.

Lastly, the "Experiment Effects" approach leverages A/B testing to see which experiments impact key metrics. By analyzing the treatment effects and filtering out noisy results, we dynamically identify top experiments affecting metrics. These approaches together help us narrow down root causes for metric movements and guide further investigations.

Quotes:

How we are analyzing the metric segments takes inspiration from the algorithm in Linkedin’s ThirdEye. We organize the different metric segments into a tree structure, ordered by the dimensions we are using to segmentize the metric.

• Pearson correlation: measures the strength of the linear relationship between two time-series

• Spearman’s rank correlation: measures the strength of the monotonic relationship (not just linear) between two time-series; in some cases, this is more robust than Pearson’s correlation

• Euclidean similarity: outputs a similarity measure based on inversing the Euclidean distance between the two (standardized) time-series at each time point

• Dynamic time warping: while the above three factors measure similarities between two time-series in time windows of the same length (usually the same time window), this supports comparing metrics from time windows of different lengths based on the distance along the path that the two time-series best align

  See also: Scuba: Diving into Data at Facebook - Meta Research

  Scuba: Diving into Data at Facebook paper pdf

  %Scuba %RealTimeAnalytics %InMemoryMonitoring %FacebookInfrastructure %DistributedSystems %PerformanceMonitoring %LogAnalytics %AdHocAnalytics %SystemsAtScale

  

  Discussion on Scuba

  1. Systems @Scale 2019 – Scuba: Real-time Monitoring and Log Analytics at Scale

  "Scuba is Facebook's platform for real-time monitoring and log analytics at scale."
  View the presentation

  2. YouTube Video – Scuba: Real-time Monitoring and Log Analytics at Scale

  "Scuba is Facebook's platform for real-time monitoring and log analytics at scale."
  Watch on YouTube

2025-02-17 calculator-app - Chad Nauseam Home { chadnauseam.com }

Creating a calculator app with precise results is challenging because floating point numbers can't represent all numbers accurately. Hans-J. Boehm experimented with various methods like bignums and algebraic equations but had to find a balance between precision and practicality.

Ultimately, Boehm's team realized they only needed to work with numbers expressible through the calculator's operations. They combined rational arithmetic and constructive real numbers, representing numbers as a rational times a real. Using symbolic representations for irrational numbers like π, they achieved accurate results while maintaining usability.

This approach allowed them to develop a calculator app that delivers accurate answers without compromising user experience. Their work highlights the complexity and creativity required to solve seemingly simple problems in software development.

2025-01-25 Life Lessons from the First Half-Century of My Career – Communications of the ACM { cacm.acm.org }

I started my career at Hughes Aircraft in 1972 while working on my Ph.D. at the University of California, Los Angeles (UCLA). After designing airborne computers for four years, I graduated and then taught and did systems research at UC Berkeley for the next 40. Since 2016, I’ve helped Google with hardware that accelerates artificial intelligence (AI).

At the end of my technical talks, I often share my life story and what I’ve learned from my half-century in computing. I recently was encouraged to share my reflections with a wider audience, so I’ve captured them here as 16 people-focused and career-focused life lessons.

People-Focused and Career-Focused Life Lessons from David Patterson.

2025-02-06 Software development topics I've changed my mind on after 10 years in the industry - Blogomatano { chriskiehl.com }

Things I've changed my mind on:​

Things I now believe, which past me would've squabbled with:

• Simple is not given. It takes constant work
• There is no pride in managing or understanding complexity
• Typed languages are essential on teams with mixed experience levels
• Java is a great language because it's boring
• REPLs are not useful design tools (though, they are useful exploratory tools)
• Most programming should be done long before a single line of code is written
• Frontend development is a nightmare world of Kafkaesque awfulness I no longer enjoy
• Elegance is not a real metric
• Good management is invaluable. (I went most of my career before seeing it done well)
• DynamoDB is a good database (IFF your workload lines up with what it's offering)
• Objects are extremely good at what they're good at. Blind devotion to functional is dumb.

Opinions I've picked up along the way​

• Engineering is mostly about communication
• Never go full monad in Java.
• The query planner is a cruel mistress
• If I think something is easy, that's a sure sign I don't understand it.
• You have to give younger devs room to explore and make mistakes
• You have to actively invest in improving your soft skills (and investments pay back immediately)
• Very few abstractions exist in general application development. Just write the code you need
• Contrarily, library development is about abstractions. Spend time hunting for an algebra
• ORMs are the devil in all languages and all implementations. Just write the damn SQL
• The trouble with functional programming is functional programmers 😄
• Given a long enough time horizon, you'll deeply regret building on Serverless Functions
• Types are assertions we make about the world
• Distributed locking is still really hard for some reason
• Formal modeling and analysis is an essential skill set
• Isolation is the most important property of a good integration suite.
• DynamoDB is the worst possible choice for general application development
• Most won't care about the craft. Cherish the ones that do, meet the rest where they are
• Gradual, dependently typed languages are the future
• You literally cannot add too many comments to test code (I challenge anyone to try)

Things I have not changed my opinion on:​

• People who stress over code style, linting rules, or other minutia remain insane weirdos to me. Focus on more important things.
• Code coverage has absolutely nothing to do with code quality (in many cases, it's inversely proportional)
• Monoliths remain pretty good
• It's very hard to beat decades of RDBMS research and improvements
• Micro-services require justification (they've increasingly just become assumed)
• Most projects (even inside of AWS!) don't need to "scale" and are damaged by pretending so
• 93%, maybe 95.2%, of project managers, could disappear tomorrow to either no effect or a net gain in efficiency. (this estimate is up from 4 years ago)

We'll see which of these have flipped at year 15.

2025-01-18 The documentation problem in development | Rowsana { rowsana.bearblog.dev }

2025-01-18 Everything I Know About Shipping Code Faster { www.developing.dev }

Two weeks ago, I shared Evan’s writing on what helped him grow from Junior to Staff at Meta in 3 years. His entire post hinges on that you need to blaze through your core responsibilities to free up time for growth.

The most common question I got after that post was how do you do that?

I interviewed Evan last week so you can hear the answer in his own words soon (aiming to share that next week). Before that, I wanted to share some thoughts since it’s one of the most important parts of growing your impact. Here’s everything I know about shipping more in less time.

= = =

(Semi-GPT summary) To get more done in less time, you’ve got to nail your core responsibilities so you can free up time for growth. Start by resolving ambiguity. Be fluent in code search to navigate big codebases quickly, know who to ask for help when you’re stuck, and learn to query data yourself instead of waiting on others. These basics will save you hours.

When writing code, smaller, focused diffs are the way to go. They’re faster to write, test, and review, with fewer bugs slipping through. To move even quicker, batch your tests, use feature flags to safely land work in progress, and copy existing test plans to save time in unfamiliar code paths. Make reviews faster by spoon-feeding context to reviewers and preempting feedback before submission. Being a great collaborator builds trust and gets your code reviewed faster.

Flow state is key. Eliminate distractions with noise-canceling headphones, cluster meetings to maximize focus time, and work during hours when interruptions are minimal. Turn off noisy notifications and audit your workflow for inefficiencies. While waiting on builds or tests, knock out quick tasks to keep momentum. Freeing up that extra time lets you tackle growth opportunities and build a career trajectory like Evan’s.

(found in 2025-01-18 Everything I Know About Shipping Code Faster { programmingdigest.net })

2025-01-16 Nobody Cares { grantslatton.com }

At work the junior engineer sends you some code to review. The code was clearly written in a first draft, and then just iteratively patched until the tests passed, then immediately sent to you to review without any further improvement. They do not care.

The guy on the hiking trail is playing his shitty EDM on his bluetooth speaker, ruining nature for everyone else. He does not care.

The doctor misdiagnoses your illness whose symptoms are in the first paragraph of the trivially googleable wikipedia article. He does not care.

People don't pick up after their dogs. The guy at the gym doesn't re-rack the weights. The lady at the grocery store leaves the cart in the middle of the parking lot. They. Do. Not. Care.

2025-01-09 28h Days { sidhion.com }

2025-01-09 28h Days: year 1 update { sidhion.com }

2025-01-08 Laid Off for the First Time In My Career, and Twice In One Year - Dillon Shook { dillonshook.com }

Based on my N=2 experience and the posts I’ve read here are some warning signs to look out for:

• The product org is struggling to set a vision
• Many distractions and lack of focus
• Low products usage
• Perks being cut, cancelled onsite meetings, signs of financial troubles

And last but certainly most telling:

• There’s a “company update” meeting unexpectedly scheduled four hours from now

2024-12-31 How I got promoted to staff engineer twice | sean goedecke { www.seangoedecke.com }

First, we need to understand why senior-to-staff promotions happen in tech companies. They happen for two reasons:

1. Company leadership (i.e. your skip-level or above) think a particular engineer is valuable and may leave if not promoted to staff.
2. Company leadership want a particular engineer to lead specific cross-org projects that will run smoother if they’ve got the staff role.

Promotions do not happen because a particular engineer is really technically strong and ready for the next level. They do not happen because an engineer has been mentoring a lot and is ticking the boxes on the engineering ladder description. They are a tool for retaining or for empowering valued engineers. So to be promoted to staff, you must be known and valued by your organization.

2024-12-31 225. Systems Ideas that Sound Good But Almost Never Work—"Let's just…" { hardcoresoftware.learningbyshipping.com }

When someone suggests, "let's just," it often leads to complications far beyond what anyone anticipates. For example, making something "pluggable" assumes seamless adaptability through future modules or implementations, but true pluggability requires creating at least two working versions upfront, which is rarely feasible. Similarly, adding APIs to transform a product into a "platform" may sound strategic, but APIs demand constant maintenance, compatibility, and user interest—things that are much harder to deliver than imagined.

Other ideas that rarely work include adding layers of abstraction, synchronizing data, or enabling cross-platform functionality. While abstractions can solve problems, premature ones create unused complexity. Synchronization, especially across unstructured data, is fraught with inconsistencies and bugs. Cross-platform efforts often devolve into building something akin to an operating system, which is far more complex than initially envisioned. Even "escape to native" options—allowing frameworks to access underlying platforms—tend to fail because they create conflicts between the framework's state and the native platform's.

Most of these ideas fail not because they are inherently bad but because they oversimplify the problem and ignore the complexities of implementation, maintenance, and real-world usage. Successful engineering requires solving problems with clear first principles, not leaning on patterns that are more prone to failure than success.

Fun / Retro​

2025-02-18 dinosaur couch (@dinosaurcouch) • Instagram photos and videos { www.instagram.com }

More Windows 3.11 CSS:

• 2025-02-08 nielssp/classic-stylesheets: Classic stylesheets for web applications. { github.com }

  

• 2025-02-08 Windows 3.1 {karol-kiersnowski.github.io}

  2025-02-08 GitHub - karol-kiersnowski/win31: Simple simulator of Windows 3.1 (it's just a toy) {github.com}

• 2025-02-08 GitHub - sleepybuildings/vuedows: A reimplementation of the Windows 3.11 shell in CSS, Typescript and Vue {github.com}

  

2025-02-06 A computer can never be held accountable { simonwillison.net }

2025-01-25 cs16.css { cs16.samke.me }

CSS library based on Counter Strike 1.6 UI.

2025-01-07 Neal.fun { neal.fun }

The website Neal.fun is a creative space where Neal shares his projects and games. It's a fun and interactive site with various activities and experiments.

2025-01-07 Stimulation Clicker { neal.fun } Wow!!!

2025-01-02 ASCII Porn Predates the Internet But It’s Still Everywhere { www.vice.com }

Inspiration!​

2025-02-22 A system to organise your life • Johnny.Decimal { johnnydecimal.com }

A system to organise your life. Johnny.Decimal is designed to help you find things quickly, with more confidence, and less stress.

You assign a unique ID to everything in your life.

A diagram showing the structure of a Johnny.Decimal number. The number is 15.52 and it explains how the '1' is an area, which groups related categories in sets of 10. The '15' is the category, in this case 'travel'. And '52' is just an ID; they start at 01. The title of this, our 52nd travel thing, is 'Trip to NYC'. These IDs help you stay organised. They impose constraints that make it harder to get lost. And you create your own index to link everything in your life together.

The system is free to use and the concepts are the same at home, work, or that club you manage.

2025-02-22 Removing Jeff Bezos From My Bed ◆ Truffle Security Co. { trufflesecurity.com }

SSH access to the bed! What Can They Do with This Access?

Let’s start with the basics:

• They can know when you sleep
• They can detect when there are 2 people sleeping in the bed instead of 1
• They can know when it’s night, and no people are in the bed

Imagine your ex works for Eight Sleep. Or imagine they want to know when you’re not home.

(Of course, they can also change the bed’s temperature, turn on the vibrating feature, turn off your alarm clock, and any of the other normal controls they have power over.)

2025-02-11 Orange Guidance Soapstone {leshuguita.github.io}

2025-02-11 Project Aria FAQ | Project Aria Docs { facebookresearch.github.io }

Oh, the quality of documentation!

2025-02-08 FreeDemandLetter - Get What You Deserve { www.freedemandletter.com }

2025-02-08 Do-nothing scripting: the key to gradual automation – Dan Slimmon { blog.danslimmon.com }

At first glance, it might not be obvious that this script provides value. Maybe it looks like all we’ve done is make the instructions harder to read. But the value of a do-nothing script is immense:

• It’s now much less likely that you’ll lose your place and skip a step. This makes it easier to maintain focus and power through the slog.
• Each step of the procedure is now encapsulated in a function, which makes it possible to replace the text in any given step with code that performs the action automatically.
• Over time, you’ll develop a library of useful steps, which will make future automation tasks more efficient.

A do-nothing script doesn’t save your team any manual effort. It lowers the activation energy for automating tasks, which allows the team to eliminate toil over time.

Suggestions from 2025-02-08 Do-nothing scripting: the key to gradual automation (2019) | Hacker News { news.ycombinator.com }

2025-02-07 jsontr.ee: Visualize JSON Structures as Dynamic SVG Diagrams

You can try it out on this playground, which provides the option to download the diagram as PNG, or use it in an app with customizable styles.

(🟠 Found in JavaScript Weekly: JavaScript Weekly Issue 721: January 31, 2025 { javascriptweekly.com })

2025-01-31 mathesar-foundation/mathesar: An intuitive spreadsheet-like interface that lets users of all technical skill levels view, edit, query, and collaborate on Postgres data directly—100% open source and self hosted, with native Postgres access control. { github.com }

Intuitive spreadsheet-like interface that lets users of all technical skill levels view, edit, query, and collaborate on Postgres data directly—self hosted, with native Postgres access control.

2025-01-27 Simple Search - Just a list of search bars { simplesearch.info }

2025-01-27 Compare Search Engines - Gnod Search { www.gnod.com }

2025-01-27 YC Graveyard { ycgraveyard.iamwillwang.com }

YC Graveyard: 821 inactive Y Combinator startups

2025-01-26 SQLook - SQLite Database Viewer and Generator { sqlook.com }

And so... they changed UI to a more modern Bootstrap version... oh... SQLook – A free online SQLite database manager with a Windows 2000 interface

2025-01-25 synth-inc/onit: Onit MacOS client { github.com }

We are building Onit based on these core beliefs:

1. Universal Access: AI assistants should be accessible from anywhere on your computer, not just in browsers or specific apps.
2. Provider Freedom: Users should have the choice between models and model providers (Anthropic, OpenAI, xAI, etc.) and not be locked into a single provider.
3. Local First: AI is much more useful with access to your data. But that doesn't count for much if you have to upload personal files to an untrusted server first. Onit will always provide options for local processing. No personal data will leave your computer without explicit approval.
4. Customizability: Onit is your assistant. You should be able to configure it to your liking.
5. Extensibility: Onit should allow the community to build and share extensions, making it more useful for everyone.

2025-01-23 Master the Art of the Product Manager 'No' { letsnotdothat.com }

Master the Art of the Product Manager "No"

See also: 2025-01-23 How to professionally say? The Complete Guide 2024 { www.corporatereplies.com }

Just shut up!

I kindly request that you allow me to finish my thoughts. This will enable a smoother flow of conversation and ensure that all points are thoroughly addressed. Thank you for your understanding.

Why are you so useless?

(This one’s obviously sarcastic, but if you do use it, tag us on social media @corporatereplies 😂; We’re on Instagram and TikTok and we’d love to see the reaction.)

I am observing that your current performance is not meeting the expected standards. Could you please elaborate on the challenges you are facing to assist in finding potential solutions?

2025-01-23 AkashRajpurohit/howtoprofessionallysay: 📖 A guide for your daily "professional" interactions { github.com }

2025-01-23 How to professionally say { howtoprofessionallysay.akashrajpurohit.com }

How to professionally say A guide for your daily "professional" interactions

2025-01-23 itamarom/notepadjs { github.com }

https://itamarom.github.io/notepadjs/

A cross-platform love letter to Notepad (+) PWA

2025-01-19 jjcm/llmpeg: Uses an llm to generate ffmpeg commands { github.com }

Allows for simple usage of ffmpeg via an llm. BASH

You write ffmpeg commands based on the description from the user. You should only respond with a command line command for ffmpeg, never any additional text. All responses should be a single line without any line breaks.

2025-01-16 FFmpeg By Example { ffmpegbyexample.com }

2025-01-15 jesseduffield/lazygit: simple terminal UI for git commands { github.com }

Elevator Pitch

Rant time: You've heard it before, git is powerful, but what good is that power when everything is so damn hard to do? Interactive rebasing requires you to edit a goddamn TODO file in your editor? Are you kidding me? To stage part of a file you need to use a command line program to step through each hunk and if a hunk can't be split down any further but contains code you don't want to stage, you have to edit an arcane patch file by hand? Are you KIDDING me?! Sometimes you get asked to stash your changes when switching branches only to realise that after you switch and unstash that there weren't even any conflicts and it would have been fine to just checkout the branch directly? YOU HAVE GOT TO BE KIDDING ME!

If you're a mere mortal like me and you're tired of hearing how powerful git is when in your daily life it's a powerful pain in your ass, lazygit might be for you.

2025-01-10 I’ve acquired a new superpower – Daniel Wirtz { danielwirtz.com }

2025-01-08 Fontjoy - Generate font pairings in one click { fontjoy.com }

The goal of font pairing is to select fonts that share an overarching theme yet have a pleasing contrast. Which fonts work together is largely a matter of intuition, but we approach this problem with a neural net. See GitHub for more technical details.

2025-01-05 Self-driving 1993 Volvo 940 (part 1: actuators) – PracticApp – Hardware / Software Engineering { practicapp.com }

Together with some friends, I decided earlier this year to particpate in the Carbage run 2025 Winter edition. This is a 6-day journey in winter all the way through Sweden to the polar circle, and back down to Helsinki in a group of roughly 400 cars.

One small catch (you might have guessed it from the name): your car has to be “carbage”. In practice, this means it needs to be at least 20 years old, and with a day value of less than €1000.

2025-01-02 lighting-ai/web-piano: This project is a playable piano keyboard developed using Bolt.DIY + DeepSeekV3. It supports both mouse clicks and keyboard input, with a MacBook-style touchbar for visual feedback. { github.com }

➡️ 2025-01-02 stackblitz-labs/bolt.diy: Prompt, run, edit, and deploy full-stack web applications using any LLM you want! { github.com }

➡️ 2025-01-02 deepseek-ai/DeepSeek-Coder: DeepSeek Coder: Let the Code Write Itself { github.com }

2025-01-02 API Parrot { apiparrot.com }

API Parrot is the tool specifically designed to reverse engineer the HTTP APIs of any website. Making life easier for developers looking to automate, integrate or scrape websites without public APIs.

👂 The Ear of AI​

2025-02-20 Animate Anyone 2 { humanaigc.github.io }

2025-02-20 Accelerating scientific breakthroughs with an AI co-scientist { research.google }

2025-02-11 Tech's Dumbest Mistake: Why Firing Programmers for AI Will Destroy Everything { defragzone.substack.com }

Firing programmers for AI is a mistake | Hacker News { news.ycombinator.com }

The next generation of programmers will grow up expecting AI to do the hard parts for them. They won’t know why an algorithm is slow, they won’t be able to debug cryptic race conditions (provided they are familiar with the concept), and they certainly won’t know how to build resilient systems that survive real-world chaos.

The result? We’ll have a whole wave of programmers who are more like AI operators than real engineers. And when companies realize AI isn't magic, being just a bunch of tokenized words in line (prove me wrong on that), they'll scramble to find actual programmers who know what they're doing. Too bad they spent years not hiring them.

2025-02-07 Understanding Reasoning LLMs - by Sebastian Raschka, PhD { magazine.sebastianraschka.com }

2025-01-31 Jailbreaking DeepSeek R1 - Prompt Injection Using Charcodes { substack.com }

Bypass DeepSeek censorship by speaking in hex

2025-01-29 DeepSeek's Multi-Head Latent Attention and Other KV Cache Tricks | PySpur { www.pyspur.dev }

2025-01-29 How has DeepSeek improved the Transformer architecture? | Epoch AI { epoch.ai }

2025-01-28 17-445 Machine Learning in Production / AI Engineering { mlip-cmu.github.io }

• 2025-01-28 Syllabus | Large Language Model Systems { llmsystem.github.io }

2025-01-21 AI Model & API Providers Analysis | Artificial Analysis { artificialanalysis.ai }

Independent analysis of AI models and API providers Understand the AI landscape to choose the best model and provider for your use-case

2025-01-18 Don't use cosine similarity carelessly { p.migdal.pl }

2025-01-17 📚 Convert E-books into audiobooks with Kokoro - Claudio Santini { claudio.uk }

2025-01-13 The 2025 AI Engineering Reading List - Latent Space { www.latent.space }

2025-01-06 Killed by LLM { r0bk.github.io }

2024-12-31 Things we learned about LLMs in 2024 { simonwillison.net }

In 2024, the field of Large Language Models (LLMs) saw significant advancements. The GPT-4 barrier was broken, with 18 organizations now having models that outperform the original GPT-4. Notably, Google's Gemini 1.5 Pro introduced new capabilities like a 2 million token input context length and video input. Additionally, LLM prices dropped dramatically due to increased competition and efficiency, making these models more accessible.

Multimodal vision became common, with models now handling images, audio, and video. Voice and live camera modes also emerged, allowing real-time interaction with LLMs. Despite these advancements, the concept of "agents"—LLMs acting autonomously—has not yet fully materialized. The environmental impact of LLMs improved due to efficiency gains, but the large-scale infrastructure buildout by tech giants remains a concern.

Overall, 2024 was marked by rapid progress in LLM capabilities, reduced costs, and the rise of multimodal and real-time interaction features. However, challenges like the environmental impact and the practical implementation of autonomous agents still need to be addressed.

2025-01-04 Can LLMs write better code if you keep asking them to “write better code”? | Max Woolf's Blog { minimaxir.com }

This article investigates whether large language models (LLMs) like Claude 3.5 Sonnet or GPT can iteratively improve code when asked to "make it better." Using a Python coding problem as a test, the author demonstrates that LLMs can optimize performance over iterations, improving speed and efficiency. However, vague prompts often lead to overengineering, such as unnecessary "enterprise-level features," without clear benefits. Despite these issues, iterative prompting can yield faster, more efficient code.

With explicit instructions, the LLM delivered substantial improvements, including using tools like Numba for just-in-time compilation and NumPy for vectorization. These optimizations resulted in code that was up to 100x faster than the initial implementation. The LLM also introduced creative techniques like precomputing digit sums and leveraging parallel processing. However, issues like hallucinated logic, subtle bugs, and redundant complexity showed that human oversight is essential to validate and refine the results.

The findings highlight the potential and limitations of using LLMs for coding. While they can provide significant speed-ups and novel ideas, they often miss important optimizations, such as deduplication or statistical shortcuts. The article emphasizes that LLMs are valuable tools for accelerating development when used thoughtfully but require careful guidance and validation from skilled developers to produce effective, reliable results.

2025-01-05 What we learned copying all the best code assistants { blog.val.town }

Since the beginning of Val Town, our users have been clamouring for the state-of-the-art LLM code generation experience. When we launched our code hosting service in 2022, the state-of-the-art was GitHub Copilot. But soon it was ChatGPT, then Claude Artifacts, and now Bolt, Cursor, and Windsurf. We’ve been trying our best to keep up. Looking back over 2024, our efforts have mostly been a series of fast-follows, copying the innovation of others. Some have been successful, and others false-starts. This article is a historical account of our efforts, giving credit where it is due.

Research 🤖 LLM vs 🧠 Brain: Cognitive Impact​

2025-02-04 I Taught for Most of My Career. I Quit Because of ChatGPT | TIME { time.com }

Virtually all experienced scholars know that writing, as historian Lynn Hunt has argued, is “not the transcription of thoughts already consciously present in [the writer’s] mind.” Rather, writing is a process closely tied to thinking. In graduate school, I spent months trying to fit pieces of my dissertation together in my mind and eventually found I could solve the puzzle only through writing. Writing is hard work. It is sometimes frightening. With the easy temptation of AI, many—possibly most—of my students were no longer willing to push through discomfort.

Generative AI is, in some ways, a democratizing tool. Many of my students were non-native speakers of English. Their writing frequently contained grammatical errors. Generative AI is effective at correcting grammar. However, the technology often changes vocabulary and alters meaning even when the only prompt is “fix the grammar.” My students lacked the skills to identify and correct subtle shifts in meaning. I could not convince them of the need for stylistic consistency or the need to develop voices as research writers.

I pointed to weaknesses such as stylistic quirks that I knew to be common to ChatGPT (I noticed a sudden surge of phrases such as “delves into”). That is, I found myself spending more time giving feedback to AI than to my students.

2025-02-04 (PDF) Investigating How Frequent Interactions with AI Technologies Impact Cognitive and Emotional Processes { www.researchgate.net }

Of course I did not read the original article and asked ChatGPT to create a digest

AI is Making Us Smarter

The study found that frequent AI users experience measurable cognitive improvements.

📌 Short-term memory improvement:

• Correlation coefficient: r = 0.663 (p < 0.01) → Strong positive correlation.
• Conclusion: People who use AI frequently recall information faster and more accurately.

📌 Better decision-making:

• Correlation coefficient: r = 0.572 (p < 0.01) → Significant improvement.
• How was this tested? Participants completed decision-making tasks before and after AI use.
• Results: AI-assisted users had a higher accuracy rate in complex decision-making.

🚀 Key takeaway: AI is acting as a cognitive amplifier, allowing us to process and retain information more efficiently.

But… it’s not all good news.

The Dark Side: AI is Increasing Stress and Anxiety

While AI improves cognitive performance, the study also found a moderate positive correlation (r = 0.468, p < 0.01) between frequent AI use and increased mental stress.

📌 Evidence from self-reported stress levels:

• Participants completed anxiety and stress assessments before and after AI interactions.
• Results: Frequent AI users reported higher stress scores after prolonged AI use.

📌 Cognitive overload is real:

• AI bombards users with continuous information, leading to mental fatigue.
• Example from interviews: Users described feeling "overwhelmed" and "mentally exhausted" after extensive AI interaction.

🤯 Key takeaway: AI might make tasks easier, but it also increases cognitive pressure and emotional strain.

The Hidden Risk: Psychological Dependence on AI

One of the most alarming findings was the development of AI dependency.

📌 Psychological reliance on AI:

• Regression analysis confirmed that frequent AI users are more likely to doubt their own judgment.
• Standardized Coefficient (Beta) = 0.421, p = 0.000 → A strong predictor of AI-induced dependency.

📌 Real-world impact:

• Users who rely on AI for problem-solving report difficulty making decisions without AI assistance.
• Example from interviews: Some participants said they "don’t trust their answers without double-checking with AI."

🔍 Key takeaway: AI is replacing independent thinking, reducing cognitive autonomy, and making users second-guess themselves.

5. The Solution: How We Can Use AI Without Losing Ourselves

So, what’s the way forward? The study suggests three key strategies to balance AI’s cognitive benefits with emotional well-being:

✔️ AI should assist, not replace thinking → We must stay in control of our decisions. ✔️ Regulate AI’s role in decision-making → Avoid relying on AI for every task. ✔️ AI should be designed for cognitive balance → Not just efficiency, but emotional well-being too.

🎯 Final Thought: AI has the potential to elevate our intelligence or erode our independence.

The question is: Will we use AI as a tool to enhance our minds—or let it become the master of our decisions?

The future is in our hands.

---

For the record (gpt-4o):

1. I've asked GPT summarize the article like a friend researcher would do. The result was bad.
2. The I've asked to write in a conversation style between two friends... the result was "Me: Bro, this paper is wild. It’s basically saying that using AI all the time makes us smarter… but also kinda messes with our emotions."
3. "Make the TED-style presentation, where the people share their opinions" -- led to good initial structure with emojis, which I like!
   1. "Add evidence for each point" -- finalized the result, not bad, I wonder if the numbers and conclusions are correct.

2025-02-22 Microsoft Study Finds Relying on AI Kills Your Critical Thinking Skills { gizmodo.com }

A new study published by researchers at Microsoft and Carnegie Mellon University found that the more humans lean on AI tools to complete their tasks, the less critical thinking they do, making it more difficult to call upon the skills when they are needed.

The researchers tapped 319 knowledge workers—a person whose job involves handling data or information—and asked them to self-report details of how they use generative AI tools in the workplace. The participants were asked to report tasks that they were asked to do, how they used AI tools to complete them, how confident they were in the AI’s ability to do the task, their ability to evaluate that output, and how confident they were in their own ability to complete the same task without any AI assistance.

⌚ Nice watch!​

2025-01-21 How I Built T3 Chat in 5 Days - YouTube { www.youtube.com }

GPT Summary: I developed T3 Chat, an AI chat app that emphasizes speed, usability, and efficient local-first architecture, completing the project in just five days. Motivated by frustrations with existing AI tools, I aimed to create a responsive and seamless experience. Leveraging the Deep Seek V3 model for its speed and affordability, I found existing starter kits unsuitable for my needs, prompting me to build a custom solution. The app uses React, React Router, and Dexie.js for its database layer, enabling offline functionality and efficient synchronization between local and cloud data. Switching from server-driven routing to a client-side approach greatly improved navigation and responsiveness.

The development process included significant hurdles. I experimented with tools like Jazz for syncing but found its collaborative-first structure overly restrictive. Instead, I built a custom sync layer, tailoring the data flow to the app's requirements. Performance optimization was critical, with tools like React Scan helping to eliminate inefficiencies. Markdown chunking and memoized rendering were implemented to minimize unnecessary re-renders, ensuring a smooth user experience. Payments were integrated with Stripe, alongside an onboarding flow that uses inline messages to explain app features. Despite challenges, these deliberate engineering choices resulted in an app that is faster, more responsive, and better tailored to user needs than its competitors.

The tools used include Deep Seek V3, React, Dexie.js, React Router, React Scan, Tailwind CSS, Vercel AI SDK, and Stripe. Each played a vital role, though some required customization, like Jazz and OpenAuth. The result is an AI chat app that outperforms existing alternatives by leveraging local-first architecture, advanced optimizations, and thoughtful design principles. This project demonstrates how targeted engineering and innovative thinking can create high-performing, user-focused applications.

2025-01-19 Locknote: Local Reasoning in C++ - Sean Parent - NDC TechTown 2024 - YouTube { www.youtube.com }

GPT Summary:

The speaker, Sean Parent, a senior principal scientist at Adobe, shared insights into improving software engineering practices with a focus on local reasoning—breaking down complex systems into manageable, verifiable components. He also delved into challenges around reasoning in C++, design principles, and strategies for building reliable systems.

Core Ideas from the Talk

The Root Cause of Software Failures The talk began with an analysis of why large software systems fail. Despite many failures being attributed to management issues, the real challenges often stem from exceeding our ability to reason about systems. The software engineering crisis, a problem identified as early as 1968, persists because large systems become too complex to understand or verify.

"The greatest limitation in writing software is our ability to understand the systems we're creating."

Key failures include lack of tools, poor practices, and an over-reliance on free relationships (unmanaged dependencies between components).

Local Reasoning Local reasoning is the ability to understand and verify a function or class independently of its broader context. This is enabled through clear APIs, preconditions, and postconditions, which define the contract between the client (caller) and the implementer. The talk focused on achieving local reasoning through careful structuring of functions, arguments, and classes.

API Contracts and Preconditions Preconditions and postconditions define the expectations and guarantees of a function:

1. Preconditions: Specify conditions the caller must meet before invoking the function.
2. Postconditions: Describe the state after the function executes successfully.
3. Invariant Conditions: Properties that must always hold true within the scope of a function or class.

Preconditions allow implementers to shift responsibility for ensuring valid input to the caller, simplifying function logic.

"Do not underestimate the power of a precondition. It lets the implementer focus on the valid cases."

Managing Function Arguments Function arguments should follow a clear and consistent contract:

• Let Arguments: Immutable references (e.g., const T&) that are not modified by the function.
• In-Out Arguments: Mutable references (e.g., T&) that may be modified by the function.
• Sink Arguments: R-value references (e.g., T&&) that are consumed by the function, leaving the caller responsible for ensuring proper ownership transfer.

General rules for arguments:

• Non-const references must not be accessed by other threads during the function's execution.
• Const references must not be written to during the function's execution.

These rules enforce memory safety and help prevent concurrency issues.

Avoiding Aliasing and Law of Exclusivity Aliasing—when multiple references point to the same memory—is a major challenge in reasoning about code. C++ lacks built-in safeguards like Swift’s exclusive access or Rust’s borrow checker, but developers must enforce similar rules manually:

• Ensure no overlapping projections (references to object parts) are passed to a function.
• Projections are invalidated if the object they point to is modified.

"In C++, we have exactly the same rule. We just don't have the language facilities to enforce it."

Projections and Value Semantics Projections (e.g., references to parts of an object) enable value semantics while maintaining efficiency. Rules for projections include:

• Avoid overlapping mutable projections.
• Projections are invalidated when the parent object is modified or destroyed.
• Multiple non-overlapping projections may coexist safely.

Mutation and Independence To simplify reasoning, objects must be independent under mutation:

1. Disallow mutation (functional programming).
2. Disallow sharing of mutable objects.
3. Allow mutation only when there is no sharing (copy-on-write).

Encapsulation and whole-part relationships (e.g., an object fully owning its parts) are critical to maintaining independence.

Encapsulation of Relationships Extrinsic relationships—connections between objects not captured by a whole-part hierarchy—are a primary source of complexity. These relationships should:

• Be encapsulated within a managing class to enforce invariants (e.g., ensuring a pointer remains valid).
• Be carefully tracked and invalidated when one side of the relationship changes.

"Containers are examples of classes that manage extrinsic relationships between their parts."

Complexity and Chaotic Systems Complex systems often become chaotic—unpredictable and impossible to reason about. Examples like the three-body problem illustrate how simple rules and relationships can create unpredictable behaviors. Developers must avoid creating chaotic systems by:

• Structuring code into hierarchies (e.g., whole-part relationships).
• Encapsulating relationships within manageable, well-defined classes.
• Simplifying or abstracting relationships to reduce interconnectedness.

Free Relationships Free relationships—unmanaged dependencies—are inherently dangerous. The speaker recommends avoiding them entirely, except in cases where the relationships are monotonic:

• Monotonic systems only move forward and never return to a previous state (e.g., immutable variables or conflict-free replicated data types).

Designing Reliable Code The speaker provided concrete recommendations for designing reliable, predictable systems:

• Use small, single-purpose functions: Each function should have a clear role with well-defined inputs and outputs.
• Avoid modifying shared state: Treat shared state as immutable or use copy-on-write semantics.
• Minimize sharing: Avoid passing shared pointers or references to mutable state in public interfaces.
• Write testable, invariant-based classes: Ensure each class encapsulates its relationships and invariants.
• Manage complexity with hierarchies: Use containment relationships to enforce structure and reasoning.

Guidelines for APIs

1. Functions should clearly specify their scope and effects.
2. Use projections to allow manipulation of object parts while preserving value semantics.
3. Do not pass overlapping projections or invalid references.
4. Favor references over shared pointers in function interfaces.

Addressing Systemic Complexity When individual relationships between parts become too complex to reason about, step back and define the system as a whole. For example, instead of managing individual moves in chess, define the overall algorithm for playing the game.

Summary of Best Practices

1. Write clear APIs with defined preconditions, postconditions, and invariants.
2. Avoid shared state unless absolutely necessary, and treat shared state as immutable.
3. Design objects for value semantics, ensuring independence and disjointedness.
4. Encapsulate relationships into classes to simplify reasoning.
5. Use hierarchies and DAGs to structure complex systems.
6. Minimize complexity by managing extrinsic relationships and avoiding chaotic loops.
7. Build monotonic systems where possible to allow for distributed, predictable behavior.

"At some point, individual relationships become too complex. You have to step back and solve the system as a whole."

These principles form a cohesive strategy for creating systems that are easier to reason about, maintain, and scale. By adhering to local reasoning, managing complexity, and encapsulating relationships, developers can build reliable, efficient software.

whole / part snippet:

/**
 * @class whole
 * @brief An example "whole" class that holds a "part" subobject.
 *
 * This class demonstrates a pattern where we:
 * - Disallow default construction.
 * - Provide an explicit constructor taking a required parameter.
 * - Use compiler-generated (default) copy/move constructors and assignment operators.
 * - Provide a default comparison operator.
 *
 * The goal is to ensure that any "whole" object is always in a valid and meaningful state,
 * and that all defaulted functions have consistent semantics with their subobjects.
 */
class whole {
    /**
     * @var _part
     * @brief The subobject/part that this "whole" manages.
     *
     * Storing the part as a member ensures that the "whole" is always composed of
     * a valid "part". We rely on the "part" type to provide its own correctness
     * and invariants.
     */
    part _part;

public:
    /**
     * @brief Delete the default constructor.
     *
     * Reason:
     * - We do not allow a "whole" to exist without explicitly providing
     *   a meaningful state for its subobject.
     * - Prevents accidental creation of a "whole" in an uninitialized or
     *   incomplete state.
     */
    whole() = delete;

    /**
     * @brief Construct a "whole" by providing a required state.
     *
     * @param s A "state" object that the "_part" subobject will be constructed with.
     * Reason:
     * - Ensures that each new "whole" has a valid "part" from the beginning.
     * - Marked explicit to prevent implicit conversions from state -> whole,
     *   forcing a clear constructor call.
     */
    explicit whole(state s)
        : _part{s}
    { }

    /**
     * @brief The copy constructor (defaulted).
     *
     * Reason:
     * - In most cases, compiler-generated copying does exactly what we want:
     *   memberwise copy of the subobjects.
     * - Making it explicit (optional choice here) can prevent some unintentional
     *   conversions, but primarily we’re just acknowledging that it is defaulted.
     */
    explicit whole(const whole&) = default;

    /**
     * @brief The move constructor (defaulted, noexcept).
     *
     * Reason:
     * - We allow moving to be efficient and safe.
     * - noexcept helps with certain optimizations (e.g., containers can move
     *   elements instead of copying if they know it won’t throw).
     */
    whole(whole&&) noexcept = default;

    /**
     * @brief Copy assignment operator (defaulted).
     *
     * Reason:
     * - Same rationale as the copy constructor: a simple memberwise copy
     *   from the other "whole" is typically correct and easiest to maintain.
     */
    whole& operator=(const whole&) = default;

    /**
     * @brief Move assignment operator (defaulted, noexcept).
     *
     * Reason:
     * - Same rationale as the move constructor: move semantics can improve
     *   performance, noexcept promises no exceptions are thrown.
     */
    whole& operator=(whole&&) noexcept = default;

    /**
     * @brief Equality comparison operator (defaulted).
     *
     * @param other The other "whole" to compare with.
     * @return true if the two "whole" objects are equal, false otherwise.
     *
     * Reason:
     * - Defaulted comparison will do a memberwise comparison of "_part"
     *   (assuming "part" itself has an appropriate operator==).
     * - Makes it easy to compare two "whole" objects without manual checks.
     */
    bool operator==(const whole&) const = default;
};

2025-01-18 TPMs and the Linux Kernel: unlocking a better path to hardware security - Ignat Korchagin - YouTube { www.youtube.com }

GPT Summary:

• Introduction to TPMs: Trusted Platform Modules (TPMs) are passive hardware security chips widely available in modern laptops and servers. They are primarily used for cryptographic key management, platform integrity, and remote attestation, providing hardware-backed security for sensitive operations.
• TPMs in Application Development: Despite their ubiquity, TPMs are rarely used directly by applications. Developers face challenges such as complex interfaces, limited documentation, and the absence of seamless support in common libraries and tools.
• Complexity of TPM Interaction: Using TPMs involves navigating multiple layers:
  1. Resource Managers: Necessary to serialize access to the TPM, which cannot handle multiple concurrent requests. Linux provides an in-kernel resource manager (/dev/tpmrm0) to simplify this.
  2. TPM Libraries: Competing implementations (Intel TSS and IBM TSS) have incompatible APIs, forcing developers to make early, limiting choices.
• Linux Kernel Key Retention Service: A subsystem of the Linux kernel that securely stores cryptographic keys in kernel memory, ensuring their isolation from user-space processes. It supports multiple key types (e.g., user, logon, and trusted keys) and organizes keys into hierarchical key rings with fine-grained permissions.
• Trusted Keys with TPM Integration: Trusted keys leverage TPMs to encrypt key material into "wrapped blobs," ensuring plaintext keys are never exposed to user space. The kernel automatically decrypts these blobs when needed, making it a lightweight software HSM.
• Key Management Challenges: Current trusted key implementation requires applications to manage wrapped blobs manually, which complicates key recovery, persistence, and scaling, especially for stateless systems or devices with limited storage.
• Key Derivation from TPMs: A proposed approach uses TPM seed values and application-specific metadata to deterministically derive cryptographic keys. This method eliminates the need for persistent key storage and enables scalable, reproducible key management.
• Linux Crypto API and Kernel Key Store Integration: The Linux Crypto API allows applications to offload cryptographic operations to the kernel using cryptographic sockets. A recent patch integrates this API with the key store, enabling cryptographic operations using kernel-managed keys without exposing them to user space.
• Request Key System Call Enhancements: The request_key syscall is extended to allow dynamic retrieval of application-specific keys. A plugin-based architecture lets the kernel call user-space helpers (e.g., TPM-aware plugins) to derive or retrieve keys as needed.
• Stateless Key Derivation with TPMs: The stateless key derivation method uses TPMs to create keys tied to application metadata (e.g., executable paths, user IDs, or code hashes). These keys are reproducible and isolated by design, making them suitable for ephemeral or IoT systems.
• Kernel-Based Key Derivation: A proposed kernel patch would eliminate user-space exposure of key material entirely by performing key derivation directly in the kernel, ensuring plaintext keys remain within secure kernel memory.
• Limitations of Current TPM Integration: Existing systems primarily support symmetric key operations. Asymmetric key functionality, such as signing or private key decryption, remains under development and is expected in future kernel releases.
• Improving Accessibility for Developers: By exposing TPM functionality through the Linux key retention service, developers can leverage hardware-backed security without needing to understand TPM internals, providing a more accessible pathway for application adoption.
• Call for Community Feedback: The speaker sought input on the practicality of proposed solutions for IoT and stateless systems, emphasizing the importance of balancing security, scalability, and developer usability.

2025-01-18 Memory Safety: Rust vs. C - Robert Seacord - NDC TechTown 2024 - YouTube { www.youtube.com }

GPT Summary:Background and Context: The talk originates from a memory-safe languages panel led by government and industry stakeholders. There is a push, particularly from governments like the U.S. and other Five Eyes members, to migrate critical systems from C and C++ to "memory-safe languages" like Rust. The speaker, while defending C and C++, acknowledges biases and stresses the importance of fair evaluations between languages.

Challenges of Defining "Memory-Safe Languages": The panel has inconsistently defined key terms. A "low-level memory-safe language" (essentially Rust) is distinguished from garbage-collected ones like Java or Python. The main critique of C/C++ centers not on the inherent inability to ensure memory safety but on the lack of compiler-enforced memory safety, leaving discipline and external tools to fill the gap.

Types of Safety: The talk breaks down safety concerns into type safety, memory safety, and thread safety, each foundational to broader software security and functional safety. Functional safety ensures systems like brakes or airplane controls continue operating safely, even under partial failure.

Arguments for C/C++ in Safety-Critical Systems: Safety-critical systems in aerospace, automotive, and other domains rely on C/C++ due to decades of tooling, standards (e.g., ISO 26262), and expertise. The deterministic nature of these languages aligns with strict timing and behavior guarantees, which are harder to achieve with garbage collection or immature ecosystems.

Rust's Growing Role and Barriers: Rust, though promising, faces ecosystem maturity challenges. The availability of Rust-trained engineers, tooling gaps (e.g., in platforms like MathWorks), and reliance on interoperability with C APIs present barriers. Rust's adoption in safety-critical domains remains limited due to these hurdles and the immense cost of rewriting existing, battle-tested codebases.

Security Concerns Beyond Memory Safety: Eliminating memory safety issues does not address broader vulnerabilities like input validation, SQL injection, or business logic errors. For example, tools in C/C++ like AddressSanitizer (ASan) can address memory safety issues but are unsuitable for production. Security is a multi-faceted problem that Rust alone cannot solve.

Progress in C and C++: Modern updates in C (e.g., C23's checked integer operations) and C++ aim to close gaps in safety. Tools like UBSan, ASan, and static analysis have matured, enabling effective error detection and mitigation in development. The C/C++ ecosystem has advanced to rival or even surpass memory-safe languages in certain safety-critical applications.

Cost and Practicality of Transition: Rewriting massive C/C++ systems into Rust or any other language without adding new features is seen as economically unviable. Transition timelines are long, involving curriculum changes, workforce training, and standards development. Safety-critical systems tend to evolve incrementally rather than through wholesale rewrites.

Critique of the Panel's Conclusions: The speaker criticizes the panel's narrow focus on memory safety as overly simplistic. Broader issues like ecosystem maturity, tooling availability, and compatibility with safety standards make the wholesale dismissal of C and C++ impractical and misguided.

Closing Thoughts: The speaker emphasizes a balanced, pragmatic approach to safety and security. Transitioning to Rust or any new language must account for all engineering realities, including ecosystem readiness, regulatory compliance, and the multifaceted nature of software vulnerabilities.

2025-01-18 How Simple Is "As Simple As Possible"? - Rendle . - NDC Porto 2024 - YouTube { www.youtube.com }

Simplifying Software Development: A Rant on Doing Less, Better

This is a talk about how we’re overcomplicating software for no good reason. It’s about keeping things simple and just building systems that work instead of getting lost in trends, tools, and buzzwords.

The speaker kicks off with a nostalgic dive into the early days of coding on Tandon 286 machines, soldering RS232 cables by hand, and building monoliths that simply did the job. “We wrote software that people used, they got their jobs done, and went home happy. No internet, no GitHub repos -- just code that worked.”

Fast forward to today, and things are a mess. Microservices? Great if you’ve got a thousand developers and a global scale problem. If not, you’re probably just smashing your monolith into tiny, unmanageable pieces. “If you’ve got fewer than 100 programmers and you’re doing microservices, I will find you and kick your shins.”

The same critique extends to APIs. SOAP was overkill; REST simplified things (or did it?), but now we’re stuffing APIs with metadata, inventing gRPC, or obsessing over “hypermedia” that no one asked for. “Just send some JSON over HTTP and call it a day. We don’t need another doctoral thesis to justify URLs.”

And don’t even get started on frontends. React, Angular, Vue -- they’re all bloated monstrosities. “140MB of node modules to load a blank page? What are we even doing?” The solution? Go back to server-side rendering or use lightweight tools like HTMX. “We solved these problems years ago, but no -- let’s reinvent them with more JavaScript.”

On infrastructure, the speaker points to Kubernetes as a classic example of overengineering. “Most of us don’t need it, but we’re running it anyway because it sounds cool. Just use containers properly and let the cloud handle the rest.”

The takeaway is simple: stop making things harder than they need to be. “If you’re adding complexity just to look good on your CV, you’re doing it wrong. Just build stuff that works, keep it simple, and fix it when it breaks. Complexity isn’t clever; it’s stupid.”

The talk wraps with humor but drives the point home: "Stop overcomplicating things. Build what you need. Then go get a beer."

2025-01-13 Why You're Not Getting Promoted To Senior (ex-Amazon Principal) - YouTube { www.youtube.com }

To become a senior engineer, understanding what blocks promotions and taking deliberate actions to address those barriers is crucial. Based on the advice provided, here are the key takeaways and actionable insights:

One common misconception is that excellent technical skills alone will secure a promotion. Many engineers hit a plateau despite being technically competent because they overlook critical non-technical factors. According to the speaker, three specific roadblocks hinder promotions, and addressing these can change your trajectory.

The first roadblock is ineffective delegation. Promotions often require demonstrating leadership, and delegation is a cornerstone of this. However, not all delegation styles are equally effective:

• The Load Balancer: Merely distributing tasks among the team doesn’t showcase leadership or improve team capabilities. "Tasks come in, and you spread them out to others on your team." This approach doesn't reduce overall workload or scale your impact.
• The Decomposer: Breaking down ambiguous problems into smaller, executable tasks is better, but it's still an expected responsibility at most levels. It doesn’t elevate you as a leader.
• The Capability Multiplier: This is the ideal approach. By assigning challenging problems to team members and coaching them through the process, you scale your impact by developing the team. "You coach them up, tell them how you would handle the situation, and let them handle the problem on their own." The critical elements of this approach are:
  • Knowing your team’s capabilities to assign tasks slightly outside their comfort zone.
  • Investing time upfront to coach them while stepping away to give them ownership.
  • Accepting the possibility of failure as part of their growth.

Effective delegation demonstrates leadership by "creating copies of yourself," a trait highly valued in promotion decisions.

The second roadblock is a weak relationship with your manager. Promotions often hinge on managerial support. Managers are hesitant to risk promoting someone who might fail at the next level, as this reflects poorly on them and disrupts team dynamics. The speaker emphasized: "Your manager is the biggest roadblock to getting promoted to senior... They only do that for people that they trust."

To strengthen this relationship:

• Clearly communicate your desire for promotion and ask for specific feedback.
• Build trust by consistently delivering results and taking ownership of problems.
• Repair any strained relationships or consider moving to a different team if necessary.

The third roadblock is failing to demonstrate leadership by owning problems. To advance to senior engineer, you must show initiative in solving team-level issues. The story of David, an engineer striving for promotion, illustrates this. Despite his technical excellence, his promotion was blocked because he raised problems without presenting solutions. Leadership involves not just identifying issues but also proactively addressing them.

For example:

• If user adoption is low, suggest prioritizing features to improve engagement.
• If defect rates are high, identify patterns or implement training for improvement.
• If operational load is causing attrition, propose forming a task force to resolve it.

"High-level ICs are leaders that don't have direct reports. Leaders take ownership of problems and do something about them."

In summary, focus on scaling through delegation, building trust with your manager, and demonstrating leadership through problem ownership. These strategies will position you as a strong candidate for promotion to senior engineer.

CS50 Cybersecurity - Lecture 1 - Securing Data

Also:

2024-12-18 CS50 Cybersecurity - Lecture 2 - Securing Systems - YouTube { www.youtube.com }

1. Password Security and Hashing

• Storing Passwords: Early systems stored plaintext passwords like "alice: apple," which is insecure.
• Hashing Passwords: Converts passwords into fixed-length strings using a hash function.
• Simple vs. Proper Hash Functions: Early functions were simplistic (A=1, B=2) but proper hashing creates cryptic outputs.
• Salting Passwords: Adds a random value (salt) to passwords before hashing to produce unique hashes. Salt is stored alongside the hash.
• Password Authentication: Input password is hashed and compared to the stored hash.
• Hashing Vulnerabilities: Brute force attacks, rainbow tables, and shared password issues are mitigated with salting.
• Best Practices: Use industry standards like NIST guidelines, avoid creating custom hashing functions, and rely on proven libraries.

2. Encryption and Cryptography

• Cryptography: Secures data in transit and at rest using encryption.
• Types: Codes (word substitution) and ciphers (character manipulation).
• Encryption Keys: Symmetric encryption uses the same key for encryption/decryption; asymmetric encryption uses a public-private key pair.
• Encryption Algorithms: AES and Triple DES (symmetric); RSA, Diffie-Hellman (asymmetric).
• Asymmetric Key Cryptography: Involves public and private keys; RSA encrypts with a public key, decrypts with a private key.
• Key Exchange Problem: Diffie-Hellman allows two parties to establish a shared secret key without prior communication.
• Encryption vs. Hashing: Hashing is one-way and irreversible; encryption is two-way and reversible.

3. Digital Signatures and Verification

• Digital Signatures: Authenticate and verify the origin of a message or document.
• How They Work: Message is hashed, then encrypted with a private key to create the signature, which is verified using the public key.
• Purpose: Ensures integrity, authenticity, and non-repudiation of messages or contracts.

4. Public Key Infrastructure (PKI)

• Concept: Relies on a trusted system to verify public keys belong to specific entities.
• Key Roles: Public keys are shared, private keys are secret. Certificate Authorities (CAs) issue digital certificates to confirm key authenticity.

5. Passkeys and Passwordless Authentication

• Passkeys: Replace passwords with biometrics (fingerprint, face scan) or PINs.
• How Passkeys Work: Device generates a public-private key pair per website. Public key is shared, private key stays on the device.
• Authentication Process: Websites send a challenge; user signs it with the private key. Website verifies using the stored public key.
• Benefits: No need for passwords, increased security, supported by Apple, Google, and Microsoft.

6. Encryption in Transit vs. Encryption at Rest

• Encryption in Transit: Protects data as it moves from point A to point B. Used in protocols like HTTPS. Prevents "man-in-the-middle" attacks but may allow the middle server (like Gmail) to see the data.
• End-to-End Encryption (E2EE): Encrypts data so only the sender and recipient can see it. Used by WhatsApp and iMessage. Intermediaries can't decrypt it.
• Encryption at Rest: Encrypts stored data on devices (like hard drives) to protect against theft or loss.

7. File Deletion and Secure Deletion

• File Deletion: Deleting a file just removes references to it; data is still present until overwritten.
• Secure Deletion: Overwrites 0s, 1s, or random bits to ensure no file remnants remain. Full-disk encryption makes secure deletion automatic.
• Device Disposal: Use full-disk encryption to ensure data is unreadable when selling or giving away devices.

8. Ransomware Attacks

• What is Ransomware?: Malware encrypts files and demands payment (often in Bitcoin) for the decryption key.
• How it Works: Hackers encrypt system files and request payment to decrypt them.
• Prevention: Use full-disk encryption and regular backups to prevent data loss.

9. Quantum Computing and Its Impact on Cybersecurity

• Quantum Computing: Uses qubits that can be in multiple states simultaneously, increasing computational power exponentially.
• Threat to Security: Could break current encryption algorithms like RSA due to greater computing power.
• Quantum-Safe Cryptography: Research is underway for "post-quantum cryptography" to withstand quantum attacks.

2024-12-20 Domain Modeling Made Functional - Scott Wlaschin - KanDDDinsky 2019 - YouTube { www.youtube.com }

GPT Summary:Functional Programming for Domain Modeling: Functional programming simplifies modeling by separating data and behavior. It uses composable types to reflect domain concepts clearly, allowing you to model workflows and real-world scenarios with precision.

Code Reflects the Domain: Code should represent the domain's shared mental model. Concepts like "suit" or "rank" in a card game are directly encoded into the structure, ensuring that the vocabulary in code matches the language of domain experts.

Static Typing as a Domain Modeling Tool: Types are not just for error-checking but are integral to domain modeling. They enforce rules at compile-time, reducing the need for defensive programming or runtime validation. This provides compile-time unit testing for domain correctness.

Composable Type Systems: Composable type systems build new types from smaller ones using "and" (records/tuples) and "or" (choices). These allow for flexible, modular designs that adapt to changing domain requirements.

Eliminating Null Values: Null values are error-prone and should be replaced with optional types (e.g., Option<T>), which explicitly represent the presence or absence of a value. This makes code safer and self-documenting.

Replacing Primitive Types: Avoid using primitive types like string or int for domain-specific data. Instead, use wrappers (e.g., EmailAddress or CustomerID) to enforce constraints and ensure clarity.

Replacing Boolean Flags with Choices: Boolean flags are ambiguous and prone to misuse. Replace them with choice types (e.g., VerifiedEmail vs. UnverifiedEmail) to enforce business rules explicitly in the type system.

Immutability in Functional Programming: Immutability ensures that once data is validated and encapsulated, it cannot change. This eliminates repetitive validation and simplifies reasoning about state changes in the domain.

Rapid Feedback and Iteration: Collaborating with domain experts while modeling in code provides immediate feedback. This approach allows adjustments to domain understanding and code simultaneously, shortening feedback loops from weeks to minutes.

Modeling Constraints Explicitly: Use types to encode constraints, such as a string with a maximum length (String50) or a positive integer for quantities (OrderQuantity). This prevents invalid states and enforces constraints at the type level.

Making Illegal States Unrepresentable: Design your system so that invalid states (e.g., an unverified email being treated as verified) cannot be represented in the code. This reduces the need for runtime validation and minimizes bugs.

Separating Domain Logic from Implementation Details: Keep domain logic independent of technical concerns like database schemas or persistence. This is often referred to as persistence ignorance.

Refactoring Towards Deeper Insight: As you learn more about the domain, refactor code to introduce new concepts (e.g., ShuffledDeck or VerifiedEmail). This process evolves the domain model to better reflect reality.

Explicitly Modeling Relationships and Constraints: For example, if an entity must have an email or a postal address, model this as a choice type (e.g., EmailOnly, AddressOnly, or Both). This avoids ambiguous states and ensures correctness.

Process Over Product: The modeling process itself -- collaborating with stakeholders, defining concepts, and refining understanding -- is as important as the resulting code. The shared mental model is the foundation of success.

Code as a Living Document: Code is the ultimate source of truth in functional modeling. Unlike UML diagrams or external documentation, code evolves with the domain and remains in sync with business logic.

Enforcing Business Rules in the Type System: Business rules like "password resets require a verified email" can be encoded directly in the type system. This eliminates the need for external checks and makes rules unbreakable.

Modeling Actions with Functions: Actions in the domain (e.g., dealing a card or verifying an email) are modeled as functions with explicit inputs and outputs, reflecting the transformation of domain state.

Avoiding Programmer Jargon in Domain Models: Terms like "base class," "factory," or "proxy" should not appear in the domain model. Use only terms that stakeholders understand.

Facilitating Non-Programmer Feedback: Modeling in code allows non-developers to participate in reviewing and refining the domain model, ensuring alignment between technical and business perspectives.

Domain-Driven Design and Functional Programming as Allies: Functional programming and domain-driven design complement each other, providing tools for creating robust, accurate, and easily understood models of complex domains.

Use of Algebraic Data Types (ADTs): ADTs like records and discriminated unions are powerful tools for expressing complex domain concepts naturally, allowing for greater expressiveness and error prevention.

Encapsulation of Validation: Validation is done at the boundaries of the system (e.g., API inputs) and not repeatedly in the domain logic. Once data is validated, it is immutable and safe to use.

Encouraging Collaboration with Shared Language: The modeling process ensures that all stakeholders -- developers, domain experts, and product owners -- share a common understanding of the system through a ubiquitous language.

Flexibility and Extensibility: The compositional approach makes it easier to adapt the domain model to new requirements without introducing significant complexity.

2024-12-20 Introduction to Wait-free Algorithms in C++ Programming - Daniel Anderson - CppCon 2024 - YouTube { www.youtube.com }

GPT Summary:Concurrency Concepts and Lock-Free Programming: Concurrency issues arise when multiple threads access shared resources simultaneously, potentially causing errors. Lock-based programming avoids these problems but can degrade performance due to contention. Lock-free programming ensures system-wide progress but does not guarantee individual thread progress. Key tools include atomic operations like compare-and-swap (CAS), fetch-add, and fetch-sub.

Weight-Free Algorithms: Weight-free algorithms improve on lock-free by guaranteeing progress for all threads within bounded steps. This is achieved through collaboration among threads instead of competition. The helping mechanism, where threads assist ongoing operations rather than blocking or overriding them, is central to weight-free design.

Sticky Counter as a Case Study: A weight-free counter that supports increment, decrement, and read operations was used to demonstrate weight-free algorithm design. Challenges like linearizability, handling "zero" states, and edge cases like thread descheduling were addressed using flag bits and the helping principle, ensuring correctness and bounded progress.

Design Challenges and Subtleties: Weight-free algorithms require significant redesign, as they must enable threads to detect and assist in-progress operations. Concepts like linearizability ensure that operations appear to happen in a sequential order, even if they overlap in execution. Testing and formal verification are critical for validating correctness, as subtle bugs can arise in complex concurrent systems.

Performance Implications: Weight-free algorithms perform better in high-contention scenarios, especially when operations like reads are frequent. However, performance depends on the workload. Benchmarks showed that while weight-free algorithms often outperform lock-free ones in certain workloads, lock-free approaches can be faster when contention is low or writes dominate.

Progress Guarantees and Practical Constraints: The talk clarified terms like blocking (no progress), lock-free (system-wide progress), and weight-free (thread-level progress). It emphasized that real-world constraints, such as thread scheduling and hardware architecture, must be considered when implementing concurrent algorithms.

2025-01-01 "Junior developers can't think anymore..." - YouTube { www.youtube.com }

2025-01-02 12 Months After Layoff - The Blunt Truth - YouTube { www.youtube.com }

Good Reads​

2024-12-28 Developer with ADHD? You’re not alone. - Stack Overflow {stackoverflow.blog}

Reddit: 2024-12-28 Got ADHD? Program computers? Even close with either? Talk about it here. {www.reddit.com}

Many developers with ADHD feel their job is a perfect fit for how they think and approach problems. “Coding can give ADHD brains exactly the kind of stimulation they crave,” explains full-stack developer Abbey Perini. “Not only is coding a creative endeavor that involves constantly learning new things, but also once one problem is solved, there’s always a brand new one to try.”

In addition to a revolving door of fresh challenges that can keep people with ADHD engaged, coding can reward and encourage a state of hyperfocus: a frequently cited symptom of ADHD that developer Neil Peterson calls “a state of laser-like concentration in which distractions and even a sense of passing time seem to fade away.”

2024-12-20 How types make hard problems easy • { mayhul.com }

2024-12-16 The 70% problem: Hard truths about AI-assisted coding { addyo.substack.com }

found in programmingdigest issue1798 { programmingdigest.net }

The hidden cost of "AI Speed": When you watch a senior engineer work with AI tools like Cursor or Copilot, it looks like magic. They can scaffold entire features in minutes, complete with tests and documentation. But watch carefully, and you'll notice something crucial: They're not just accepting what the AI suggests. They're constantly:

• Refactoring the generated code into smaller, focused modules
• Adding edge case handling the AI missed
• Strengthening type definitions and interfaces
• Questioning architectural decisions
• Adding comprehensive error handling

In other words, they're applying years of hard-won engineering wisdom to shape and constrain the AI's output. The AI is accelerating their implementation, but their expertise is what keeps the code maintainable.

The knowledge paradox: Here's the most counterintuitive thing I've discovered: AI tools help experienced developers more than beginners. This seems backward – shouldn't AI democratize coding?

The reality is that AI is like having a very eager junior developer on your team. They can write code quickly, but they need constant supervision and correction. The more you know, the better you can guide them.

This creates what I call the "knowledge paradox":

• Seniors use AI to accelerate what they already know how to do
• Juniors try to use AI to learn what to do
• The results differ dramatically

I've watched senior engineers use AI to:

• Rapidly prototype ideas they already understand
• Generate basic implementations they can then refine
• Explore alternative approaches to known problems
• Automate routine coding tasks

Meanwhile, juniors often:

• Accept incorrect or outdated solutions
• Miss critical security and performance considerations
• Struggle to debug AI-generated code
• Build fragile systems they don't fully understand

2024-12-16 A 10 Year Retrospective of a Passionate Software Engineer | by Boris Cherkasky | Nov, 2024 | Medium { cherkaskyb.medium.com }

found in programmingdigest issue1798 { programmingdigest.net }

Take Ownership of Your Career No one is responsible for your career growth but you. While managers may offer guidance, the responsibility to seek opportunities, take initiative, and drive your own development is yours alone. Waiting for someone else to guide your progression will leave you stagnant.

"No one is responsible for your career path but you."

Seek Mentorship — It’s a Shortcut to Mastery A mentor can accelerate your growth by giving you insights, sharing their decision-making process, and exposing you to higher-level thinking. Actively seek out senior engineers, build relationships, and ask questions. This can be one of the most effective ways to "level up" faster than self-learning alone.

"Having a mentor is a force multiplier! It’s literally a means to learn faster, it’s a shortcut!"

Initiative is Always Rewarded No employer will think less of you for taking initiative. If something is blocked, find a way around it. Push for better solutions, offer new ideas, and take on challenges without being asked. This attitude of "full ownership" sets you apart. Engineers who "unblock themselves" — even by learning disciplines outside their core expertise — become the most valuable contributors.

"Nothing is more important than making your colleagues feel comfortable and safe working with you."

The Dunning-Kruger Effect is Real — Be Humble and Self-Aware At some point, you will overestimate your own skills. Recognizing this gap is essential for growth. Take feedback seriously, reflect on your mistakes, and focus on learning through deliberate practice. Switch from "just get it done" to "learn all you need to do it right." This mindset shift will elevate your skill set.

Master the "Glue Work" That Holds Teams Together It’s not enough to just write code. The ability to coordinate, track, and organize work is a rare and valuable skill. Acting as the "glue" between people, projects, and teams will make you indispensable. Track tickets, follow up on blockers, and ensure no one is left behind. Great engineers don’t just "code" — they also lead, unblock, and delegate.

Technical Excellence is Necessary, But Not Sufficient You can be a great coder, but without skills like communication, empathy, and coordination, you won’t become a senior engineer. Learn to bridge the gap between engineers, product managers, and customers. Senior engineers know how to translate customer requirements into engineering solutions and help their teams grow.

Learn to See the Business, Not Just the Code As you grow in your career, it’s not just about building "good" software — it’s about building software that drives business outcomes. Learn to ask, "How will this impact our KPIs?" and prioritize cost-efficient, high-impact solutions. This business-first mindset can distinguish you as a senior engineer and lead to better decision-making.

"At one point, we scratched the 'optimal solution' for a good enough, 10x cheaper solution. Engineering is all about tradeoffs."

Resilience and Observability Are Non-Negotiable Skills Handling production incidents teaches you to value system reliability, observability, and DevOps. As you progress, mastering monitoring, alerting, and on-call response will become essential. Developers who "speak infrastructure" become highly valuable, as they can ensure stability and avoid system failure.

"It became clear that being a developer that 'speaks' and understands infrastructure is a superpower, and a differentiating factor."

Continuous Learning is Not Optional The craft of software engineering evolves rapidly. Relying on daily work alone will not keep you at the top. You need to invest in side learning — read books like Clean Code and Designing Data-Intensive Applications, attend meetups, seek mentorship, and watch technical talks. Growth requires time and passion outside daily tasks.

"Learning through daily tasks is not enough for becoming a top-tier engineer. The craft and technology are just too complex and require a lot of passion and time."

Be a Decent Human Being — It Matters More Than You Think Nothing beats being a kind, respectful, and empathetic teammate. People remember how you make them feel. Psychological safety and trust are essential for high-performing teams. As you grow into senior roles, prioritize creating safe, welcoming environments where people can speak up, share ideas, and fail without fear of judgment.

"Nothing — and I mean it — Nothing! is more important than being a decent human being, a pleasant colleague, and a pragmatic engineer."

2024-12-15 Preferring throwaway code over design docs { softwaredoug.com }

Another important point is on using PRs for documentation. They are one of the best forms of documentation for devs. They’re discoverable - one of the first places you look when trying to understand why code is implemented a certain way. PRs don’t profess to reflect the current state of the world, but a state at a point in time. A historical artifact. On the other hand, most design docs lie to you. They’re undead documentation. Unless you’re fastidious of keeping them up to date (most of us aren’t) they reflect an outdated view of reality.

2024-12-14 3 shell scripts: Kill weasel words, avoid the passive, eliminate duplicates { matt.might.net }

2024-12-11 From where I left - antirez { antirez.com }

The blog post by Salvatore Sanfilippo (antirez) reflects on his journey with Redis, his departure, and his decision to return. He also shares insights into Redis's past, his thoughts on software licensing, and new technical concepts he's working on, such as vector sets for Redis. Below is a detailed digest of the key points from the article.

After leaving Redis about 4.4 years ago, Salvatore detached himself from the project's code, commits, and technical management. This detachment was not born out of resentment but rather a desire to explore other areas like writing and embedded projects, while also spending more time with family. He describes this period as a time to "hack randomly" and explore areas like neural networks and Telegram bots. However, this "random hacking" eventually left him feeling a lack of purpose, which reignited his desire to return to the tech world.

"Hacking randomly was cool but, in the long run, my feeling was that I was lacking a real purpose, and every day I started to feel a bigger urgency to be part of the tech world again."

Salvatore's return to Redis began during a trip to New York City with his 12-year-old daughter. Reflecting on life changes and purpose, he decided to re-engage with Redis. This led to a conversation with the new Redis CEO, Rowan Trollope, where they discussed Salvatore's possible role. He proposed becoming a bridge between Redis Labs and the Redis community, creating educational materials like demos, tutorials, and new design concepts. An agreement was quickly reached, allowing him to rejoin Redis in a part-time role.

"I wrote him an email saying: do you think I could be back in some kind of capacity? Rowan showed interest in my proposal, and quickly we found some agreement."

2024-12-10 What TDD is ACTUALLY Good For – Axol's Blog { theaxolot.wordpress.com }

In an earlier article, I tore through some terrible arguments used to advocate for TDD that I see all too often (even by experienced engineers). I said in that piece that I would eventually go through what I think are better arguments for TDD, so that’s what I’m gonna do now.

Brownfield work also lends itself well to TDD, but less so. It depends on the complexity of the new feature, and the extendibility of the codebase. You have to use your best judgment. If it seems like a feature requires significant changes to existing modules, I’d lean on traditional development. However, if you see a gentle path to implementing this new feature, you might reap more benefits with TDD.

Greenfield development is a big no-no for TDD (at first). I don’t care how confident you are in what your interfaces will be. You’re not that good. Everything you think you know will change in the exploratory phase of a new project as you code, and you’ll strain your sanity by rewriting tests over and over again. Don’t do this, no matter how much your TDD idol pontificates its benefits.

BuT iF yOuR’e ReWrItInG yOuR tEsTs So MuCh, YoU’rE nOt PrAcTiSiNg TdD pRoPeRlY.”

2024-12-28 Ask HN: Are you unable to find employment? | Hacker News { news.ycombinator.com }

es, this is what everybody I know is experiencing right now.

Caveat lector: This is simply a retelling of my personal experience, YMMV. This is not advice.

What has consistently worked for me: I stopped applying for jobs, and redirected all that effort into creating and publishing open source projects that demonstrate competence in the areas of work I want. And, just as importantly, I contribute to big established open source projects in those areas too.

I did not apply for my current job (started 6 months ago): they solicited me, based on my open source work. All the best jobs I've had have been like that, this is the 3rd time it worked.

When I'm unemployed, I only apply for jobs I actually want, typically spending an hour each on 0-2 extremely targeted applications per week. But I treat churning out new open source stuff as my full time job until somebody notices. In addition to successfully landing me three great jobs over the past decade, this approach has made me a much much better programmer.

Also, I strongly believe spending hours a day writing new code will enhance your ability to pass technical interviews much more than gamified garbage like leetcode.

A huge part of making this work is not living a typical valley lifestyle: I plan my life around the median national salary for a software engineer, and when I'm making more than that it all goes straight into my savings. In the bay, that requires living frugally (by bay standards...), but I can't even begin to put into words how grateful I am to past-decade-me for living like that and giving today-me the freedom to turn down the bad jobs and wait for the good ones. Obviously, I don't have children.

I do a lot more open source than a typical programmer in the valley, but I don't think I'm "exceptional" in any sense: you just have to put in the work. I do feel like I was very lucky to start my career in an extremely open-source-centric role, and in fairness that gives me a leg up here which I am probably inclined to underestimate.

Working with People​

2024-12-05 How to Grow Professional Relationships | Tejas Kumar { tej.as }

In my career, I’ve worked with some extraordinary people while also encountering the barriers of exclusionary cliques and gatekeeping. These experiences prompted me to examine how professional relationships develop, leading to the creation of the TJS (The Journey to Synergy) Collaboration Model. This framework identifies seven stages that relationships can pass through, from competitive isolation to productive collaboration.

For those striving to build stronger, more impactful connections—whether in business, creative endeavors, or personal growth—this model offers a clear lens to understand where you stand and how to move forward.

The 7 Stages of the TJS Collaboration Model: A Quick Digest

1. Everything is a Competition Relationships are marked by exclusion and a zero-sum mindset. Gatekeeping and discrimination dominate, with little to no collaboration or shared goals.
2. Coexist Acknowledgment of each other's existence without meaningful interaction. There’s mutual respect but little effort to engage, often due to differing goals, values, or personalities.
3. Communicate Basic exchange of information occurs, but interactions remain shallow. Conversations may begin, but follow-through and deeper engagement are often lacking.
4. Cooperate Parties work together on neutral, low-stakes tasks with transactional motives. Cooperation may lead to future opportunities but doesn’t yet involve deep trust or shared investment.
5. Coordinate One party adopts the other’s goal and takes deliberate steps to align efforts. Trust begins to form as actions are coordinated for mutual benefit, laying the groundwork for deeper collaboration.
6. Collaborate A shared project is created together, with both parties contributing equally and meaningfully. Trust, understanding, and synergy define this stage, as both sides grow from the partnership.
7. We Are the Same A toxic state where boundaries dissolve, leading to unhealthy co-dependence. Individuality is lost, and relationships suffer from over-enmeshment and burnout.

2024-12-07 ✨ The 6 Mistakes You’re Going to Make as a New Manager – Terrible Software { terriblesoftware.org } { people management} {engineering management}

The right amount of engagement that you should have in your team’s projects is also a tricky subject. Lean in too much, and you’re micromanaging; lean out too much, and you appear disengaged.

To find the right balance, consider the concept of Guided Autonomy. This means setting clear goals and expectations, then stepping back and letting your team figure out how to achieve them.

As an individual contributor (IC), your work spoke for itself; people could easily see it. Plain and simple. As a manager, it’s less black and white, and surprisingly, for many new managers, part of your job now involves managing how others see you.

2024-12-07 1 in 6 Companies Are Hesitant To Hire Recent College Graduates - Intelligent { www.intelligent.com }

2024-12-09 The One Good Reason to Become a Manager (and All the Bad Ones) – Terrible Software { terriblesoftware.org }

Espanso​

2024-11-07 Espanso - A Privacy-first, Cross-platform Text Expander { espanso.org }

2024-11-07 espanso/SECURITY.md at master · espanso/espanso { github.com }

2024-11-07 Using Espanso to boost Efficiency 🚤 | Alicia's Notes 🚀 — Than... { notes.aliciasykes.com }

Really good collection of examples.

# Outputs markdown link, with clipboard contents as the URL
- trigger: ":md-link"
  replace: "[$|$]({{clipboard}})"
  vars:
  - name: "clipboard"
    type: "clipboard"

# Creates a HTML anchor element, with clipboard contents as href
- trigger: ":html-link"
  replace: "<a href=\"{{clipboard}}\" />$|$</a>"
  vars:
  - name: "clipboard"
    type: "clipboard"

# Outputs BB Code link, with clipboard contents as the URL
- trigger: ":bb-link"
  replace: "[url={{clipboard}}]$|$[/url]"
  vars:
  - name: "clipboard"
    type: "clipboard"

NiX​

2024-08-29 An unordered list of hidden gems inside NixOS — kokada { kokada.dev }

2024-12-04 Deploying Containers on NixOS { bkiran.com }

WebDev​

2024-12-09 JSON5 – JSON for Humans | JSON5 { json5.org }

JSON5 is an extension to the popular JSON file format that aims to be easier to write and maintain *by hand* (e.g. for config files). It is not intended to be used for machine-to-machine communication. (Keep using JSON or other file formats for that. 🙂)

{
  // comments
  unquoted: 'and you can quote me on that',
  singleQuotes: 'I can use "double quotes" here',
  lineBreaks: "Look, Mom! \
No \\n's!",
  hexadecimal: 0xdecaf,
  leadingDecimalPoint: .8675309, andTrailing: 8675309.,
  positiveSign: +1,
  trailingComma: 'in objects', andIn: ['arrays',],
  "backwardsCompatible": "with JSON",
}

2024-12-19 How To Create Multi-Step Forms With Vanilla JavaScript And CSS | CSS-Tricks { css-tricks.com }

2024-10-10 Liskov's Gun: The parallel evolution of React and Web Components – Baldur Bjarnason { www.baldurbjarnason.com }

2024-10-09 Why Web Components Failed - YouTube { www.youtube.com }

2024-10-09 Web Components are not Framework Components — and That’s Okay • Lea Verou { lea.verou.me }

2024-10-09 JSON•Edit•React { carlosnz.github.io }

2024-10-09 CarlosNZ/json-edit-react: React component for editing/viewing JSON/object data { github.com }

2024-10-10 player.style - Video & audio player themes for every web player & framework { player.style }

Show HN: Winamp and other media players, rebuilt for the web with Web Components (player.style)

2024-10-10 Media Chrome Docs { www.media-chrome.org }

Inspiration!​

2024-12-29 How I Automated My Job Application Process. (Part 1) { blog.daviddodda.com }

Look, I'll be honest - job hunting sucks.

It's this soul-crushing cycle of copying and pasting the same information over and over again, tweaking your resume for the 100th time, and writing cover letters that make you sound desperate without actually sounding desperate.

But here's the thing: repetitive tasks + structured process = perfect automation candidate.

So I did what any sane developer would do - I built a system to automate the whole damn thing. By the end, I had sent out 250 job applications in 20 minutes. (The irony? I got a job offer before I even finished building it. More on that later.)

Let me walk you through how I did it. 2024-12-29 I automated my job application process | Hacker News { news.ycombinator.com }

• 2024-12-29 Do Things that Don't Scale { paulgraham.com }

2024-12-28 How to Create HTML/ZIP/PNG Polyglot Files | Polyglot-HTML-ZIP-PNG { gildas-lormeau.github.io }

Github: gildas-lormeau/Polyglot-HTML-ZIP-PNG: Learn how to create HTML/ZIP/PNG polyglot files in JavaScript

How to Create HTML/ZIP/PNG Polyglot Files

This article is a summary of the presentation available here. The resulting demo file can be downloaded at the end of the article. The repository can be found at https://github.com/gildas-lormeau/Polyglot-HTML-ZIP-PNG.

Introduction

SingleFile, a tool for web archiving, commonly stores web page resources as data URIs. However, this approach can be inefficient for large resources. A more elegant solution emerges through combining the ZIP format’s flexible structure with HTML. We’ll then take it a step further by encapsulating this entire structure within a PNG file.

2024-12-26 Frontend Developer Roadmap: What is Frontend Development? { roadmap.sh }

by Kamran Ahmed (@kamrify) / X { x.com } kamranahmed.info

2024-12-22 Keeping a CHANGELOG at Work – code.dblock.org | tech blog { code.dblock.org }

2024-12-22 Draw all roads in a city at once { anvaka.github.io }

City Roads: A tool to draw all roads in a city at once

2024-12-21 Designing a calm web reader | James' Coffee Blog { jamesg.blog }

Github: capjamesg/web-reader: A minimal web reader.

2024-12-21 Show HN: Artemis, a Calm Web Reader | Hacker News { news.ycombinator.com }

2024-12-21 Lenns.io - Lenns.io { lenns.io }

RSS The feed reader for people that want to be in control

2024-12-21 Instaloader — Download Instagram Photos and Metadata { instaloader.github.io }

2024-12-21 Grayjay App - Follow Creators Not Platforms { grayjay.app }

2024-12-20 apankrat/nullboard: Nullboard is a minimalist kanban board, focused on compactness and readability. { github.com }

Nullboard is a minimalist take on a kanban board / a task list manager, designed to be compact, readable and quick in use.

2024-12-20 mizu.js | Lightweight HTML templating library for any-side rendering { mizu.sh }

2024-12-16 Alien Covenant (Movie Review) — Boy Drinks Ink { boydrinksink.com }

2024-12-16 Displaying Website Content on an E-Ink Display | Marios Fasold's Website { mfasold.net }

2024-12-13 Perspective | Perspective { perspective.finos.org }

2024-12-13 finos/perspective: A data visualization and analytics component, especially well-suited for large and/or streaming datasets. { github.com }Perspective is an interactive analytics and data visualization component, which is especially well-suited for large and/or streaming datasets. Use it to create user-configurable reports, dashboards, notebooks and applications, then deploy stand-alone in the browser, or in concert with Python and/or Jupyterlab.

Features

• A fast, memory efficient streaming query engine, written in C++ and compiled for WebAssembly, Python and Rust, with read/write/streaming for Apache Arrow, and a high-performance columnar expression language based on ExprTK.
• A framework-agnostic User Interface packaged as a Custom Element, powered either in-browser via WebAssembly or virtually via WebSocket server (Python/Node).
• A JupyterLab widget and Python client library, for interactive data analysis in a notebook, as well as scalable production Voila applications.

Found in: ✉️ 2024-12-13 JavaScript Weekly Issue 716: December 12, 2024 { javascriptweekly.com }

2024-12-13 Termo - An Easy to use terminal for your browser { termo.rajnandan.com }

Termo is a simple terminal emulator that can be used to create a terminal-like interface on your website. It is inspired by the terminal emulator in stripe.dev. It is an wrapper on top of xterm.js.

Found in: ✉️ 2024-12-13 JavaScript Weekly Issue 716: December 12, 2024 { javascriptweekly.com }

2024-12-07 ibttf/interview-coder { github.com }

An invisible desktop application that will help you pass technical interviews

2024-12-07 Install Docker natively on Android Phone and use it as a Home Server | CrackOverflow { crackoverflow.com }

In this tutorial, we will guide you through the process of installing Docker on your Android phone, specifically using a OnePlus 6T with postmarketOS. I also wrote another blog post explaining how you can run this phone without a battery, allowing it to run forever as long as it remains connected to a power source. If you’re interested, feel free to check it out! This guide can be adapted only for phones on the postmarketOS device list. Please note that this process will erase all data on your phone, so it’s important to use a device you don’t need. Let’s get started!

Database​

2024-12-07 Brian Douglas' Tech Blog - Sensible SQLite defaults { briandouglas.ie }

SQLite is cool now. DHH uses it, Laravel defaults to it. Here is a list of sensible defaults when using sqlite.

2024-12-20 vlcn-io/cr-sqlite: Convergent, Replicated SQLite. Multi-writer and CRDT support for SQLite { github.com }

"It's like Git, for your data."

CR-SQLite is a run-time loadable extension for SQLite and libSQL. It allows merging different SQLite databases together that have taken independent writes.

In other words, you can write to your SQLite database while offline. I can write to mine while offline. We can then both come online and merge our databases together, without conflict.

In technical terms: cr-sqlite adds multi-master replication and partition tolerance to SQLite via conflict free replicated data types (CRDTs) and/or causally ordered event logs.

2024-10-10 Optimizing Postgres table layout for maximum efficiency { r.ena.to }

When modeling a Postgres database, you probably don’t give much thought to the order of columns in your tables. After all, it seems like the kind of thing that wouldn’t affect storage or performance. But what if I told you that simply reordering your columns could reduce the size of your tables and indexes by 20%? This isn’t some obscure database trick — it’s a direct result of how Postgres aligns data on disk.

In this post, I’ll explore how column alignment works in Postgres, why it matters, and how you can optimize your tables for better efficiency. Through a few real-world examples, you’ll see how even small changes in column order can lead to measurable improvements.

2024-11-17 What I Wish Someone Told Me About Postgres | ChallahScript { challahscript.com }

I’ve been working professionally for the better part of a decade on web apps and, in that time, I’ve had to learn how to use a lot of different systems and tools. During that education, I found that the official documentation typically proved to be the most helpful.

Except…Postgres. It’s not because the official docs aren’t stellar (they are!)–they’re just massive. For the current version (17 at the time of writing), if printed as a standard PDF on US letter-sized paper, it’s 3,200 pages long. It’s not something any junior engineer can just sit down and read start to finish.

So I want to try to catalog the bits that I wish someone had just told me before working with a Postgres database. Hopefully, this makes things easier for the next person going on a journey similar to mine.

Note that many of these things may also apply to other SQL database management systems (DBMSs) or other databases more generally, but I’m not as familiar with others so I’m not sure what does and does not apply.

Math​

2024-12-18 ✨ How I Used Linear Algebra to Build an Interactive Diagramming Editor — and Why Matrix Math is Awesome | by Ivan Shubin | Dec, 2024 | ITNEXT { itnext.io }

C || C++​

2024-12-27 C++ 'Type Erasure' Explained | Dave Kilian's Blog { davekilian.com } { 2014 }

I recently stumbled across this pattern on a Hacker News post. It’s a neat toy, but I had a hard time finding a good explanation (most of the information I found jumped straight into examples before really motivating what was going on). In this post, I’ll try to derive the pattern from first principles instead.

CPP Mock libraties:

• 2024-12-27 rollbear/trompeloeil: Header only C++14 mocking framework { github.com }
• 2024-12-27 eranpeer/FakeIt: C++ mocking made easy. A simple yet very expressive, headers only library for c++ mocking. { github.com }
• 2024-12-27 gMock for Dummies | GoogleTest { google.github.io }

2024-12-21 Fixing C strings { thasso.xyz }

2024-09-29 It is never too late to write your own C/C++ command-line utilities – Daniel Lemire's blog { lemire.me }

You know those moments when your code feels sluggish, and you wonder if there’s a better way? Sometimes, there is. Daniel Lemire recently shared a cool story about swapping a Python script for a custom C++ utility and saving their company a ton of cash. The gist? Their Python script, used to process a JSON file every few seconds, was hogging a full CPU core. They reworked it into a C++ program using some smart libraries like simdjson, and the difference was night and day: over ten times faster, turning a snail into a lightning bolt.

Python is great for getting things up and running quickly, but when performance really matters—like shaving off milliseconds in a process that runs all day—C++ can be a game changer. It takes more effort to write, sure, but the payoff in speed and efficiency can be huge. Of course, it’s not all rainbows; setting up dependencies and dealing with compilation takes extra time. But tools like CMake and CPM are making that part a lot less painful these days.

Python’s convenience makes it perfect for many tasks, but when you’re pushing the limits of performance, don’t be afraid to roll up your sleeves and dive into C++. It’s a little extra work upfront, but when the results are this good, it’s worth it. Plus, you might even impress your team with how much you can squeeze out of your hardware. Sometimes, the old-school tools are still the best ones for the job.

Python comes with a lot of bundled functionality whereas C++ requires you to give more thought to dependencies. Thankfully CMake with CPM make recovering the dependencies painless:

include(cmake/CPM.cmake)
CPMAddPackage("gh:fmtlib/fmt#11.0.2")
CPMAddPackage("gh:simdjson/simdjson@3.10.1")
CPMAddPackage("gh:fastfloat/fast_float@6.1.6")
add_executable(main main.cpp)
target_link_libraries(main fmt::fmt simdjson::simdjson FastFloat::fast_float)

2024-11-30 Everything You Never Wanted To Know About Linker Script · mcyoung { mcyoung.xyz }

2024-10-13 Every bug/quirk of the Windows resource compiler (rc.exe), probably - ryanliptak.com { www.ryanliptak.com }

2024-09-13 Safe C++ { safecpp.org }

Over the past two years, the United States Government has been issuing warnings about memory-unsafe programming languages with increasing urgency. Much of the country’s critical infrastructure relies on software written in C and C++, languages which are very memory unsafe, leaving these systems more vulnerable to exploits by adversaries.

2024-09-26 Embedded Scripting Languages { caiorss.github.io }

2024-09-29 Few lesser known tricks, quirks and features of C { jorenar.com }

2024-07-01 Writing GUI apps for Windows is painful - Samuel Tulach

2024-12-21 ysc3839/win32-darkmode: Example application shows how to use undocumented dark mode API introduced in Windows 10 1809. { github.com }

2024-07-06 How to implement a hash table (in C)

2024-07-26 GitHub - cameron314/concurrentqueue: A fast multi-producer, multi-consumer lock-free concurrent queue for C++11

2024-08-22 Do low-level optimizations matter? Faster quicksort with cmov (2020) { cantrip.org }

2024-08-22 A ToC of the 20 part linker essay LWN.net { lwn.net }

2024-10-27 Alternative operator representations - cppreference.com { en.cppreference.com }

2024-10-28 The Curiously Recurring Template Pattern (CRTP) - Fluent C++ { www.fluentcpp.com }

• The CRTP, episode One: Definition
• The CRTP, episode Two: What the CRTP can bring to your code
• The CRTP, episode Three: An implementation helper for the CRTP

2024-11-07 marovira/lua: The Lua Programming Language with Modern CMake { github.com }

CMake: This is a bundle of the Lua Programming Language v5.4.4 that provides a modern CMake script for easy inclusion into projects and installation. For usage instructions, see the next section.

👂 The Ear of AI​

The Era of AI is now renamed to The Ear of AI because of a silly typo

2024-12-29 How I run LLMs locally - Abishek Muthian { abishekmuthian.com }

2024-12-21 A Gentle Introduction to Graph Neural Networks { distill.pub }

This article explores and explains modern graph neural networks. We divide this work into four parts. First, we look at what kind of data is most naturally phrased as a graph, and some common examples. Second, we explore what makes graphs different from other types of data, and some of the specialized choices we have to make when using graphs. Third, we build a modern GNN, walking through each of the parts of the model, starting with historic modeling innovations in the field. We move gradually from a bare-bones implementation to a state-of-the-art GNN model. Fourth and finally, we provide a GNN playground where you can play around with a real-word task and dataset to build a stronger intuition of how each component of a GNN model contributes to the predictions it makes.

2024-12-21 OpenAI o3 Breakthrough High Score on ARC-AGI-Pub { arcprize.org }

OpenAI's new o3 system - trained on the ARC-AGI-1 Public Training set - has scored a breakthrough 75.7% on the Semi-Private Evaluation set at our stated public leaderboard $10k compute limit. A high-compute (172x) o3 configuration scored 87.5%.

ARC-AGI serves as a critical benchmark for detecting such breakthroughs, highlighting generalization power in a way that saturated or less demanding benchmarks cannot. However, it is important to note that ARC-AGI is not an acid test for AGI – as we've repeated dozens of times this year. It's a research tool designed to focus attention on the most challenging unsolved problems in AI, a role it has fulfilled well over the past five years.

Passing ARC-AGI does not equate to achieving AGI, and, as a matter of fact, I don't think o3 is AGI yet. o3 still fails on some very easy tasks, indicating fundamental differences with human intelligence.

2024-12-21 Building effective agents Anthropic { www.anthropic.com }

When building applications with LLMs, we recommend finding the simplest solution possible, and only increasing complexity when needed. This might mean not building agentic systems at all. Agentic systems often trade latency and cost for better task performance, and you should consider when this tradeoff makes sense.

2024-12-15 They See Your Photos { theyseeyourphotos.com }

2024-12-12 A ChatGPT clone, in 3000 bytes of C, backed by GPT-2 { nicholas.carlini.com }

2024-11-26 Introducing the Model Context Protocol \ Anthropic { www.anthropic.com }

The Model Context Protocol is an open standard that enables developers to build secure, two-way connections between their data sources and AI-powered tools. The architecture is straightforward: developers can either expose their data through MCP servers or build AI applications (MCP clients) that connect to these servers.

2024-11-23 pingcap/autoflow: pingcap/autoflow is a Graph RAG based and conversational knowledge base tool built with TiDB Serverless Vector Storage. Demo: https://tidb.ai { github.com }

pingcap/autoflow is a Graph RAG based and conversational knowledge base tool built with TiDB Serverless Vector Storage. Demo: https://tidb.ai

2024-11-22 AI and Everything Else - Benedict Evans | Slush 2023 - YouTube { www.youtube.com }

2024-11-22 Presentations — Benedict Evans { www.ben-evans.com }

2024-11-14 AI Makes Tech Debt More Expensive { www.gauge.sh }

GenAI can’t handle High Complexity If you’ve tried tools like Cursor or Aider for professional coding, you know that their performance is highly sensitive to the complexity of the code you’re working on. They provide a dramatic speedup when applying pre-existing patterns, and when making use of existing interfaces or module relationships. However, in ‘high-debt’ environments with subtle control flow, long-range dependencies, and unexpected patterns, they struggle to generate a useful response.

2024-11-07 TutoriaLLM/TutoriaLLM: Self-hosted environment for programming tutorial by LLM { github.com }

TutoriaLLM は、小中学生を対象とした、Web 上で使用できる、LLM によって提供されるセルフホスト型プログラミング学習プラットフォームです。教育コンテンツを制作する人と、そのコンテンツから学ぶ人たちのために設計されています。

TutoriaLLM is a self-hosted programming learning platform for K-12 Education that can be used on the web. It is designed for those who create educational content and those who learn from it.

2024-10-12 AI Winter Is Coming { leehanchung.github.io }

2024-08-27 System Prompts - Anthropic { docs.anthropic.com }

2024-08-28 AI Apocalypse: 80% of Projects Crash and Burn, Billions Wasted says RAND Report - SalesforceDevops.net { Vernon Keenan / salesforcedevops.net }

The most common cause of AI project failure? It’s not the technology – it’s the people at the top. Business leaders often misunderstand or miscommunicate what problems need to be solved using AI. As one interviewee put it, “They think they have great data because they get weekly sales reports, but they don’t realize the data they have currently may not meet its new purpose.”

Many executives have inflated expectations of what AI can achieve, fueled by salespeople’s pitches and impressive demonstrations. They underestimate the time and resources required for successful AI implementation. One interviewee noted, “Often, models are delivered as 50 percent of what they could have been” due to shifting priorities and unrealistic timelines.

Data quality emerged as the second most significant hurdle. “80 percent of AI is the dirty work of data engineering,” an interviewee stated. “You need good people doing the dirty work—otherwise their mistakes poison the algorithms.”

2024-09-13 Notes on OpenAI’s new o1 chain-of-thought models { simonwillison.net }

2024-09-13 2205.11916 Large Language Models are Zero-Shot Reasoners { arxiv.org }

Let's think step-by-step

2024-09-18 zlwaterfield/scramble: Open-Source Grammarly Alternative { github.com }

A very simple Chromium and Firefox extension example to fix grammar or rewrite the text on any website

2024-09-18 WonderWorld { kovenyu.com }

Interactive Scene Generation

WonderWorld allows real-time rendering and fast scene generation. This allows a user to navigate existing scenes, and specify where and what to generate a new scene. Here are examples where a user specifies scene contents (via text) and locations (via camera movement) to create a virtual world. Videos here are accelerated.

2024-09-18 STORM { storm.genie.stanford.edu }

2024-09-18 punnerud/Local_Knowledge_Graph { github.com }

2024-09-01 Discussion thread Programming with ChatGPT | Hacker News { news.ycombinator.com }

simonw 4 days ago | prev

I'm increasingly building entire functional prototypes from start to finish using Claude 3.5 Sonnet. It's an amazing productivity boost. Here are a few recent examples:

• Image Resize Quality Tool: This is a tool for dropping in an image and instantly seeing resized versions of that image at different JPEG qualities, each of which can be downloaded. I used to use the (much better) Squoosh for this, but my cut-down version is optimized for my workflow (picking the smallest JPEG version that remains legible). Notes and prompts on how I built it are available here.

• django-http-debug: This is an actual open-source Python package I released that was mostly written for me by Claude. It's a webhooks debugger where you can set up a URL, and it will log all incoming requests to a database table for you. Notes on how I built it are available here.

• datasette-checkbox: This is a Datasette plugin that adds toggle checkboxes to any table with is_ or has_ columns. An animated demo and prompts showing how I built the initial prototype can be found here.

• Gemini BBox Tool: This is a tool for trying out Gemini 1.5 Pro's ability to return bounding boxes for items it identifies. You'll need a Gemini API key for this one, or you can check out the demo and notes here.

• Gemini Chat Tool: This is a similar tool for trying out different Gemini models (Google released three more yesterday) with a streaming chat interface. Notes on how I built it are available here.

I still see some people arguing that LLM-assisted development like this is a waste of time, and they spend more effort correcting mistakes in the code than if they had written it from scratch themselves.

I couldn't disagree more. My development process has always started with prototypes, and the speed at which I can get a proof-of-concept prototype up and running with these tools is quite frankly absurd.

2024-06-27 dropofahat.zone

2024-06-27 I am using AI to drop hats outside my window onto New Yorkers | Hacker News

2024-12-26 Apache NiFi { nifi.apache.org }

2024-12-26 Apache NiFi on Azure - Azure Architecture Center | Microsoft Learn { learn.microsoft.com }

⌚ Nice watch!​

2024-12-15 Dependency Injection in C++ - A Practical Guide - Peter Muldoon - C++Now 2024 - YouTube { www.youtube.com }

Long talk! Only list of the topics covered. I personally want to focus on "Inheritance and Virtual Functions" and "Template-Based Dependency Injection" with concepts. Concepts look really cool.

Methods of Dependency Injection

• Link-Time Dependency Injection
  • Overview and explanation
  • Issues with link-time DI (fragility, undefined behavior, ODR violations)
  • Reasons to avoid link-time DI in modern systems
• Inheritance and Virtual Functions
  • Base class and derived classes for DI
  • Interface-based DI (abstract interfaces)
  • Drawbacks (interface bloat, large interface sizes, tight coupling)
• Template-Based Dependency Injection
  • Using templates to achieve DI
  • Benefits of compile-time DI
  • Concepts (C++20) for template constraints
  • Pros and cons of using templates for DI
• Type Erasure (std::function)
  • Using std::function for DI
  • Flexibility and run-time benefits
  • Overhead and runtime costs of std::function
• Null Object Pattern
  • Creating "null" objects for dependency injection
  • Use cases and benefits
  • How to use null objects for testing
• Setter Injection
  • Description of setter-based DI
  • Problems with setter injection (state mutation, initialization order issues)
  • Why setter injection is generally avoided
• Method Injection
  • Description of method-level DI
  • Pros (clearer interfaces) and cons (interface bloat)
• Constructor Injection
  • Constructor-level DI for immutability
  • Best practices for constructor injection
  • Drawbacks (API changes, large constructor argument lists)
• Dependency Suppliers (Factory Functions)
  • Using supplier functions to control dependency injection
  • How dependency suppliers differ from service locators

2024-12-14 Master Tailwind CSS Crash Course 2024 | not a tutorial - YouTube { www.youtube.com }

by Ankita Kulkarni

/* Introduction */
// This document serves as a comprehensive reference sheet for key Tailwind CSS concepts and utilities.
// Each section focuses on a major topic, providing a functional code sample that covers its subtopics.
// Use this guide as a quick reference for essential Tailwind features.

/* 1. Core Concepts of Tailwind CSS */
<div class="container mx-auto p-6">
  <h1 class="text-4xl font-bold mb-4">Core Concepts of Tailwind CSS</h1>
  <p class="text-gray-600">This paragraph demonstrates text utilities, margin, and padding.</p>
  <button class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded">
    Click Me
  </button>
</div>

/* 2. Responsive Design */
<div class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 gap-4 p-6">
  <div class="bg-red-500 p-4">1</div>
  <div class="bg-green-500 p-4">2</div>
  <div class="bg-blue-500 p-4">3</div>
  <div class="bg-yellow-500 p-4">4</div>
</div>

/* 3. Grid and Flexbox */
<div class="flex flex-col md:flex-row md:justify-between p-6">
  <div class="bg-purple-500 p-4 flex-1">Flex Item 1</div>
  <div class="bg-orange-500 p-4 flex-1">Flex Item 2</div>
  <div class="bg-teal-500 p-4 flex-1">Flex Item 3</div>
</div>

<div class="grid grid-cols-2 md:grid-cols-4 gap-6 p-6">
  <div class="bg-pink-500 h-20"></div>
  <div class="bg-blue-500 h-20"></div>
  <div class="bg-green-500 h-20"></div>
  <div class="bg-red-500 h-20"></div>
</div>

/* 4. Padding, Margins, and Spacing */
<div class="p-10 m-10 bg-gray-100">
  <h2 class="mb-6">Padding and Margin Example</h2>
  <p class="py-4 px-6 bg-white shadow-lg rounded">This box has custom padding and margin.</p>
</div>

/* 5. Borders and Border Radius */
<div class="border-4 border-dashed border-blue-500 rounded-lg p-6 m-6">
  <h2 class="text-xl font-bold">Dashed Border with Radius</h2>
  <p class="mt-4">This container demonstrates border styles and border radius utilities.</p>
</div>

/* 6. Typography and Text Styling */
<div class="p-6">
  <h1 class="text-4xl font-extrabold underline decoration-pink-500">H1 Header</h1>
  <h2 class="text-3xl font-semibold mt-4">H2 Header</h2>
  <p class="text-base text-gray-700 leading-relaxed mt-2">This is a paragraph demonstrating text styling like font size, color, and line height.</p>
</div>

/* 7. Customizing Colors */
<div class="bg-custom-purple text-white p-6">
  <h2 class="text-xl">Custom Color</h2>
  <p>Custom colors can be configured in tailwind.config.js</p>
</div>

/* 8. Box Shadows and Drop Shadows */
<div class="shadow-lg p-6 m-6 bg-white rounded-lg">
  <h2 class="font-bold">Box Shadow Example</h2>
  <p>This container has a large box shadow applied to it.</p>
</div>

/* 9. Customizing Animations and Transitions */
<button class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded transition duration-300 ease-in-out transform hover:scale-105">
  Hover Me
</button>

/* 10. Images and Transformations */
<img src="/path/to/image.jpg" class="w-64 h-64 object-cover rounded-full transform rotate-12">

/* 11. State Management */
<input type="text" placeholder="Focus Me" class="focus:outline-none focus:ring-2 focus:ring-blue-500 p-2 border border-gray-300 rounded">

/* 12. Dark Mode in Tailwind */
<div class="dark:bg-gray-800 dark:text-white p-6">
  <h2 class="text-xl">Dark Mode Example</h2>
  <p>This text changes color in dark mode.</p>
</div>

/* 13. Filters and Effects */
<img src="/path/to/image.jpg" class="w-64 h-64 filter grayscale hover:grayscale-0 transition duration-300">

/* 14. Custom Utility Classes */
<div class="custom-button bg-blue-500 text-white font-bold py-2 px-4 rounded">
  Custom Button
</div>

/* 15. Advanced Layout Techniques */
<div class="max-w-4xl mx-auto p-6">
  <h2 class="text-2xl font-bold mb-4">Advanced Layout</h2>
  <div class="flex justify-center">
    <div class="w-1/2 bg-red-500 p-4">50% Width</div>
  </div>
</div>

/* 16. Gradients and Backgrounds */
<div class="bg-gradient-to-r from-purple-400 via-pink-500 to-red-500 text-white p-6 rounded-lg">
  <h2 class="text-xl font-bold">Gradient Background</h2>
  <p>This container has a beautiful gradient background.</p>
</div>

/* 17. Customizing Layouts */
<div class="grid grid-cols-2 gap-4">
  <div class="bg-blue-500 h-20"></div>
  <div class="bg-green-500 h-20"></div>
  <div class="bg-red-500 h-20"></div>
  <div class="bg-yellow-500 h-20"></div>
</div>

/* 18. Project Walkthrough */
<div class="p-6">
  <h2 class="text-2xl font-bold mb-4">Project Walkthrough</h2>
  <p class="text-gray-600">This project demonstrates how all the Tailwind concepts come together to create a cohesive layout.</p>
</div>

/* 19. Additional Resources */
<div class="p-6 bg-gray-100">
  <h2 class="text-xl font-bold">Resources</h2>
  <ul class="list-disc pl-6">
    <li>Official Tailwind CSS Documentation</li>
    <li>VS Code Tailwind IntelliSense Plugin</li>
    <li>Learning Responsive Design and Dark Mode</li>
  </ul>
</div>

2024-12-10 What's a Tensor? - YouTube { www.youtube.com }

2024-11-28 Playing Game on the Mall Wall: Japanese Man's Super-sized Adventure! - YouTube { www.youtube.com }

Nomad Push is a 38-year-old Japanese man who’s homeless and travels all over Japan. On his YouTube channel, he shares his daily life in a really honest and down-to-earth way. You’ll see him doing things like:

• Sleeping in train stations
• Exploring abandoned houses
• Cooking simple meals in parks

Even though he’s dealing with tough times, his videos feel positive and show a side of life most people don’t get to see. A lot of people watching his channel say it’s inspiring, and he’s built a big community of fans who support him. When he hit 100,000 subscribers, another YouTuber, Oriental Pearl, even threw a celebration for him, which shows how much people believe in him.

If you’re learning Japanese, this channel is a goldmine. His videos are full of real Japanese conversations, and he adds subtitles to help viewers follow along. It’s great practice for understanding how people actually talk in Japan.

Nomad Push’s channel is like a window into his life and a journey across Japan at the same time. It’s simple, real, and worth checking out if you’re curious about a different way of seeing the world.

2024-12-02 A Day in the Life of a Japanese Hikikomori (Shut In) - YouTube { www.youtube.com }

Inside the Life of Nito: A Hikikomori Turned Game Developer

Nito, a hikikomori living in Kobe, Japan, has spent the past decade in near-total isolation. Far from idle, he has dedicated the last five years to developing Pull Stay, an old-school beat-em-up game reflecting his experiences as a recluse. The protagonist, a hikikomori himself, battles societal judgment—a theme close to Nito’s heart. Using Unreal Engine, he has self-taught coding, 3D design, and storytelling to bring his vision to life.

A Creative Path Born from Setbacks After graduating from the University of Tokyo, Nito struggled to find his footing in traditional creative fields like writing and doujinshi (independent manga). He shifted to game development when tools like Unreal Engine became accessible. Despite the steep learning curve and his limited English skills, Nito found purpose in creating something meaningful on his own terms.

Breaking Stereotypes and Defying Odds Nito’s life defies the typical hikikomori stereotype of idleness and dependence. His determination and self-taught skills showcase resilience, proving isolation doesn’t equate to lack of ambition. Through Pull Stay, he turns personal struggles into a story that others can relate to and enjoy.

What’s Next? With Pull Stay nearing release on Steam, Nito hopes its success will enable him to collaborate with other creators and travel the world. If it doesn’t take off, he plans to use the game as a portfolio to break into the industry. For now, his story serves as an inspiring reminder of the power of creativity and persistence.

Support Nito by checking out Pull Stay on Steam or sharing his journey with others.

https://store.steampowered.com/app/1179890/Pull_Stay/

2024-11-30 10% Of Engineers Should Get Fired - YouTube { www.youtube.com }

What Are Ghost Engineers? Ghost engineers are unproductive employees contributing less than 10% of a median engineer’s output. They account for up to 10% of the workforce and cost companies $90 billion annually. These individuals often perform minimal tasks, such as making fewer than three commits a month or trivial changes, while collecting full salaries.

Key Insights:

• Economic Impact: Eliminating ghost engineers could save companies billions and add $465 billion to market caps without reducing performance.
• Remote Work Paradox: While top engineers excel remotely, the worst also thrive in remote settings. 14% of remote engineers are ghost engineers compared to 6% in-office.
• Cultural Cost: Ghost engineers demoralize motivated teammates and occupy roles that could go to skilled newcomers.
• Startups’ Advantage: Startups avoid this issue by demanding accountability from every team member, contributing to their ability to outperform larger organizations.

Why It Matters: Ghost engineers don’t just waste money—they stall innovation, hinder team dynamics, and damage the credibility of remote work. Companies have a unique chance during layoffs to address this inefficiency, open doors to fresh talent, and foster a culture of accountability.

The Way Forward: Fire unproductive workers, improve performance metrics, and rebuild trust in remote work by ensuring accountability. The tech industry’s future depends on tackling this hidden crisis.

Sources:

2024-11-30 Yegor Denisov-Blanch on X: "I’m at Stanford and I research software engineering productivity. We have data on the performance of >50k engineers from 100s of companies. Inspired by @deedydas, our research shows: ~9.5% of software engineers do virtually nothing: Ghost Engineers (0.1x-ers) https://t.co/uygyfhK2BW" / X { x.com }

2024-11-30 Tech's $90B Ghost Engineer Problem: Stanford Study Finds 9.5... { socket.dev }

Das highlighted a few tools of the trade from the “quiet quitting” playbook:

• “in a meeting” on slack
• scheduled slack, email, code at late hours
• private calendar with blocks
• mouse jiggler for always online
• “this will take 2 weeks” (1 day)
• “oh, the spec wasn’t clear”
• many small refactors
• “build is having issues”
• blocked by another team
• will take time bcuz obscure tech reason like “race condition”
• “can you create a jira for that?”

2024-12-07 Keynote: Advent of Code, Behind the Scenes - Eric Wastl - YouTube { www.youtube.com }

Hello friends! My name is Eric Wasel, and Advent of Code is a project I created to help programmers improve their skills through small, self-contained challenges. The puzzles start easy and get progressively harder, helping you learn new techniques and develop problem-solving skills. I believe the best way to learn is by solving specific problems, and this project reflects that. We even have C++ in Advent of Code, and I’ll touch on where and how during the talk. Drawing from my experience designing systems for ISPs, auction infrastructure, and marketplaces, Advent of Code is all about celebrating learning, curiosity, and the joy of programming for everyone, no matter their level.

2024-12-07 To Int or To Uint - Alex Dathskovsky - YouTube { www.youtube.com } {C++}

This talk provides valuable insights into handling integers in C++. Integers are fundamental in any program, but improper handling can lead to subtle bugs, undefined behavior, and poor performance. This content explores the complexities of signed and unsigned integers, common mistakes, and how to optimize performance. By understanding these nuances, you'll avoid common pitfalls, write more efficient code, and improve the overall robustness of your applications.

The Basics of Signed and Unsigned Integers

Representation in Memory

• Unsigned Integers: Simple modulo 2 representation. Overflow behavior is well-defined, which means operations that exceed the maximum value wrap around predictably.
• Signed Integers: Historically, C++ supported various representations like one’s complement and two’s complement. Since C++20, two’s complement is the standard. Overflow is undefined, and operations involving signed integers require careful handling to avoid unexpected behavior.

Performance Considerations Signed integers often involve additional steps in assembly code, such as preserving the sign bit during division or right shifts. This makes operations on signed integers slower compared to their unsigned counterparts, especially in performance-critical code. For example, unsigned division by two can be replaced by a simple bit shift. Signed division, on the other hand, requires arithmetic shifts that preserve the sign bit, adding extra overhead.

Best Practices for Handling Integers

Use Fixed-Width Integer Types Explicitly use types like int32_t, uint64_t, and size_t when appropriate. These make your code portable and clear about the expected range of values.

Prefer Signed Types Unless Necessary Unsigned integers should only be used when their wrapping behavior is explicitly desired. For most use cases, signed integers are safer and less prone to subtle bugs.

Leverage C++20 and C++23 Features Modern C++ provides tools like std::ssize and type traits that simplify working with integers. Use these features to avoid common pitfalls and ensure correctness.

Treat Warnings as Errors Enable strict compiler warnings (-Wall, -Wextra, and -Werror) and sanitizers to catch potential issues early. Compiler tools can often detect problems like signed-unsigned mismatches before they cause runtime errors.

Avoid Overusing auto While auto simplifies code, it can obscure type information, leading to unexpected behavior. Be explicit with integer types, especially in loops and arithmetic operations.

Author: Alex Dathskovsky

2024-12-07 Demystifying CRTP in C++: What, Why, and How { www.cppnext.com }

2024-12-07 Exposing the not-so-secret practices of the cult of DDD - Chris Klug - - YouTube { www.youtube.com }

2024-12-07 Bosses Are FIRING Gen Z Workers Just Months After Hiring Them. - YouTube { www.youtube.com }

Source: 2024-12-07 1 in 6 Companies Are Hesitant To Hire Recent College Graduates - Intelligent { www.intelligent.com }

Good Reads​

2024-12-01 Legacy Shmegacy - David Reis on Software { davidreiscto.substack.com }

People call some code legacy when they are not happy with it. Usually it simply means they did not write it, so they don’t understand it and don’t feel safe changing it. Sometimes it also means the code has low quality1 or uses obsolete technologies. Interestingly, in most cases the legacy label is about the people who assign it, not the code it labels. That is, if the original authors were still around the code would not be considered legacy at all.

This model allows us to deduce the factors that encourage or prevent some code from becoming legacy:

1. The longer are programmer’s tenure the less code will become legacy, since authors will be around to appreciate and maintain it.
2. The more code is well architected, clear and documented the less it will become legacy, since there is a higher chance the author can transfer it to a new owner successfully.
3. The more the company uses pair programming, code reviews, and other knowledge transfer techniques, the less code will become legacy, as people other than the author will have knowledge about it.
4. The more the company grows junior engineers the less code will become legacy, since the best way to grow juniors is to hand them ownership of components.
5. The more a company uses simple standard technologies, the less likely code will become legacy, since knowledge about them will be widespread in the organization. Ironically if you define innovation as adopting new technologies, the more a team innovates the more legacy it will have. Every time it adopts a new technology, either it won’t work, and the attempt will become legacy, or it will succeed, and the old systems will.

The reason legacy code is so prevalent is that most teams are not good enough at all of the above to avoid it, but maybe you can be.

🥒 2024-12-01 Tech's $90B Ghost Engineer Problem: Stanford Study Finds 9.5... { socket.dev }

Beyond the economic and productivity concerns, ghost engineers pose significant security risks. Their lack of meaningful engagement can lead to a few critical issues: unreviewed or improperly tested code changes, unnoticed vulnerabilities, and outdated systems left unpatched. A disengaged engineer might also miss—or deliberately ignore—critical security protocols, creating potential entry points for malicious actors.

When these engineers aren't actively involved in maintaining secure practices, they can create blind spots in a company’s defense strategy, increasing the risk of breaches or compliance failures. Threat actors can exploit disengaged engineers through phishing, social engineering, or leveraging neglected updates and poorly reviewed code to infiltrate systems and compromise security. Addressing these gaps requires better oversight and collaborative practices.

Before you start side-eyeing your coworkers, it’s worth noting that measuring productivity in software engineering is notoriously tricky. Commit counts or hours logged are often poor indicators of true impact. Some high-performing engineers—the mythical “10x engineers”—produce significant results with fewer, well-thought-out contributions.

However, the “ghost engineer” trend exposes systemic inefficiencies in talent management and performance evaluation. Remote work policies, once heralded as a game-changer, are now under the microscope. They’ve enabled flexibility for many but have also given rise to the ghost engineering phenomenon. The tug-of-war over remote versus in-office work is likely to intensify as companies grapple with these kinds of leadership and accountability issues.

2024-11-30 The deterioration of Google { www.baldurbjarnason.com }

I'm Baldur Bjarnason, a web developer and writer. In my latest essay, I wrote about the decline of Google and its impact on independent publishers.

Here's a quick summary:

1. Independent Publishers Struggling: Many independent sites are shutting down due to a lack of traffic from Google and Facebook.
2. Google's Machine Learning Issues: Google's attempt to improve search results with machine learning has backfired, letting spam through and delisting quality content.
3. Economic Impact: Even frugally run sites can't survive on the remaining traffic, leading to significant financial struggles for creators.
4. Algorithm Black Box: Google's algorithm has become so complex that even their engineers can't fully understand or fix it.
5. Monopoly Power: Google's monopoly allows it to capture value without improving product utility, leaving users with fewer alternatives.

2024-11-30 15 Lessons From 15 Years of Indie App Development { lukaspetr.com }

Hey there, I'm Lukas Petr, an indie iOS app developer from Prague. Over the past 15 years, I've learned a lot about the ups and downs of indie app development. Here are some key takeaways:

1. Enjoy the Process: Loving what you do is crucial. If you don't enjoy the journey, it will be tough to stick with it.
2. Understand Your Motivation: Know why you're doing this. For me, it's about creating something meaningful and useful.
3. Risk and Reward: The risk is high, but the reward of fulfilling work and ownership is worth it.
4. Find Your Niche: Focus on what you believe in and what scratches your own itch.
5. Provide Additional Value: Aim for sustainable value over time, not just quick gains.
6. Wear Many Hats: Be prepared to handle everything from development to marketing.
7. Reflect Regularly: Regular introspection helps you stay on track and improve.
8. Learn and Apply Lessons: Keep evolving and improving based on your experiences.
9. Find Support: Surround yourself with people who can help propel you forward.
10. Luck: Sometimes, success involves a bit of luck, but you have to put yourself out there.

I hope you find these insights helpful. If you're pursuing any creative endeavor, I'm rooting for you! Feel free to reach out if you have any questions or comments.

2024-11-24 A career ending mistake — Bitfield Consulting { bitfieldconsulting.com }

A career-ending mistake isn't always a catastrophic error like shutting down a nuclear power station or deleting a production database; it's often subtler, like failing to plan for the end of your career. The article explores how many of us rush through our professional lives without a clear destination, highlighting that "career" itself can mean "to rush about wildly." It asks the critical questions: “Where do you want to end up? And is that where you're currently heading?” Instead of drifting, the piece advises us to define what we truly want, as "The indispensable first step to getting what you want is this: decide what you want." Whether you're content in your current role or seeking something more fulfilling, understanding your end goal and working intentionally toward it is key to avoiding a career that feels out of control.

Fun quote:

Engineering managers need a solid foundation of technical competence, to be sure, but the work itself is primarily about leading, supervising, hiring, and developing the skills of other technical people. It turns out those are all skills, too, and relatively rare ones.

Managing people is hard; much harder than programming. Computers just do what you tell them, whether that’s right or wrong (usually wrong). Anyone can get good at programming, if they’re willing to put in enough time and effort. I’m not sure anyone can get good at managing, and most don’t. Most managers are terrible.

That’s quite a sweeping statement, I know. (Prove me wrong, managers, prove me wrong.) But, really, would a car mechanic last long in the job if they couldn’t fit a tyre, or change a spark plug? Would a doctor succeed if they regularly amputated the wrong leg? We would hope not. But many managers are just as incompetent, in their own field, and yet they seem to get away with it.

2024-11-23 the tech utopia fantasy is over | ava's blog { blog.avas.space }

Growing up, I had a positive view of tech, believing it would bring comfort, less work, and personalized assistance. However, the reality has been different, with tech companies failing to deliver on their promises and instead contributing to issues like disinformation, economic inequality, and environmental harm. While there have been some benefits, such as increased political knowledge and social connections, the negatives now overshadow the positives. The tech utopia fantasy is truly dead to me.

2024-11-18 Good software development habits | Zarar's blog { zarar.dev }

1. Keep Commits Small: Keep each commit focused on a single change to make it easier to track and revert issues. Code that compiles should be committable.
2. Refactor Continuously: Follow Kent Beck's advice: make changes easy, then make the easy changes. Frequent, small refactorings prevent complex reworks.
3. Deploy Regularly: Treat deployed code as the only true measure of progress. Frequent deployments ensure code reliability.
4. Trust the Framework: Don’t test features already covered by the framework; focus on testing your unique functionality, especially with small components.
5. Organize Independently: If a function doesn’t fit anywhere, create a new module. It’s better to separate logically independent code.
6. Write Tests First (Sometimes): If unsure about an API’s design, start with tests to clarify requirements. TDD doesn’t have to be strict—write code in workable chunks.
7. Avoid Duplication After the First Copy-Paste: If code is duplicated, it’s time for an abstraction. Consolidating multiple versions is harder than parameterizing one.
8. Accept Design Change: Designs inevitably get outdated. Good software development is about adapting to change, not achieving a “perfect” design.
9. Classify Technical Debt: Recognize three types of technical debt: immediate blockers, future blockers, and potential blockers. Minimize the first, address the second, and deprioritize the third.
10. Prioritize Testability in Design: Hard-to-test code hints at design issues. Improve testability through smaller functions or test utilities to avoid skipping tests.

🔥2024-11-14 Lessons from my First Exit · mtlynch.io { mtlynch.io }

Selling my first business was a journey filled with excitement, stress, and invaluable lessons. I want to share my experiences to help other entrepreneurs who might be considering a similar path. This post is especially relevant for small business owners and startup founders looking to navigate the complexities of a business exit.

---

Quote:

Used dedicated accounts for the business

Part of what made TinyPilot’s ownership handoff smooth was that its accounts and infrastructure were totally separate from my other business and personal accounts:

• I always sent emails related to the business from my @tinypilotkvm.com email address.
• I always used @tinypilotkvm.com email addresses whenever signing up for services on behalf of TinyPilot.
• I kept TinyPilot’s email in a dedicated Fastmail account.
  • This wasn’t true at the beginning. TinyPilot originally shared a Fastmail account with my other businesses, but I eventually migrated it to its own standalone Fastmail account.
• I never associated my personal phone number with TinyPilot. Instead, I always used a dedicated Twilio number that forwarded to my real number.
• All account credentials were in Bitwarden.

After closing, handing over control was extremely straightforward. I just added the new owner to Bitwarden, and they took over from there. There were a few hiccups around 2FA codes I’d forgotten to put in Bitwarden, but we worked those out quickly.

---

For example, TinyPilot uses the H.264 video encoding algorithm. It’s patented, so we had to get a license from the patent holder before we shipped that feature. During due diligence, we discovered that the patent license forbade me from transferring the license in an asset sale.

I immediately started imagining the worst possible outcome. What if the patent holder realizes they can block the sale, and they demand I pay them $100k? What if the patent holder just can’t be bothered to deal with a tiny business like mine, and they block the sale out of sheer indifference?

🔥 2024-11-08 Blog Writing for Developers { rmoff.net }

Like a favourite pair of jeans that’s well-worn, comfy, and slightly saggy round the arse, I have a go-to structure for writing. Come to think of it, I use it for lots of conference talks too. It looks like this:

1. Tell them what you’re going to tell them
2. Tell them
3. Tell them what you told them

What this looks like in practice is something along these lines:

1. An intro

   What is this thing, and why should the reader give af be interested?

   This could be a brief explanation of why I am interested in it, or why you would want to read my take on it. The key thing is you’re relating to your audience here. Not everyone wants to read everything you write, and that’s ok.

   Let people self-select out (or in, hopefully) at this stage, but make it nice and easy. For example, if you’re writing about data engineering, make it clear to the appdev crowd that they should move on as there’s nothing to see here (or stick around and learn something new, but as a visitor, not the target audience).

2. The article itself

3. A recap

   Make sure you don’t just finish your article with a figurative mic drop—tie up it nicely with a bow (a 🙇🏻 or a 🎀, either works).

   This is where marketing would like to introduce you to the acronym CTA (Call To Action) 😉. As an author you can decide how or if to weave that into your narrative.

   Either way, you’re going to summarise what you just did and give people something to do with it next. Are there code samples they can go and run or inspect? A new service to sign up for? A video to watch? Or just a general life reflection upon which to ponder.

2024-11-07 Monorepo - Our experience { ente.io }

We switched to a monorepo nine months ago, and it’s been working well for us. Before, we had multiple repositories, which made things like managing pull requests or syncing changes a hassle. With everything in one place now, the workflow feels smoother and simpler. It wasn’t a decision we overanalyzed; it just felt like the right time to try it, and we’ve been happy with the results.

The main pros? First, there’s less repetitive work. Instead of opening multiple pull requests across repos for a single change, now it’s just one. Submodules, which were always a pain to manage, are mostly gone. Everything that needs to work together stays in sync naturally. Refactoring has also become easier because we can see the whole picture in one place, which encourages code improvements over time. Plus, being in the same repo has made us feel more connected as a team. Even small things, like seeing everyone’s changes when pulling updates, help us stay in the loop without extra effort.

As for cons, we honestly haven’t found many. A common concern is that monorepos can get messy or slow as they grow, but for our small team, it hasn’t been an issue. We kept it simple—no strict rules, just “don’t touch the root folder”—and it’s been fine. It might not work the same for larger teams or projects with different dynamics, but for us, it’s been a clear win.

2024-10-14 LogLog Games { loglog.games }

I spent three years using Rust for game development, and after shipping a few games and writing over 100,000 lines of code, I’m stepping away from it. Rust has some great qualities—its performance is top-notch, and it often lets you refactor confidently. But for fast, iterative development, which is crucial for indie games, it just doesn't align well. The borrow checker and Rust’s strictness often force unnecessary refactoring, slowing down the process of prototyping and testing new ideas. Tools like hot reloading, essential for quick feedback loops, are either clunky or nonexistent in Rust. And while the language excels in many technical areas, its game development ecosystem is still young, with fragmented solutions and limited support for things like GUI and dynamic workflows.

For small teams like ours, the priority is delivering fun, polished games quickly. With Rust, I found myself spending more time fighting the language and its ecosystem than focusing on gameplay. Moving forward, we’re transitioning to tools that better support rapid iteration and creativity, even if they’re less "perfect" on paper.

2024-09-29 It's hard to write code for computers, but it's even harder to write code for humans · Erik Bernhardsson { erikbern.com }

Onboarding is Key: Users should get started quickly and see results fast. Fix: Simplify setup. Remove steps and make the tool easy to use immediately. For example, ensure API tokens are ready without extra configuration. The faster users see success, the more likely they’ll stick around.

Show Examples First: Abstract explanations confuse users. Fix: Use examples instead of long concepts. Show how the tool works with real use cases. When I write docs, I always start with practical examples users can copy and tweak.

Errors Need Solutions: Errors frustrate users. Fix: Make error messages helpful. Suggest fixes and show code snippets. A clear path back to success turns frustration into trust.

Avoid Too Many Ideas: Too much upfront information overwhelms users. Fix: Keep it simple. Focus on a few core ideas to start. When I design a tool, I aim for 3-5 basic concepts that cover most use cases. Fewer concepts, fewer headaches.

Use Familiar Terms: New words confuse people. Fix: Use common terms like "function" instead of inventing new ones. I think about how people already think about code and try to fit my tool into their existing mental model.

Flexibility Matters: Rigid tools frustrate creative users. Fix: Let users program their own solutions with APIs or scripts. Make everything programmable so users can adapt the tool to their needs.

Don’t Overdo Magic: Hidden behaviors often fail in edge cases. Fix: Keep defaults clear and reliable. Avoid adding unnecessary complexity. Unless I’m 99% sure a “magic” behavior will always work, I avoid it. Instead, I focus on being predictable.

Clarity Over Brevity: Short, clever code is hard to read. Fix: Write clear, readable code. Make it easy to follow. I remind myself: people read code far more than they write it.

2024-09-29 Too much efficiency makes everything worse: overfitting and the strong version of Goodhart’s law | Jascha’s blog { sohl-dickstein.github.io }

When you optimize too much, you can make things worse instead of better. This is the essence of the strong version of Goodhart’s Law: when a measure becomes the target, over-optimization can degrade what you originally cared about. This principle, often studied as "overfitting" in machine learning, also applies broadly to systems like education, economics, and governance.

The Problem: When proxies (measurements or secondary goals) are optimized too well, the actual outcomes worsen. For instance, standardized testing shifts focus from genuine learning to test preparation, undermining education. Similarly, rewarding scientists for publications incentivizes trivial or false findings over meaningful progress. Overfitting to proxies creates harmful side effects, from filter bubbles in social media to inequality in capitalism. How to Fix It: Lessons from Machine Learning

1. Better Alignment: Make proxies closer to real goals. In machine learning, this involves better data collection. In broader systems, it means crafting laws, incentives, and norms that encourage genuine outcomes, like prioritizing long-term learning over test scores.
2. Regularization: Introduce penalties or costs for extreme behaviors. Just as machine learning uses mathematical constraints, systems can add friction:
   • Tax extreme wealth disparities or excessive lawsuits.
   • Impose costs for high-volume actions, like bulk emails or algorithmic trading.
   • Penalize complexity to discourage harmful optimization.
3. Inject Noise: Add randomness to disrupt harmful optimization. Examples include:
   • Randomized selection in competitive admissions to reduce over-preparation.
   • Random trade processing delays to stabilize financial markets.
   • Unpredictable testing schedules to encourage holistic studying.
4. Early Stopping: Halt optimization before it spirals out of control. In systems, this could mean:
   • Capping time spent on decision-making relative to its stakes.
   • Freezing certain information flows, like press blackouts before elections.
   • Splitting monopolies to prevent market over-consolidation.
5. Restrict or Expand Capabilities:
   • Restrict: Limit system capacities to prevent runaway effects, like capping campaign finances or AI training resources.
   • Expand: In some cases, more capacity reduces trade-offs, such as developing clean energy or transparent information systems.

BibTeX entry for post:
@misc{sohldickstein20221106,
  author = {Sohl-Dickstein, Jascha},
  title = {{ Too much efficiency makes everything worse: overfitting and the strong version of Goodhart's law }},
  howpublished = "\url{https://sohl-dickstein.github.io/2022/11/06/strong-Goodhart.html}",
  date = {2022-11-06}
}

2024-09-29 Measuring Developers' Jobs-to-be-done - by Abi Noda { substack.com }

2024-09-29 Measuring Developers' Jobs-to-be-done | Hacker News { news.ycombinator.com }

Google used to measure how well developer tools worked by evaluating how they supported certain tasks, like "debugging" or "writing code." However, this approach often lacked specificity that would be useful for tooling teams. For instance, "searching for documentation" is a common task, but the reason behind it—whether it's to "explore technical solutions" or "understand the context to complete a work item"—can meaningfully change a developer's experience and how well tools support them in achieving their goal.

To provide better insights, Google researchers identified the key goals developers are trying to achieve in their work and developed measurements for each goal. In this paper, they explain their process and share an example of how this new approach has benefited their teams.

2024-10-05 Bureaucrat mode - by Andrew Chen - @andrewchen { andrewchen.substack.com }

As companies scale, they often shift from the agile, conviction-driven "Founder mode" to "Bureaucrat Mode," where decision-making slows, and processes dominate. While startups thrive on speed and direct action, large organizations tend to create committees, expand scopes, and reward consensus over outcomes. These tendencies, while rooted in good intentions like collaboration and stability, can cripple innovation and efficiency when scaled excessively.

The Problem: Bureaucrat Mode emerges as companies grow, driven by processes meant to manage complexity. However, these processes often become self-perpetuating, encouraging behaviors that prioritize internal metrics, visibility, and team expansion over meaningful results. Bureaucrats, focused on navigating processes rather than solving problems, replicate themselves by hiring others who thrive in such environments. This cycle of self-replication entrenches inefficiency and resistance to change.

2024-10-10 How to make Product give a shit about your architecture proposal – Andy G's Blog { gieseanw.wordpress.com }

When dealing with Product teams about your architecture proposal, picture yourself as a plumber who's trying to sell different service packages. This analogy highlights how you should present your technical proposals to Product in a way that aligns with their focus on business value. They’re not interested in technical jargon; they want to know how your architecture decision translates into a return on investment.

Remember that Product people are looking for results. Instead of overwhelming them with details about OLTP systems or ETL processes, you need to frame your explanation as a negotiation — highlighting the costs and benefits of each option, just like the plumber did with his service packages.

"Product doesn’t give a shit about how your data is stored. Product cares about products."

The essence here is to avoid diving into the weeds of indexes or table joins until they understand the impact on their budget and timeline. When they ask, “Why is this so expensive?” that’s your cue to explain, in clear terms, the complexity involved in implementing things like OLAP systems or setting up ETL processes.

Approach your conversation by outlining different “packages” — starting with the 🥇 platinum package that covers all technical needs but at a higher cost. This sets the stage for a value discussion, where Product sees the full picture and starts to understand the trade-offs involved.

"Now you can (gently) talk to them about the difference between online transaction processing systems (OLTP) and online analysis processing systems (OLAP)."

The trick is to guide Product through a step-by-step decision-making process, laying out each feature as a line item on an invoice. This approach helps them grasp which elements of your proposal can be trimmed down or delayed to fit within their budget constraints. For example, if they can't afford a new OLAP system, offer scaled-down options, and negotiate on scope and time rather than quality.

🔥 One of the most crucial points is not to compromise on quality. In software development, you should avoid falling into the trap of lowering standards just to meet short-term goals. Sacrificing quality often leads to delivering subpar products that can damage customer satisfaction in the long run. As the article states, “What’s worse, delivering something a customer actually hates, or delivering nothing at all?” Maintaining a baseline of quality ensures that even with limited resources, you're delivering something worthwhile.

If the Product team suggests cutting corners to fit the project into a two-week sprint, resist the temptation. The iron triangle of software development — time, scope, and budget — should always consider quality as a non-negotiable factor.

Ultimately, you're helping Product to ruthlessly prioritize tasks to deliver the best possible outcomes within the given constraints. In these negotiations, scope will often be the main variable that can be adjusted to balance the budget and timeline. And when the tables turn, and it’s your idea that needs their buy-in, present it in terms of ROI to make a compelling case.

Think like a plumber: when you know the value of what you’re selling, it’s easier to convince others to invest in the right solution instead of a quick fix. Always push for a solution that maintains a minimum level of quality, even if it means delivering less within the same time frame.

2024-11-03 Get Me Out Of Data Hell — Ludicity { ludic.mataroa.blog }

📹 2024-11-03 Nikhil Suresh - Skills that programmers need, to defend both their code and their careers - YouTube { www.youtube.com }

This blog narrates an engineer's daily struggle with an overly complex and inefficient data warehouse system. Despite working within an ostensibly supportive team, the engineer describes their workplace as a "Pain Zone," rife with convoluted processes, unchecked errors, and cultural dissonance. Here’s a detailed breakdown of the main points:

The story begins with a ritual of starting the day with a senior engineering partner. Together, they embark on a shared mission to navigate the "Pain Zone," their term for the warehouse system plagued by unnecessary complexity. The data warehouse in question involves copying text files from different systems, and ideally, this process should require only ten steps. However, the engineer discovers over 104 discrete operations in the architecture diagram, a staggering example of the platform's inefficiency.

"Retrieve file. Validate file. Save file. Log what you did. Those could all be one point on the diagram...That's ten. Why are there a hundred and four?"

The engineer describes the necessity of "Pain Zone navigation," a practice where engineers rely on pair programming for moral support to withstand the psychological toll of working in such an environment. The issue isn’t only technical; it’s deeply cultural. A culture that demands velocity while disregarding craftsmanship fosters an atmosphere where complexity and inefficiency go unchallenged. This attitude, the author suggests, results in the degradation of code quality, with engineers penalized for trying to refactor code.

To illustrate the dysfunction further, the author recounts a routine task: checking if data from sources like Google Analytics is flowing correctly. What they find instead is garbled JSON strings dumped in the logs without logical structure, with 57,000 distinct entries where there should be fifty. This revelation shows that for over a year, the team has been collecting "total nonsense" in the logs.

"We only have two jobs. Get the data and log that we got the data. But the logs are nonsense, so we aren't doing the second thing, and because the logs are nonsense I don't know if we've been doing the first thing."

Rather than address this critical error, management insists on working with the erroneous logs to maintain "velocity," a term often implying efficiency but, in this case, prioritizing speed over accuracy. The author describes the frustration of being told to parse nonsensical data instead of fixing the core issues—a situation summarized by the team motto: "Stop asking questions, you're only going to hurt yourself."

The cultural disconnect deepens as the author tries to work with data from Twitter, only to find that log events lack an event ID. A supposed expert suggests using a column with ambiguous file path strings, each lacking logical identifiers, requiring complex regular expressions to infer events.

"I am expected to use regular expressions to construct a key in my query."

In yet another disheartening revelation, the author learns that the Validated: True log entries are merely hardcoded placeholders, not actual validation statuses. The logs fail to capture real system states, effectively undermining auditability.

By the end, the author reaches a breaking point, realizing their values diverge sharply from those of the organization. This disconnect prompts them to resign, choosing to invest their time in personal projects and consulting instead. In a closing reflection, they criticize the industry for investing in trendy tools like Snowflake and Databricks, without hiring engineers who understand how to design simple, effective systems.

"I could build something superior to this with an ancient laptop, an internet connection, and spreadsheets. It would take me a month tops."

This piece is a critique of both overly complex architectures and a corporate culture that prioritizes speed over quality. It highlights the importance of valuing craftsmanship and straightforward design in building sustainable and efficient data systems.

2024-11-24 SciFi book: Manna – Table of Contents | MarshallBrain.com { marshallbrain.com } (RIP Marshall)

With half of the jobs eliminated by robots, what happens to all the people who are out of work? The book Manna explores the possibilities and shows two contrasting outcomes, one filled with great hope and the other filled with misery.

Join Marshall Brain, founder of HowStuffWorks.com, for a skillful step-by-step walk through of the robotic transition, the collapse of the human job market that results, and a surprising look at humanity’s future in a post-robotic world.

Then consider our options. Which vision of the future will society choose to follow?

• 😺 The building we exited was another one of the terrafoam projects. Terrafoam was a super-low-cost building material, and all of the welfare dorms were made out of it. (Chapter 4)

Newsletters​

2024-09-20 JavaScript Weekly Issue 705: September 19, 2024 { javascriptweekly.com }

2024-09-29 Digital signatures and how to avoid them { newsletter.programmingdigest.net }

2024-09-29 Implementing Blocked Floyd-Warshall algorithm { newsletter.csharpdigest.net }

2024-10-18 JavaScript Weekly Issue 709: October 17, 2024 { javascriptweekly.com }

2024-10-20 How Discord Reduced Websocket Traffic by 40% { newsletter.programmingdigest.net }

2024-10-27 A Brief Introduction to the .NET Muxer { newsletter.csharpdigest.net }

2024-10-27 That's Not an Abstraction { newsletter.programmingdigest.net }

2024-11-17 Exploring the browser rendering process { newsletter.programmingdigest.net }

2024-12-01 Legacy Shmegacy { newsletter.programmingdigest.net }

Working with People​

2024-11-23 Take the Thomas-Kilmann Instrument | Improve How You Resolve Conflict {kilmanndiagnostics.com}

Related:

• 2024-11-23 Guide to the Thomas-Kilmann Conflict Model - My Professional Development {mypd.co.uk}
• 2024-11-23 Thomas-Kilmann Conflict Mode Instrument (TKI®) | The Myers-Briggs Company {www.themyersbriggs.com}

In conflict situations, individuals often exhibit different behavioral strategies based on their approach to managing disagreements. Avoiding is one strategy, and here are four others, alongside avoiding, commonly identified within conflict management models like the Thomas-Kilmann Conflict Mode Instrument (TKI):

Avoiding

• Behavior: The individual sidesteps or withdraws from the conflict, neither pursuing their own concerns nor those of the other party.
• When it's useful: When the conflict is trivial, emotions are too high for constructive dialogue, or more time is needed to gather information.
• Risk: Prolonging the issue may lead to unresolved tensions or escalation.

---

Competing

• Behavior: The individual seeks to win the conflict by asserting their own position, often at the expense of the other party.
• When it's useful: When quick, decisive action is needed (e.g., in emergencies) or in matters of principle.
• Risk: Can damage relationships and lead to resentment if overused or applied inappropriately.

---

Accommodating

• Behavior: The individual prioritizes the concerns of the other party over their own, often sacrificing their own needs to maintain harmony.
• When it's useful: To preserve relationships, resolve minor issues quickly, or demonstrate goodwill.
• Risk: May lead to feelings of frustration or being undervalued if used excessively.

---

Compromising

• Behavior: Both parties make concessions to reach a mutually acceptable solution, often splitting the difference.
• When it's useful: When a quick resolution is needed and both parties are willing to make sacrifices.
• Risk: May result in a suboptimal solution where neither party is fully satisfied.

---

Collaborating

• Behavior: The individual works with the other party to find a win-win solution that fully satisfies the needs of both.
• When it's useful: When the issue is important to both parties and requires creative problem-solving to achieve the best outcome.
• Risk: Requires time and effort, which may not always be feasible in time-sensitive situations.

---

Each of these strategies has its strengths and limitations, and the choice of approach often depends on the context of the conflict, the relationship between the parties, and the desired outcomes.

Wellbeing​

2024-11-03 On Burnout, Mental Health, And Not Being Okay — Ludicity { ludic.mataroa.blog }

In this deeply personal blog post, the author reflects on the mental health struggles that many people face, sharing candid experiences with burnout and severe depression. They emphasize that everyone will have times when they are "Not Okay," and it's important to acknowledge this without shame. Through their own journey of overcoming hardship—ranging from academic pressures to toxic workplaces—they highlight the significance of seeking help, making lifestyle changes, and understanding that recovery is possible. The author encourages readers to care for themselves and others, reminding us that empathy and support can make a profound difference in navigating life's challenges.

✨ New wiki category:

2024-12-01 Psy-Burnout (mental wellbeing) { blog.zharii.com }

Fun / Retro​

2024-11-23 calculatorwords.pdf 344 Words You Can Spell On a Calculator

Compiled by Jim Bennett 2014

2024-11-23 Rendering “modern” Winamp skins in the browser / Jordan Eldredge { jordaneldredge.com }

2024-11-11 Pieter.com - Pieter's Official Homepage { pieter.com }

2024-11-07 MAX SIEDENTOPF — Passport Photos { maxsiedentopf.com }

2024-10-13 stenzek/duckstation: Fast PlayStation 1 emulator for x86-64/AArch32/AArch64/RV64 { github.com }

DuckStation is an simulator/emulator of the Sony PlayStation(TM) console, focusing on playability, speed, and long-term maintainability. The goal is to be as accurate as possible while maintaining performance suitable for low-end devices.

2024-06-18 Where Did You Go, Ms. Pac-Man? — Thrilling Tales of Old Video Games

2024-06-27 Liquid Layers

2024-06-27 Liquid Layers | Hacker News

2024-06-27 Science Fiction Writer Robert J. Sawyer: WordStar: A Writer's Word Processor

2024-06-28 Advent of Code 2023 Day 19: Aplenty - YouTube

Advent of Code in Excel

2024-08-29 Web Design Museum - Discover old websites, apps and software { www.webdesignmuseum.org }

2024-09-19 crowdwave.com { www.crowdwave.com }

Show HN: I made crowdwave – imagine Twitter/Reddit but every post is a voicemail

2024-08-28 Monkeytype | A minimalistic, customizable typing test { monkeytype.com }

Inspiration!​

2024-12-01 Andrew Ayer in the Fediverse { follow.agwa.name }

I honestly liked the design and layout

2024-12-01 To the Fediverse! { www.fediverse.to }

2024-12-01 Pleroma — a lightweight fediverse server { pleroma.social }

2024-12-01 src/App.scss · develop · Pleroma / pleroma-fe · GitLab { git.pleroma.social } Some good examples for using css variables with scss

2024-11-30 GitHub - tldraw/make-real: Draw a ui and make it real {github.com}

2024-11-30 make real • tldraw {makereal.tldraw.com}

2024-11-30 GitHub - SawyerHood/draw-a-ui: Draw a mockup and generate html for it {github.com} ✨FORK SOURCE✨

2024-11-30 tldraw | Steve Ruiz | Substack {tldraw.substack.com}

2024-11-27 Text Blaze: Snippets and Templates for Chrome {blaze.today}

2024-11-26 Monocle · Access and transform immutable data { www.optics.dev }

2024-08-28 The Monospace Web { owickstrom.github.io }

2024-11-24 triyanox/lla: A modern alternative to ls { github.com }

aww! ls with plugins!

2024-11-24 I made an ls alternative for my personal use | Hacker News { news.ycombinator.com } elashri There seems to be a lot of projects that is now competing to replace ls (for people preferences)

For reference, those are the ones I am familiar with. They are somehow active in contrast to things like exa which is not maintained anymore.

eza: (https://github.com/eza-community/eza)

lsd: (https://github.com/Peltoche/lsd)

colorls: (https://github.com/athityakumar/colorls)

g: (https://github.com/Equationzhao/g)

ls++: (https://github.com/trapd00r/LS_COLORS)

logo-ls: (https://github.com/canta2899/logo-ls) - this is forked because main development stopped 4 years ago.

Any more?

Personally I prefer eza and wrote a zsh plugin that is basically aliases that matches what I have from my muscle memory.

2024-11-24 Frosted Glass from Games to the Web - tyleo.com { www.tyleo.com }

2024-11-20 WebVM - Linux virtualization in WebAssembly { webvm.io }

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
|                                                                             |
| WebVM is a virtual Linux environment running in the browser via WebAssembly |
|                                                                             |
| WebVM is powered by the CheerpX virtualization engine, which enables safe,  |
| sandboxed client-side execution of x86 binaries, fully client-side          |
|                                                                             |
| CheerpX includes an x86-to-WebAssembly JIT compiler, a virtual block-based  |
| file system, and a Linux syscall emulator                                   |
|                                                                             |
| [News] WebVM 2.0: A complete Linux Desktop Environment in the browser:      |
|                                                                             |
| https://labs.leaningtech.com/blog/webvm-20                                  |
|                                                                             |
| Try out the new Alpine / Xorg / i3 WebVM: https://webvm.io/alpine.html      |
|                                                                             |
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+

2024-11-08 Home: Mushroom Color Atlas { www.mushroomcoloratlas.com }

2024-11-07 Your Hacker News { yourhackernews.com }

2024-11-07 Aesop's Fables Interactive Book | Read.gov - Library of Congress { read.gov }

2024-11-07 McMaster-Carr { www.mcmaster.com }

McMaster-Carr’s website, www.mcmaster.com, is renowned for its speed, achieved through minimalist design, server-side rendering, and strategic use of technology like ASP.NET and JavaScript libraries. Prefetching techniques preload pages as users hover, ensuring near-instant navigation, while CDNs cache content globally to reduce latency. This streamlined, user-focused approach lets customers quickly access and order from McMaster-Carr’s extensive catalog, making it a leader in industrial supply and a favorite for its seamless, efficient experience.

2024-10-05 Methods of Mandarin { isaak.net }

I got pretty good in Mandarin within 12 months of rigorous part-time study. I'm not even close to perfectly fluent, but I got far into intermediate fluency. Read my personal story of learning Mandarin here: isaak.net/mandarin

This post on my Methods of Mandarin (MoM) is for fellow language learners and autodidacts. This isn't a thorough how-to guide. I won't be holding your hand. It's more like a personal notebook of what worked for me. I'm sharing my personal Anki deck and then I'll describe all my methods and tips. People's styles and methods differ.

2024-08-29 sjpiper145/MakerSkillTree: A repository of Maker Skill Trees and templates to make your own. { github.com }

2024-09-18 Dune Shell { adam-mcdaniel.github.io }

2024-09-19 Comic Mono | comic-mono-font { dtinth.github.io }

2024-09-20 Math4Devs: List of mathematical symbols with their JavaScript equivalent. { math4devs.com }

⌚ Nice watch!​

2024-11-24 Keynote: The Aging Programmer - Kate Gregory - YouTube { www.youtube.com }

Maintain vision health by getting regular eye check-ups, using appropriate glasses, and addressing night driving challenges with clean windshields and adaptive lighting.

Build physical strength and stamina by incorporating strength training (e.g., push-ups, squats) and aerobic activities like walking or biking into daily life.

Reduce pain and joint issues with anti-inflammatories like naproxen as needed and by focusing on flexibility and range-of-motion exercises.

Protect hearing through regular hearing tests starting at age 50, using hearing aids if necessary, and avoiding loud environments or overly high headphone volumes.

Improve nutrition by prioritizing fruits, vegetables, and whole foods while limiting ultra-processed items. Eat meals made with care and hydrate appropriately.

Enhance sleep quality by focusing on creating a comfortable sleep environment (“sleep joy”) and getting the amount of rest your body needs without guilt.

Safeguard brain health using organizational strategies, pursuing lifelong learning, and embracing new tools and technologies to stay sharp.

Foster emotional resilience by prioritizing gratitude and optimism, avoiding unnecessary negativity, and working toward a calm and joyful outlook.

Adapt to changes in ability by recognizing limitations as they arise and addressing them proactively with tools, technology, and support systems.

Combat workplace biases against older programmers by emphasizing your experience, exploring consulting or freelancing, and pushing back against assumptions about learning capacity.

Plan for retirement by calculating your financial “number,” balancing saving with enjoying the present, and planning meaningful activities to avoid boredom and isolation.

Improve work-life balance through flexible work arrangements, prioritizing health, and focusing on work that aligns with your values and passions.

Build relationships by maintaining friendships across generations and engaging with new communities through hobbies, volunteering, or neighborhood activities.

Prevent loneliness by cultivating social engagement in retirement through structured activities, regular interactions, or volunteering.

Develop healthy habits by avoiding smoking, using sunscreen, and embracing preventive measures like vaccinations.

Incorporate joy and play into daily life through hobbies, nature, and small pleasures, focusing on activities that spark happiness and relaxation.

Create a lasting legacy by organizing and preserving personal and professional projects, ensuring they are meaningful and accessible for others.

Handle loss and change by accepting the inevitability of loss while actively seeking new experiences and connections to balance those losses.

Address unexpected challenges by consulting professionals for new or worsening health issues, as not all problems stem from aging.

Reflect on life purpose and make choices that align with long-term happiness and fulfillment.

Exercise regularly to support both physical and mental well-being.

Save for the future while enjoying life in the present.

Stay socially engaged through hobbies, work, or volunteering.

Eat a balanced diet and focus on whole foods for overall health.

Adapt to limitations by embracing tools and strategies that maintain independence.

Build friendships across generations for mutual support and enrichment.

Cultivate a sense of purpose through meaningful work or activities.

Kate Gregory’s message emphasizes that aging well—whether as a programmer or in any field—requires proactive effort, adaptability, and a focus on joy and purpose.