Hasty Briefsbeta

All tags

#software development

297 stories total

Bilingual

Conventional Commits makes me sad
10 months ago
- The author critiques the Conventional Commits specification, particularly its requirements on commit message formatting.
- Key criticisms include the mandatory type prefix in commits, which the author argues is more useful for automated tools and should be in the footer.
- The author points out inconsistencies, such as the exception for 'BREAKING CHANGE' not following the same format as other footer tokens.
- The optional nature of indicating breaking changes is criticized for making it harder for tools to parse commit messages.
- The FAQ section on the Conventional Commits website is also critiqued for lacking detailed instructions on correcting commit types and promoting squash merges, which can lead to loss of commit history.
- The author advocates for commit messages that prioritize human readability over machine readability, suggesting improvements for better tool compatibility.
Can Tinygrad Win?
10 months ago
- Tinygrad's competition is strong, open-source, and run by smart people, unlike comma's past competition in self-driving cars.
- Tinygrad is significantly smaller in line count (14,556 lines) compared to PyTorch (3.3M), JAX (400K), and MLIR (950K), suggesting potential efficiency.
- The hypothesis that tinygrad's small size means it's not competitive in speed or features is challenged; it's already feature-competitive.
- Tinygrad aims to abstract away all but the core problem of scheduling across different scales in machine learning, proposing a unified solution.
- The project's goal is to be the fastest NN framework under 25K lines, capable of handling GPT-5 scale training jobs.
- Key steps include exposing the underlying search problem, ensuring a simple and complete formulation, and applying state-of-the-art search techniques.
- Success could lead to rethinking software development, but it's a high-risk bet compared to comma's more straightforward path.
- Development speed is a critical indicator of tinygrad's potential success, with a significant milestone being the AMD contract to train LLaMA 405B as fast as NVIDIA within a year.
Uncommon Uses of Python in Commonly Used Libraries (2022)
10 months ago
- Python's `super()` function is essential for cooperative multiple inheritance, especially in base classes.
- Mixin classes provide reusable functionality without state, ideal for optional features across multiple classes.
- Relative imports (using `.`) ensure Python searches the current package first, preventing module conflicts.
- Non-empty `__init__.py` files can simplify APIs, refactor code without breaking changes, and initialize package-wide resources.
- Class methods are used when needing class-level operations, while static methods serve as utility functions within a class's namespace.
- `conftest.py` in pytest not only provides fixtures but also helps in modifying `sys.path` for module recognition.
- Design principles in libraries like scikit-learn emphasize consistency and composition, while PyTorch focuses on pragmatic performance and simplicity.
Haxe 5.0 preview.1 has been officially released
10 months ago
- Haxe 5.0.0-preview.1 is officially released as a pre-release version.
- This version is not stable and has known issues, but testing is encouraged to aid the final Haxe 5 release.
- Users encountering version string errors should update or remove the older haxelib version.
- Several removals and breaking changes are noted, including moving sys.db, php.Web, and neko.Web to hx4compat lib.
- General improvements and bugfixes include enabling parallelism and resolving various technical issues.
PHP 8.5 alpha 1 is available for download
10 months ago
- PHP 8.5.0 Alpha 1 is now available for testing.
- This marks the beginning of the PHP 8.5 release cycle.
- Users are encouraged to download and test the release, reporting any issues on GitHub.
- This version is not recommended for production use as it is an early test version.
- Details on new features and changes can be found in the NEWS and UPGRADING files.
- The next planned release is Alpha 2, scheduled for July 17, 2025.
- Release signatures are available in the manifest or on the Release Candidates page.
Measuring the Impact of AI on Experienced Open-Source Developer Productivity
10 months ago
- Randomized controlled trial (RCT) shows AI tools slow down experienced open-source developers by 19%.
- Study aims to understand AI's real-world impact on software development, contrasting with benchmarks.
- 16 experienced developers worked on 246 real issues, with or without AI tools, recording their screen time.
- Developers expected AI to speed them up by 24%, but even post-study, they believed AI sped them up by 20%.
- Five factors identified as likely contributors to the slowdown, with many experimental artifacts ruled out.
- Discussion highlights discrepancies between benchmark scores, anecdotal reports, and RCT results.
- Framework proposed to reconcile different sources of evidence on AI capabilities.
- Future studies planned to track AI's impact on developer productivity, signaling broader AI R&D acceleration risks.
Daniel Stenberg of Curl on how and why he does it
10 months ago
- The author receives admiration for their consistency and perseverance in maintaining the curl project.
- Defines their primary work as driving the curl project, which includes development, reviewing, debugging, and leading.
- Emphasizes the importance of keeping up with Internet protocol developments and providing feedback from a small player's perspective.
- Highlights the role of commercial customers in enabling full-time work on curl.
- Expresses a strong sense of loyalty and commitment to the project, enjoying the challenges and puzzles of software development.
- Describes the motivation behind making curl the best in every aspect, including documentation, security, and newcomer-friendliness.
- Details a typical workday, balancing regular work hours with evening shifts to accommodate time differences.
- Mentions the independence of the curl project, not controlled by any company or foundation.
- Discusses the challenges of maintaining motivation over time and the importance of positive feedback from users.
- Explains the social and collaborative aspects of working on an open-source project like curl.
- Stresses the importance of leading by example, reducing bureaucracy, and maintaining a friendly, direct communication style.
- Acknowledges the support of a loving family in sustaining long-term commitment to the project.
No Code Is Dead
10 months ago
- Generative AI (GenAI) is transforming software development by enabling non-technical users to build apps using natural language, potentially making traditional no-code platforms obsolete.
- Experts highlight concerns about 'vibe coding' leading to technical debt and unmaintainable code, emphasizing the need for understanding and governance in AI-generated applications.
- No-code and low-code platforms are evolving by integrating AI, with some predicting a future where AI agents handle technical implementation while humans focus on outcomes.
- Hybrid approaches, like Bubble's AI-powered visual development, aim to combine AI's speed with the transparency and control of traditional no-code tools.
- Enterprise platforms like Microsoft's Power Platform are leading the way by embedding AI into governance-heavy, scalable solutions, ensuring security and maintainability.
- The distinction between no-code and low-code is critical, with low-code platforms seen as more sustainable due to their readability and governance features.
- AI is expected to accelerate the adoption of low-code platforms rather than replace them, with vendors integrating AI to enhance existing workflows.
- The future of development lies in blending AI's accessibility with engineering discipline, ensuring scalable and secure applications.
- Collaboration between business and technical users ('fusion teams') is becoming more important, with platforms facilitating this interaction.
- Governance remains a key challenge for AI-generated code, with enterprise solutions focusing on automated policies and security controls.
AI slows down open source developers. Peter Naur can teach us why
10 months ago
- AI tools slow down experienced open-source developers by 19% when working on familiar codebases, contrary to their expectations of a 24% speedup.
- Developers' inability to accurately perceive the impact of AI tools on their productivity highlights a gap between belief and reality.
- The study's findings may not generalize to all developers, especially those working on unfamiliar or corporate projects where AI could offer productivity gains.
- The slowdown is theorized to stem from the difficulty in transferring developers' rich mental models of their projects to AI tools, which lack understanding and context.
- AI tools might benefit developers working on unfamiliar codebases by quickly generating functional code, but this approach may hinder the development of a deep mental model of the system.
- For long-term project understanding and effectiveness, manually writing code is recommended over relying on current AI tools.
AI coding may not be helping as much as you think
10 months ago
- A new study from METR found that AI coding tools slowed down task completion time by 19% for experienced developers.
- Developers initially expected AI tools to speed up their work by 24%, but post-study estimates were reduced to 20%.
- The study focused on experienced developers working on large, complex codebases they helped build.
- Caveats include the possibility of greater productivity benefits for less experienced developers or smaller projects.
- The disconnect between perceived and actual productivity gains calls for reevaluation of AI tool efficacy.
- Personal experience highlights AI's role in enabling non-experts to complete complex coding projects with guidance.
- Potential biases include overestimating personal time savings and shallow testing of code quality.
- The study underscores the need for measured assessments of AI's impact on coding productivity.
Assumptions
10 months ago
- Building a complex system with many unknowns leads to making numerous assumptions.
- Technical issues can sometimes be guessed correctly by following trends, but skepticism is advised.
- Business domain knowledge is crucial; learning or consulting experts is ideal but not always possible.
- Code should reflect certainty: static for absolute certainty, dynamic for uncertainty.
- Polymorphism and encapsulation help manage uncertainty by allowing easy future modifications.
- Scope creep often results from incorrect initial assumptions rather than actual expansion.
- Developers who understand business problems adapt better than those who just code specifications.
- Speculative generalization saves time in the long run by avoiding future refactoring drama.
- Small, synchronized teams outperform larger teams due to better alignment and communication.
- Objective self-assessment of knowledge leads to better coding choices and smoother releases.
The Big Oops: Anatomy of a Thirty-Five Year Mistake
10 months ago
- Presentation on the history of OOP at the Better Software Conference, kept under two hours.
- Research involved reviewing over a thousand pages of source material, with many stories left out.
- Proposal for a livestream to discuss additional historical documents not covered in the talk.
- Four key historical papers recommended for further reading: Early History of Smalltalk, History of C++, Development of the Simula Languages, and Origins of the APT Language.
- Interest expressed by the audience in a livestream to explore the topic in more depth.
Coding with LLMs in the summer of 2025 (an update)
9 months ago
- Frontier LLMs like Gemini 2.5 PRO enhance programmer capabilities by understanding vast topics and code quickly.
- Key benefits include bug elimination before deployment, faster idea exploration, and pair-design activities with LLMs.
- LLMs can accelerate work by writing code under clear specifications and aiding in unfamiliar technologies.
- Human+LLM collaboration is more productive than humans alone, requiring strong communication skills.
- Providing extensive context to LLMs, including bad/good solutions and clear goals, improves code quality.
- Best LLMs for coding are Gemini 2.5 PRO and Claude Opus, with Gemini being more semantically powerful.
- Avoid agents or integrated coding tools; use frontier LLMs directly and maintain control over the process.
- Current best practice is to stay in the loop with LLMs, retaining control for high-quality, minimal, and well-understood code.
- Future advancements may shift more coding tasks to AI alone, but human oversight remains crucial for now.
I'm tired of talking about AI
9 months ago
- The author expresses exhaustion and frustration over the ongoing discourse about generative AI, especially in coding.
- Despite respected peers changing their stance on AI, the author remains unconvinced and unwilling to adopt AI tools without solid reasoning.
- The author critiques common arguments for AI adoption, such as fear of job loss and democratization of coding, finding them unconvincing or contradictory.
- Concerns about AI include its inability to form a 'theory of the system'—a core aspect of programming—and its environmental and ethical implications.
- The author questions the economic sustainability of AI, doubting its trillion-dollar valuation and fearing a future where software development becomes less fulfilling.
- Ethical concerns are raised about AI's use of stolen intellectual property and its role as a tool for capital to undercut labor.
- The author speculates on a bleak future where AI transforms software development into a task of managing AI outputs, potentially making the job unappealing.
The .a File Is a Relic: Why Static Archives Were a Bad Idea All Along
10 months ago
- The article criticizes static archives (.a files) for being a flawed method for static linking in C-based SDKs.
- Dynamic linking (.so files) allows for easier updates and security fixes without recompilation, while static linking bundles dependencies into the executable.
- Static archives are essentially raw object files (.o) archived together, leading to issues like symbol conflicts and bloated binaries.
- Linker flags like --whole-archive attempt to mitigate issues but introduce new problems, such as unnecessary inclusion of all object files.
- The lack of symbol visibility control in static archives exposes internal functions, posing security and reverse engineering risks.
- The author proposes a new format, 'Static Bundle Object' (.sbo), combining benefits of shared objects with static linking, despite potential binary size increases.
- Transitioning to a new linking format would require widespread toolchain updates and adoption across Linux distributions, a lengthy process.
Why Java Is Still Worth Learning in 2025: A Developer's 25-Year Journey
9 months ago
- Initial skepticism towards Java due to its automatic memory management and perceived bloat compared to C and assembler.
- Transformation into a Java advocate after experiencing its evolution and improvements, especially from Java 1.6 onwards.
- Appreciation for Java's continuous evolution, addressing developer pain points and reducing cognitive overhead with features like generics, records, and pattern matching.
- Java's backward compatibility highlighted as a career investment, with examples of long-running codebases successfully upgraded over decades.
- The Java ecosystem's diversity in JDK distributions, frameworks, and build tools, offering flexibility without vendor lock-in.
- The supportive and innovative Java community, from local JUGs to international conferences, fostering growth and knowledge sharing.
- Java's relevance in 2025 due to its solid foundations for AI, cloud-native capabilities, and sustainable development practices.
- Introduction of modern Java features like virtual threads (Project Loom) simplifying concurrent programming.
- Practical advice for getting started with Java in 2025, emphasizing modern Java, fundamentals, real projects, and community engagement.
- Conclusion affirming Java's value as a stable, evolving language with a supportive community, ideal for long-term career growth.
Using Radicle CI
9 months ago
- Radicle CI is used for software development, integrating with Git repositories hosted on Radicle.
- The Radicle CI broker listens for repository change events and invokes an adapter to run CI, supporting various CI systems.
- A sample Rust project demonstrates setting up CI with Radicle, including local CI runs and server-based CI configurations.
- Local CI runs can be executed using the `rad-ci` extension, allowing developers to emulate server CI environments locally.
- CI configuration is repository-specific, with `.radicle/ambient.yaml` used for Ambient CI.
- Issues and changes are managed through Radicle's desktop application and command-line tools, with patches triggering CI runs.
- The process includes creating patches, running CI, fixing issues, and merging changes, all integrated with Radicle's workflow.
- Installation instructions are provided for Radicle, Radicle CI, and related tools, with a focus on Debian systems.
- The author reflects on the evolution of CI systems, aiming for a less irritating and more efficient development experience.
Good Docs Describe, Bad Docs Prescribe
9 months ago
- The Agile Manifesto prioritizes 'Working software over comprehensive documentation'.
- Modern documentation like ADRs, RFCs, and Alignment Docs can become bureaucratic hurdles, slowing progress and freezing untested assumptions.
- Good documentation describes the current state of software, not future aspirations, and should follow implementation to stay accurate.
- Generated docs, inline code comments, project READMEs, and literate programming are effective because they are anchored to the code and resist drift.
- Agile teams should prioritize working software and adapt documentation as the code evolves, avoiding the pitfalls of prescriptive documentation.
Getting into Flow State with Agentic Coding
9 months ago
- The author describes a workflow for using AI agents (Claude Code) in software development to enhance productivity and maintain flow state.
- Key steps include setting up a master AI instructions file to avoid repetitive explanations, planning tasks meticulously with the AI agent, and then executing the plan with specialized agents (Implementer, Tester, Documenter).
- The planning phase is emphasized as crucial for providing high-quality context to AI agents, ensuring better output and allowing seamless continuation of work.
- The author advocates for breaking down features into multiple stacked PRs, each with a discrete plan, to manage complexity and maintain code quality.
- Verification and refactoring are highlighted as essential steps to ensure code correctness and cleanliness, with the author leading the strategy and using AI agents for execution.
- The final review involves checking the code in a different context (e.g., GitHub PRs) to catch any missed mistakes, maintaining high standards.
- The workflow allows the author to focus on deep work and strategic thinking while delegating boilerplate and repetitive tasks to AI agents.
I Know When You're Vibe Coding
9 months ago
- The author emphasizes the importance of code quality and maintainability over the method of code creation.
- They express concern about LLM-generated code that doesn't follow project conventions, even if it's functional.
- The article highlights the importance of adhering to existing patterns and standards for maintainable software.
- The author criticizes the rush to push out software quickly at the expense of quality.
- They advocate for caring about long-term effects, consistency, and following established principles in software development.
- The piece suggests improving LLM prompts by providing better descriptions, specifying libraries, and giving examples.

first prev4next

About|Login

#software development

Conventional Commits makes me sad

Can Tinygrad Win?

Uncommon Uses of Python in Commonly Used Libraries (2022)

Haxe 5.0 preview.1 has been officially released

PHP 8.5 alpha 1 is available for download

Measuring the Impact of AI on Experienced Open-Source Developer Productivity

Daniel Stenberg of Curl on how and why he does it

No Code Is Dead

AI slows down open source developers. Peter Naur can teach us why

AI coding may not be helping as much as you think

Assumptions

The Big Oops: Anatomy of a Thirty-Five Year Mistake

Coding with LLMs in the summer of 2025 (an update)

I'm tired of talking about AI

The .a File Is a Relic: Why Static Archives Were a Bad Idea All Along

Why Java Is Still Worth Learning in 2025: A Developer's 25-Year Journey

Using Radicle CI

Good Docs Describe, Bad Docs Prescribe

Getting into Flow State with Agentic Coding

I Know When You're Vibe Coding