Stories with Tag blame

• Show HN: "Git who" – A new CLI tool for industrial-scale Git blaming

  permalink

  Posted: 2025-03-18 20:20:09

  Verbose tl;dr

  git-who is a new command-line tool designed to improve Git blame functionality for large repositories and teams. It aims to provide a more informative and efficient way to determine code authorship, particularly in scenarios with frequent merges, rebases, and many contributors. Unlike standard git blame, git-who aggregates contributions by author across commits, offering summaries and statistics such as lines of code added/removed and commit frequency. This makes it easier to identify key contributors and understand the evolution of a codebase, especially in complex or rapidly changing projects.

  The Hacker News post introduces "Git who," a new command-line interface (CLI) tool designed to enhance the Git blame functionality, specifically targeting large-scale or "industrial-scale" Git repositories and complex projects. Traditional git blame can become slow and resource-intensive when used on files with extensive histories and frequent contributions. "Git who" aims to address these performance bottlenecks by optimizing the blame operation.

  The tool, written in Rust, leverages several strategies to achieve improved speed and efficiency. It parses the output of git log -p --follow -- <file> but implements its own internal logic for analyzing the changes and attributing them to specific authors, rather than relying on Git's built-in blame mechanism. This independent processing allows for more targeted and efficient computation of blame information. The tool's focus is strictly on identifying who last touched each line of a file, omitting the date and time information usually provided by git blame. This streamlined approach contributes to its performance advantages.

  The post emphasizes the tool's suitability for very large files and repositories where traditional blame operations might struggle. The core functionality boils down to displaying a concise, line-by-line attribution of authorship, presenting only the author's name or identifier for each line in the specified file. The output is designed to be easily parsed and utilized by other tools or scripts. The project is open-source and available on GitHub, encouraging community contributions and further development. The author positions "Git who" as a valuable addition to the toolkit of developers working with large and complex Git projects.

  • git
  • cli
  • command-line
  • Tool
  • blaming
  • blame
  • version control
  • Software Development
  • Open Source
  • GitHub
  • developer tools
  • productivity
  • Code
  • programming

  Summary of Comments ( 54 )
  https://news.ycombinator.com/item?id=43404548

  Verbose tl;dr

  HN users generally found git-who interesting and potentially useful. Several commenters appreciated its ability to handle complex blame scenarios across merges and rewrites, suggesting improvements like integrating with a GUI blame tool and adding options for ignoring certain commits or authors. Some debated the term "industrial-scale," feeling it was overused, while others pointed out existing tools with similar functionality, such as git fame and the "View Blame Prior to this Commit" feature in IntelliJ. There was also discussion around performance concerns for very large repositories and the desire for more robust filtering and sorting options. One user even offered a small code improvement to handle empty input gracefully.

  The Hacker News post about "Git who," a CLI tool for industrial-scale Git blaming, has generated several comments discussing its utility, potential alternatives, and specific features.

  Several commenters appreciated the tool's focus on speed and efficiency, especially when dealing with large repositories and blame history. One commenter highlighted the slow performance of git blame in such scenarios and expressed interest in trying git-who. Another user questioned the necessity of a new tool, suggesting that tools like git log -S might suffice. A response to this suggested that git-who offered more convenient filtering options and a clearer presentation of results, especially for identifying the introduction and removal of lines of code.

  The discussion also touched on the complexities of accurately attributing code changes in large, collaborative projects. One commenter pointed out the challenges posed by code refactoring and merging, which can make it difficult to pinpoint the true origin of specific lines. This commenter suggested incorporating features to handle code moves and rewrites effectively.

  A few commenters expressed interest in the tool's integration with other development tools and workflows. One suggested the possibility of integrating git-who with code review platforms or IDEs to provide more context during code analysis.

  The ability to quickly identify the author of specific lines of code, especially in large codebases, resonated with many commenters. This is particularly relevant in industrial settings where understanding the history and evolution of code is crucial for maintenance, debugging, and future development. The speed improvements offered by git-who over traditional git blame were seen as a significant advantage.

  Overall, the comments suggest a positive reception to git-who, with a focus on its potential for improving developer workflow and efficiency in large-scale Git projects. The discussion highlights the challenges of code attribution in complex projects and suggests avenues for further development and integration.

