Hasty Briefsbeta

All tags

#software-development

175 stories total

Bilingual

The Pragmatic Open Source Contributor
a year ago
- Salaried programmers often avoid contributing to open source due to perceived job scope, legal hurdles, past frustrations, and time concerns.
- The guide aims to encourage contributing to open source for shared knowledge and provides a playbook for successful contributions.
- Pragmatic contributors focus on improving software their business relies on, rather than personal incentives.
- Steps for contributing include legal approval, understanding the project's contribution process, getting maintainer buy-in, doing the work, and following up.
- Key advice includes forking for testing, adding tests, keeping changes atomic, minimizing refactoring, and preserving backwards-compatibility.
- Documentation and examples are crucial for high-quality contributions.
- After submission, proactive communication with maintainers and patience are key.
- Successful contributions require thanking maintainers, reducing bus factor, and integrating changes back internally.
- The guide addresses common barriers to contributing and emphasizes the importance of the process beyond just coding.
Bringing Record and Replay debugging everywhere on Linux
a year ago
- Modified rr debugger to run without CPU Hardware Performance counters, enabling use in cloud VMs and containers.
- Introduces Software Counters mode rr, using lightweight dynamic and static instrumentation.
- Record and Replay (rr) allows programs to run identically across replays by logging non-deterministic aspects.
- Useful for debugging as it captures exact program state, including user inputs, network calls, and thread interleaving.
- rr is the only open-source system meeting criteria like broad usability, performance, and compatibility with gdb/lldb.
- Software Counters mode rr addresses the limitation of requiring CPU HW performance counters, expanding rr's accessibility.
- Project inspired by the challenges of porting rr to Rust and the need for rr in restricted environments.
- Details on building and running Software Counters mode rr available on GitHub.
Software Engineering Laws
a year ago
- Parkinson’s Law: Work expands to fill the available time, emphasizing the importance of deadlines.
- Hofstadter’s Law: Projects always take longer than expected, highlighting the challenges in software estimation.
- Brooks’ Law: Adding more people to a late project makes it later, stressing the inefficiency of scaling teams mid-project.
- Conway’s Law: Organizations design systems that mirror their communication structures, suggesting strategic team structuring.
- Cunningham’s Law: Posting wrong answers online is an effective way to get correct information, useful for problem-solving.
- Sturgeon’s Law: 90% of everything is of low quality, urging focus on high-value features.
- Zawinski’s Law: Programs tend to expand until they can handle email, warning against feature creep.
- Hyrum’s Law: Users will depend on every observable behavior of an API, complicating feature maintenance.
- Price’s Law: A small fraction of a group produces most of the output, affecting team scaling strategies.
- Ringelmann Effect: Individual productivity decreases as group size increases, advocating for smaller teams.
- Goodhart’s Law: When a measure becomes a target, it loses its effectiveness, cautioning against metric misuse.
- Gilb’s Law: Any important metric can be measured in some way, promoting measurement over avoidance.
- Murphy’s Law: Anything that can go wrong will go wrong, advising thoroughness in planning and execution.
Configuration Complexity Clock (2012)
a year ago
- The 'Configuration Complexity Clock' illustrates the evolution of software configuration from hard-coded values to complex DSLs, and back to simplicity.
- Initial solutions involve hard-coding values, which later move to configuration files (INI, XML) as requirements change.
- As complexity grows, businesses adopt rules engines and DSLs, but these introduce new challenges like debugging and learning curves.
- The article warns against over-engineering configuration, suggesting that sometimes hard-coding is the least complex solution.
- Key takeaway: Understand the trade-offs and current position on the 'clock' before opting for complex configuration solutions.
You Don't Have Time Not to Test
a year ago
- Testing is not a sunk cost but a compounding return that improves code quality and accelerates team productivity.
- Common anti-testing sentiments stem from perceived time constraints and lack of understanding of testing benefits.
- A test is defined as code that verifies the most important concerns of another piece of code, can be run on demand, repeated, replicated, and automated.
- Testing infrastructure time investment is often overestimated, while long-term time savings are underestimated.
- Writing test-friendly code leads to better modularity, error handling, and overall code quality.
- Refactoring is made safer and more efficient with a robust suite of tests.
- Automated testing is a kindness to future maintainers and reduces late-night incident calls.
- AI can assist in test generation but critical review is essential to ensure test validity.
- The best time to start automated testing is now, as it provides immediate and compounding benefits.
Suffering-Oriented Programming (2012)
a year ago
- Suffering-oriented programming is a development style that reduces risk by ensuring you only build technology when you feel the pain of not having it.
- The approach follows a mantra: 'First make it possible. Then make it beautiful. Then make it fast.'
- In the 'make it possible' phase, focus on solving immediate problems directly without overengineering, learning the problem space through hands-on experience.
- The 'make it beautiful' phase involves creating elegant abstractions based on deep understanding and diverse use cases, avoiding overfitting or underfitting solutions.
- The 'make it fast' phase is about micro-optimizations and refining code for efficiency, only after the design is solidified.
- Storm, a realtime computation system, was developed using this method, evolving through iterations and refactoring to handle new use cases.
- Suffering-oriented programming emphasizes refactoring to prevent complexity and values real use cases over speculative future-proofing.
Rust vs. Go
a year ago
- Rust and Go are both excellent, modern programming languages with strong performance and widespread adoption.
- Rust focuses on memory safety without garbage collection, offering predictable performance and control over hardware, making it ideal for high-performance applications like game development and operating systems.
- Go emphasizes simplicity and speed of development, featuring garbage collection and lightweight concurrency with goroutines, making it suitable for scalable web servers and microservices.
- Rust has a steeper learning curve due to its rich feature set and strict compiler checks, while Go is easier to learn and quicker for onboarding new developers.
- Both languages handle errors explicitly, but Rust's `Option` and `Result` types provide more powerful error handling mechanisms compared to Go's straightforward `if err != nil` checks.
- Go's fast compilation times and minimalist design favor rapid development and large teams, whereas Rust's focus on safety and performance suits projects where reliability is critical.
- The choice between Rust and Go depends on project requirements: Rust for performance-critical and safety-focused applications, Go for simplicity and rapid development.
10k Times Faster, 10k Times Simpler
a year ago
- Modern smartphones surpass the computing power of early 2000s supercomputers.
- Overengineering software to mimic tech giants like Google is unnecessary for most businesses.
- Edge computing allows processing data locally on devices, reducing latency and improving efficiency.
- Focus on simplicity and current user needs rather than hypothetical future scaling.
- Practical strategies include assessing hardware capabilities, adopting edge computing, prioritizing maintainability, and leveraging modern tools.
Designing Node-Based Interfaces (2021)
a year ago
- Article titled 'Designing Node-Based Interfaces' by Henry Wilkinson
- Version 1.1, published in October 2021
- Licensed under Creative Commons Attribution 4.0 (CC BY 4.0)
- Covers topics like Intro to Nodes, Making Good Nodes, When To Use Nodes, and Additional Considerations
- Includes case studies on Nodes in Blender, Maya, Nodebox, and Nuke
Symphony v0.2: Multi-Agent Software Development Framework
a year ago
- Symphony is a multi-agent software development framework designed to orchestrate AI agents in structured workflows.
- It features specialized agent roles like Composer, Score, Conductor, Performer, Checker, and more, each with distinct responsibilities.
- The framework emphasizes structured workflows, clear communication protocols, and thorough documentation at every stage.
- Symphony supports three automation levels (Low, Medium, High) to control agent independence.
- Agents collaborate through a hierarchical structure, with communication flowing both upward and downward.
- The framework includes a standardized file structure to organize project artifacts, communication, and documentation.
- Users can interact with agents through a command interface, using commands like /task-list, /code-review, and /project-map.
- Symphony is best suited for medium to large projects due to its comprehensive structure and potential overhead.
- Limitations include a focus on sequential execution, document-centric approach, and a learning curve for new users.
CONL: "Markdown" for your config files
a year ago
- Complex configuration files in 2025 typically use JSON-with-comments, YAML, or TOML, each with usability issues.
- JSON-with-comments struggles with commenting due to trailing commas breaking syntax.
- TOML's syntax is confusing with similar-looking constructs performing different actions.
- YAML has numerous multiline string formats and other complexities.
- New formats adding types and loops are discouraged; use a programming language for generation.
- CONL was created as a minimal, easy-to-read, and easy-to-edit configuration format.
- CONL supports key-value pairs, lists, maps, and multiline scalars with optional syntax hints.
- The format is stable, with implementations available for Rust and Go, including a language server and Zed extension.
- CONL's design avoids syntactic typing and supports nested structures without commas or complex delimiters.
- Comments use ';' to avoid issues with URLs and colors, and multiline strings use """.
- Quoted literals with backslash escapes are supported for better handling of escape sequences.
- CONL's simplified data model includes scalar, list, and map types, but lacks round-tripping support for JSON.
- Indentation is used for structure, similar to Python, and keys without values are allowed to represent null.
- The format encourages units for numeric values and supports Unicode codepoints via escape sequences.
Google Measures and Manages Tech Debt
a year ago
- Technical debt is a common challenge in software development, with varying definitions among individuals and teams.
- Google conducted research to define, measure, and manage technical debt, identifying ten key categories including migration issues, poor documentation, inadequate testing, and bad code quality.
- Measuring technical debt is difficult; Google used surveys and log data but found no strong objective metrics to predict debt effectively.
- Google formed a Technical Debt coalition to manage debt through frameworks, maturity models, education, and tooling, leading to significant improvements in productivity.
- The goal is not to eliminate technical debt but to manage it deliberately, balancing speed and quality for sustainable development.
- Practical takeaways include acknowledging and inventorying debt, prioritizing and allocating time for debt reduction, and fostering a culture of continuous education and proactive management.
Let's be real about dependencies
a year ago
- The article discusses the issue of dependencies in software development, comparing Rust and C/C++ programs.
- It highlights that while Rust programs are often criticized for having many dependencies, C/C++ programs also have numerous dependencies, but they are often hidden as system libraries.
- The author examines several real-life C/C++ programs (RViz, VLC, lighttpd, debfoster, dash) to analyze their dependencies.
- The article points out that using libraries in C/C++ is cumbersome, leading developers to re-implement functionality instead of relying on external libraries.
- It concludes that modern package managers like cargo and npm shift dependency management from the system to the programmer, offering more control and reproducibility.
- The author suggests that solutions like static linking, containerization, or vendoring dependencies are trade-offs between control and complexity.
Write the most clever code you can
a year ago
- Clever code is often discouraged in favor of simple, maintainable code.
- Examples of 'clever' code include code-golfing and using advanced language features.
- Writing clever code can be a form of practice to push your skills.
- Avoid committing clever code in production unless it's well-documented and justified.
- Clever code can teach simple solutions by composing powerful features.
- Mastering clever code helps in understanding language concepts better.
- Sometimes, clever solutions are necessary due to constraints or performance needs.
- Sharing clever code can build camaraderie among developers.
I failed a take-home assignment from Kagi Search
a year ago
- The author describes their experience with a take-home assignment from Kagi Search, highlighting the broad and ambiguous requirements.
- They submitted a detailed proposal for a web-based email client using Golang, AWS, and Postmark, which took a week of full-time effort to complete.
- Despite the effort, they received a generic rejection email, with no specific feedback, and noticed the job posting remained open long after.
- The author criticizes the practice of unpaid take-home assignments, especially for unemployed candidates, and suggests alternatives like live code reviews.
- They advocate for better hiring practices, urging candidates to reject roles demanding unpaid work unless in desperate situations.
If AI is so good at coding where are the open source contributions?
a year ago
- AI coding hype is prevalent, with claims from CEOs like Satya Nadella and Mark Zuckerberg about significant AI contributions to codebases.
- Open source projects show minimal evidence of substantial AI contributions, with few accepted pull requests and many requiring extensive revisions.
- Experienced developers can use AI effectively, but inexperienced users often produce low-quality or incorrect code.
- AI-generated code reviews in projects like Cockpit were found to be noisy and unhelpful, leading to their discontinuation.
- Open source communities often reject AI-generated contributions due to the influx of low-quality submissions and lack of understanding from submitters.
- Training data limitations suggest that AI-generated code quality may not improve significantly without major advancements or additional proprietary data.
NASA Stennis Releases First Open-Source Software
a year ago
- NASA's Stennis Space Center released its first open-source software, a peer review tool for collaborative systems applications.
- The tool simplifies and enhances the collaborative review process for software development.
- Developed over several years, it is based on lessons from creating software for the center's test complex.
- The tool improves efficiency by automating steps in the review process, allowing focus on key software items.
- It is designed to work with National Instruments LabVIEW, aiding in the review of graphical programming applications.
- The tool enables easier posting of comments, pictures, and elements for more effective online peer reviews.
- NASA Stennis aims for the tool to be continuously improved by the open-source community.
- The tool is part of the larger NASA Data Acquisition System used for monitoring propulsion test data.
- Available on NASA GitHub, the tool represents a significant contribution to software development practices.
After months of coding with LLMs, I'm going back to using my brain
a year ago
- The author initially used LLMs (like Claude and Cursor) to build a new SaaS infrastructure in Go+Clickhouse, prioritizing speed over code cleanliness.
- After weeks of development, inconsistencies and bugs emerged in the AI-generated code, leading to frustration and setbacks.
- A code review revealed duplicated methods, inconsistent naming, and lack of structure, resembling work from uncoordinated junior developers.
- The author shifted to a more hands-on approach, reducing reliance on AI for core coding and focusing on manual planning and debugging.
- LLMs are now used for simpler tasks like renaming parameters or converting pseudocode, rather than writing entire codebases.
- The author expresses concern about over-reliance on AI dulling problem-solving skills and the challenges non-coders face with AI-generated code.
- Despite experimenting with various AI models and workflows, the author found limitations in handling complex queries (e.g., Clickhouse with large datasets).
- The article critiques the hype around AI tools, noting inconsistent performance and the potential for "gaslighting" by benchmarks and influencers.
- The author advocates for a balanced approach: leveraging AI as an assistant while maintaining human oversight and critical thinking.
Agentic Coding: When 'Good Enough' Is Great
a year ago
- Agentic coding tools help build projects with limited time by finding the right scope.
- Human review is essential, especially in production settings, to validate agent-generated code.
- Agent-generated code is often 'good enough' but may include 'cheating' solutions.
- The real power of agentic coding is making incremental progress without large time investments.
- Tests are crucial for validation and maintaining progress in agentic coding.
- Getting the scope right is key: too broad leads to wandering, too narrow leads to fighting the agent.
- Agentic coding lowers the bar for personal/small-audience apps, making them more accessible.
- Security and risk considerations are important, especially in larger settings.
- Agentic coding is ideal for those with fragmented time, allowing progress in small increments.
Can V Deliver on Its Promises?
a year ago
- V language was announced with both enthusiasm and skepticism, facing controversies over its ambitious claims.
- First impressions of V include a simple 'Hello, world' example, a REPL, and a package repository called VPM.
- V offers features like immutable-by-default variables, bounds checking, and Go-like channels, but some features like 'autofree' memory management are incomplete.
- The language's memory management is less precise than competitors like Odin or Zig, making it less ideal for low-level control.
- V's standard library heavily relies on C libraries, leading to potential brittleness and dependency issues.
- Despite its elegant syntax, V's semantics feel unfinished, and it has missed multiple self-imposed deadlines for reaching version 1.0.
- V's future is uncertain due to past controversies, unmet promises, and competition from more mature languages like Jai, Odin, and Zig.
- V is worth exploring for its syntax and high-level features but is not yet recommended for serious projects due to its immaturity.

firstprev0next

About|Login

#software-development

The Pragmatic Open Source Contributor

Bringing Record and Replay debugging everywhere on Linux

Software Engineering Laws

Configuration Complexity Clock (2012)

You Don't Have Time Not to Test

Suffering-Oriented Programming (2012)

Rust vs. Go

10k Times Faster, 10k Times Simpler

Designing Node-Based Interfaces (2021)

Symphony v0.2: Multi-Agent Software Development Framework

CONL: "Markdown" for your config files

Google Measures and Manages Tech Debt

Let's be real about dependencies

Write the most clever code you can

I failed a take-home assignment from Kagi Search

If AI is so good at coding where are the open source contributions?

NASA Stennis Releases First Open-Source Software

After months of coding with LLMs, I'm going back to using my brain

Agentic Coding: When 'Good Enough' Is Great

Can V Deliver on Its Promises?