• "A computer can never be held accountable"

  permalink

  Posted: 2025-02-03 22:01:38

  Verbose tl;dr

  Simon Willison argues that computers cannot be held accountable because accountability requires subjective experience, including understanding consequences and feeling remorse or guilt. Computers, as deterministic systems following instructions, lack these crucial components of consciousness. While we can and should hold humans accountable for the design, deployment, and outcomes of computer systems, ascribing accountability to the machines themselves is a category error, akin to blaming a hammer for hitting a thumb. This doesn't absolve us from addressing the harms caused by AI and algorithms, but requires focusing responsibility on the human actors involved.

  Simon Willison's blog post, "A computer can never be held accountable," elaborates on the fundamental inability of computational systems to bear genuine responsibility for their actions. Willison argues that accountability, in its truest sense, necessitates consciousness and the capacity for subjective experience, including understanding the consequences of one's actions and the potential for remorse or guilt. Computers, being deterministic machines operating on pre-programmed instructions, lack these crucial components of sentience. He meticulously distinguishes between accountability and the appearance of accountability. While sophisticated algorithms can mimic human decision-making and even adapt their behavior based on feedback, these are merely complex calculations, not reflections of genuine understanding or moral agency.

  Willison further elucidates this distinction by exploring the concept of legal accountability. He posits that holding a computer legally accountable is fundamentally nonsensical, as punishment, a cornerstone of legal systems, relies on inflicting suffering or deprivation on a conscious being. A computer, devoid of subjective experience, cannot experience suffering and therefore cannot be meaningfully punished. Any attempt to "punish" a computer, such as deleting its data or shutting it down, is merely a pragmatic measure to prevent future harm, not an act of retributive justice.

  The author also examines the practice of holding humans accountable for the actions of computer systems, particularly in the context of algorithmic bias and unintended consequences. He emphasizes that while assigning blame to individuals involved in the design, development, or deployment of problematic systems might be necessary for practical reasons, it's crucial to recognize that the underlying issue often stems from the inherent limitations of computers themselves. The complexity of modern software and the unpredictable interactions between algorithms and real-world data can lead to unforeseen outcomes, even with the most meticulous design and testing. Therefore, attributing full accountability solely to human actors oversimplifies the intricate interplay between human agency and computational processes.

  In conclusion, Willison maintains that the pursuit of holding computers accountable is a misguided endeavor rooted in a misunderstanding of the nature of computation. Accountability, a concept inextricably linked to consciousness and moral agency, is simply beyond the reach of current and foreseeable computer systems. While we can and should strive to create safer and more reliable AI systems, we must abandon the illusion that these systems can be held truly responsible for their actions in the same way as humans. Instead, we must focus on developing robust oversight mechanisms and refining our understanding of the complex interplay between humans and the technologies they create.

  • accountability
  • artificial intelligence
  • AI
  • responsibility
  • Ethics
  • Technology
  • computers
  • Law
  • legal
  • Software
  • algorithms
  • Automation
  • human oversight
  • culpability
  • blame
  • moral responsibility
  • agency

  Summary of Comments ( 195 )
  https://news.ycombinator.com/item?id=42923870

  Verbose tl;dr

  HN users largely agree with the premise that computers, lacking sentience and agency, cannot be held accountable. The discussion centers around the implications of this, particularly regarding the legal and ethical responsibilities of the humans behind AI systems. Several compelling comments highlight the need for clear lines of accountability for the creators, deployers, and users of AI, emphasizing that focusing on punishing the "computer" is a distraction. One user points out that inanimate objects like cars are already subject to regulations and their human operators held responsible for accidents. Others suggest the concept of "accountability" for AI needs rethinking, perhaps focusing on verifiable safety standards and rigorous testing, rather than retribution. The potential for individuals to hide behind AI as a scapegoat is also raised as a major concern.

  The Hacker News post "A computer can never be held accountable" sparks a discussion with a moderate number of comments exploring the nuances of the title's claim. Several commenters agree with the premise, emphasizing that accountability ultimately rests with the humans who design, program, deploy, and utilize computer systems. They argue that computers merely execute instructions, lacking the consciousness or intentionality necessary for true accountability.

  One compelling line of discussion revolves around the concept of legal personhood for corporations. Commenters draw parallels, suggesting that just as corporations—legal fictions—are held accountable, so too might AI systems eventually be treated as entities capable of bearing some form of legal responsibility, even in the absence of sentience. This doesn't equate to moral accountability, they acknowledge, but rather a pragmatic legal framework for addressing harm caused by AI.

  Another thread delves into the practical implications of assigning responsibility in complex AI-driven systems. Commenters highlight the difficulty of pinpointing blame when multiple actors and systems contribute to an outcome. They discuss the potential for "passing the buck," where developers blame the training data, users blame the software, and companies blame unforeseen circumstances. This raises the question of how to establish clear lines of responsibility and develop effective mechanisms for redress.

  Some commenters introduce the concept of "accountability through proxy," where humans responsible for an AI system's actions are held accountable on its behalf. This approach acknowledges the lack of direct accountability for the computer while still seeking to ensure that someone bears responsibility for the consequences of its actions.

  Finally, several comments touch upon the potential for future AI systems to possess a greater degree of autonomy and decision-making power. While acknowledging the current limitations, they contemplate the possibility that sufficiently advanced AI might eventually warrant a reassessment of the notion of accountability as it applies to machines. However, they generally agree that this is a complex and distant prospect, and the current focus should remain on establishing accountability frameworks within existing legal and ethical paradigms.