Stories with Tag executable

• Using uv as your shebang line

  permalink

  Posted: 2025-01-28 17:35:05

  Verbose tl;dr

  The blog post explores using #!/usr/bin/env uv as a shebang line to execute PHP scripts with the uv runner, offering a performance boost compared to traditional PHP execution methods like php-fpm. uv leverages libuv for asynchronous operations, making it particularly advantageous for I/O-bound tasks. The author demonstrates this by creating a simple "Hello, world!" script and showcasing the performance difference using wrk. The post concludes that while setting up uv might require some initial effort, the potential performance gains, especially in asynchronous contexts, make it a compelling alternative for running PHP scripts.

  This blog post by Anthony Ferrara explores the concept of using #!/usr/bin/env uv as the shebang line for PHP scripts, leveraging the uv binary provided by the ext-uv PHP extension. The primary motivation is to harness the asynchronous capabilities of libuv, the underlying library, to achieve non-blocking operations and potentially enhance performance in specific scenarios.

  The author begins by highlighting the traditional PHP execution model, which is synchronous and blocking. Each request is handled sequentially, waiting for operations like file I/O or network requests to complete before proceeding. This can lead to performance bottlenecks, especially in I/O-bound applications.

  Introducing the uv binary offers an alternative execution pathway. By using uv as the shebang, the PHP script effectively runs within the libuv event loop. This allows for asynchronous operations, enabling the script to continue processing other tasks while waiting for I/O operations to finish, instead of blocking the entire execution flow.

  The post then delves into the practicalities of using this approach. It explains that the uv binary intercepts the execution and initializes the libuv event loop. The PHP code, specifically designed for this asynchronous environment, interacts with the event loop through functions provided by the ext-uv extension. These functions allow registering callbacks and handling events in a non-blocking manner.

  The author provides a simple example demonstrating the use of uv for asynchronous file reading. The code snippet illustrates how to initiate a file read operation and register a callback function to be executed when the reading is complete. This callback then processes the read data. The crucial difference from traditional file reading is that the script does not halt while waiting for the file read to finish; instead, the event loop handles the asynchronous operation in the background.

  Furthermore, the post acknowledges that using uv as the shebang is not a universal solution for all PHP projects. It's specifically targeted at applications that can benefit from asynchronous operations, primarily I/O-bound tasks. For CPU-bound workloads, the advantages might be less pronounced.

  Finally, the author touches upon the potential drawbacks and considerations of this approach, mentioning the need for careful coding practices to handle asynchronous logic and the importance of understanding the event loop model. While the uv shebang offers a compelling pathway to leverage asynchronous capabilities in PHP, it requires a shift in development paradigms and a thorough understanding of the underlying mechanisms.

  • shebang
  • uv
  • php
  • executable
  • scripts
  • Command Line
  • web server
  • performance
  • unix
  • Linux

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

  Verbose tl;dr

  Hacker News users discussed the practicality and security implications of using uv as a shebang line. Some questioned the benefit given the small size savings compared to a full path, while others highlighted potential portability issues and the risk of uv not being installed on target systems. A compelling argument against this practice centered on security, with commenters noting the danger of path manipulation if uv isn't found and the shell falls back to searching the current directory. One commenter suggested using env to locate usr/bin/env reliably, proposing #!/usr/bin/env uv as a safer, though slightly larger, alternative. The overall sentiment leaned towards avoiding this shortcut due to the potential downsides outweighing the minimal space saved.

  The Hacker News post "Using uv as your shebang line" (https://news.ycombinator.com/item?id=42855258) has a modest number of comments discussing the practicality and implications of using the uv command-line utility, provided by the libuv library, as a shebang interpreter for executing JavaScript files directly.

  Several commenters express skepticism and raise concerns about portability. One commenter points out that relying on uv as a shebang interpreter tightly couples the script to the presence and specific version of libuv on the target system, making it less portable than using a more standard shebang like #!/usr/bin/env node. They argue that this approach introduces an unnecessary dependency and restricts the script's usability across different environments.

  Another commenter echoes this sentiment, suggesting that while it might be convenient for personal scripts or very controlled environments, using uv as a shebang would not be suitable for distributing scripts intended for wider use. They highlight that assuming the availability of uv is not a reasonable expectation in most general-purpose computing environments.

  A different line of discussion emerges regarding the performance implications. One commenter questions whether using uv directly offers any significant performance advantage over using node. They suggest that any perceived performance gains might be negligible and not worth the trade-off in portability.

  One user raises a point about the potential for confusion when using uv as a shebang, as it might not be immediately clear to others what interpreter is being invoked. They suggest that clarity and maintainability are often more valuable than marginal performance improvements, especially in collaborative projects.

  Another commenter offers a more nuanced perspective, acknowledging the portability concerns but also suggesting a potential use case for this approach. They propose that using uv as a shebang could be beneficial in situations where a project already heavily relies on libuv and the scripts are intended for internal use within that specific environment. In such cases, the dependency is already present, and the streamlined execution provided by the uv shebang might offer some advantages.

  Finally, one commenter raises the possibility of using a small shell script as an intermediary to locate and execute the correct interpreter, providing a more robust and portable solution. This approach would address the portability concerns while still allowing for the use of uv when available. They offer a concrete example of such a script.

  Overall, the comments generally lean towards caution regarding the widespread use of uv as a shebang interpreter due to portability concerns. However, they also acknowledge niche scenarios where this approach might offer some benefits, primarily in tightly controlled environments where the libuv dependency is already guaranteed.

• Wild – A Fast Linker for Linux

  permalink

  Posted: 2025-01-24 16:25:53

  Verbose tl;dr

  Wild is a new, fast linker for Linux designed for significantly faster linking than traditional linkers like ld. It leverages parallelization and a novel approach to symbol resolution, claiming to be up to 4x faster for large projects like Firefox and Chromium. Wild aims to be drop-in compatible with existing workflows, requiring no changes to source code or build systems. It also offers advanced features like incremental linking and link-time optimization, further enhancing development speed. While still under development, Wild shows promise as a powerful tool to accelerate the build process for complex C++ projects.

  David Lattimore has introduced "wild," a new linker designed specifically for Linux systems, aiming to significantly accelerate the linking process. Lattimore posits that linking is often a performance bottleneck in software development, especially noticeable in large projects or during iterative development cycles. Wild aims to address this by employing several optimization strategies.

  The core principle behind wild's speed is its extensive use of parallelization. The linker leverages multi-core processors to perform linking operations concurrently, dividing the workload across available cores to minimize overall linking time. This parallel approach is applied to various stages of the linking process, enhancing efficiency. Furthermore, wild utilizes memory mapping techniques to efficiently handle large files and reduce I/O overhead, further contributing to its speed.

  Beyond parallelization and memory mapping, wild incorporates additional optimizations. It employs a carefully designed internal data structure to facilitate fast lookups and operations, minimizing processing time. The linker also implements incremental linking, allowing it to reuse previously linked outputs, dramatically reducing redundant work when only minor changes are made to the codebase. This incremental approach is particularly beneficial in iterative development workflows, where small code modifications are frequently linked. Lattimore claims substantial performance improvements compared to traditional linkers, showcasing wild's potential to streamline the development process.

  While presented as a fast linker, wild is also designed with compatibility in mind. It aims to support a wide range of object file formats, ensuring its usability with existing projects and libraries. This broad compatibility makes it a potential drop-in replacement for slower linkers, simplifying adoption for developers.

  The project is open-source, hosted on GitHub, encouraging community involvement and contributions. While the current focus is on Linux, future development might explore expanding support to other operating systems. Lattimore's work represents a promising advance in linker technology, potentially offering substantial benefits for developers working on Linux by reducing build times and enhancing productivity.

  • Linux
  • linker
  • performance
  • elf
  • executable
  • linking
  • development
  • tools
  • Open Source
  • Software
  • wild
  • fast
  • build
  • build tools
  • Systems Programming

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

  Verbose tl;dr

  HN commenters generally praised Wild's speed and innovative approach to linking. Several expressed excitement about its potential to significantly improve build times, particularly for large C++ projects. Some questioned its compatibility and maturity, noting it's still early in development. A few users shared their experiences testing Wild, reporting positive results but also mentioning some limitations and areas for improvement, like debugging support and handling of complex linking scenarios. There was also discussion about the technical details behind Wild's performance gains, including its use of parallelization and caching. A few commenters drew comparisons to other linkers like mold and lld, discussing their relative strengths and weaknesses.

  The Hacker News post titled "Wild – A Fast Linker for Linux" (https://news.ycombinator.com/item?id=42814683) has generated a fair amount of discussion, with a focus on the performance benefits and potential of the Wild linker.

  Several commenters express excitement about the speed improvements Wild offers compared to traditional linkers like ld. Some share anecdotal evidence or express anticipation of trying it out in their own projects to see the real-world impact on build times. The potential for significantly reducing link times, particularly in large projects, is a recurring theme and a key driver of interest.

  One commenter notes the importance of fast linking, particularly in iterative development cycles where frequent recompilation and linking can be a significant bottleneck. They highlight how improvements in this area can lead to more productive development.

  Another commenter points out the project's utilization of Mold's design. They mention this as a positive aspect, suggesting the project benefits from a proven architecture and can further build upon it.

  There's a discussion around specific technical details. One comment thread delves into the implementation details of parsing and handling debug information, which appears to be a contributing factor to Wild's speed. The decision to avoid using regular expressions for this task is highlighted as a potentially smart performance optimization.

  There are also comments acknowledging the challenges of linker development. One commenter mentions that writing a linker is complex, implying that creating a fast and robust one like Wild is a significant achievement.

  The overall sentiment is positive and optimistic. Many commenters see Wild as a promising development in the linking space, with the potential to significantly improve build times for Linux developers. There's a clear interest in its future development and adoption.

• Bunster: Compile bash scripts to self contained executables

  permalink

  Posted: 2025-01-23 15:17:26

  Verbose tl;dr

  Bunster is a tool that compiles Bash scripts into standalone, statically-linked executables. This allows for easy distribution and execution of Bash scripts without requiring a separate Bash installation on the target system. It achieves this by embedding a minimal Bash interpreter and necessary dependencies within the generated executable. This makes scripts more portable and user-friendly, especially for scenarios where installing dependencies or ensuring a specific Bash version is impractical.

  Bunster is a new tool designed to transform Bash scripts into standalone, executable binaries. This addresses the common challenge of dependency management when sharing or deploying Bash scripts, particularly in environments where specific versions of utilities might not be present or consistent. It works by embedding the required Bash interpreter and any necessary external utilities directly into the resulting executable. This eliminates the need for recipients to have a specific Bash version or other dependencies installed on their system. The execution process involves extracting the embedded components into a temporary directory, setting up the necessary execution environment, running the original script within this contained environment, and finally cleaning up the temporary files, leaving no trace.

  Bunster supports packaging most common Bash commands and utilities within the binary, along with supporting files. It leverages SquashFS, a highly compressed read-only filesystem, to efficiently package the required components, resulting in relatively compact executables. This process significantly simplifies distribution and execution, making it particularly useful for sharing scripts, automating tasks on diverse systems, and ensuring consistent behavior across different environments. The resulting binary operates as a self-contained unit, independent of the target system's configuration, offering improved portability and reliability. While primarily focused on Bash scripts, the project's underlying architecture could potentially be extended to support other scripting languages in the future. This makes Bunster a promising tool for streamlining the deployment and execution of scripts in various contexts.

  • bash
  • scripting
  • compiler
  • executable
  • self-contained
  • binary
  • shell
  • command-line
  • cli
  • developer tools
  • DevOps
  • Automation
  • portability
  • packaging
  • distribution
  • Linux
  • unix
  • bunster

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

  Verbose tl;dr

  Hacker News users discussed Bunster's novel approach to compiling Bash scripts, expressing interest in its potential while also raising concerns. Several questioned the practical benefits over existing solutions like shc or containers, particularly regarding dependency management and debugging complexity. Some highlighted the inherent limitations of Bash as a scripting language compared to more robust alternatives for complex applications. Others appreciated the project's ingenuity and suggested potential use cases like simplifying distribution of simple scripts or bypassing system-level restrictions on scripting. The discussion also touched upon the performance implications of this compilation method and the challenges of handling Bash's dynamic nature. A few commenters expressed curiosity about the inner workings of the compilation process and its handling of external commands.

  The Hacker News post titled "Bunster: Compile bash scripts to self contained executables" (https://news.ycombinator.com/item?id=42804835) has generated a moderate amount of discussion, with several commenters expressing interest in the project and offering their perspectives.

  A recurring theme is the comparison of Bunster to existing tools like ShellCheck and shc. One commenter highlights that while ShellCheck focuses on static analysis to identify potential issues within Bash scripts, Bunster aims to convert them into standalone executables. This distinction is crucial, as it positions Bunster as a tool for deployment rather than just debugging. Another commenter mentions shc, an older tool with a similar purpose, and raises questions about Bunster's advantages over it, particularly regarding security and the potential for reverse engineering. This prompts a discussion about the inherent limitations of trying to completely obfuscate shell scripts.

  Several commenters express concerns about the practical applications of Bunster. One questions the benefit of creating self-contained executables for Bash scripts, given that Bash is often readily available on target systems. This sparks a discussion about potential use cases, including embedded systems, isolated environments where dependencies might be an issue, and situations where guaranteeing a specific Bash version is necessary. Another commenter emphasizes the importance of containerization technologies like Docker as a more robust solution for dependency management and deployment.

  Security is another significant point of discussion. Commenters point out the potential risks associated with executing compiled Bash scripts, especially if they originate from untrusted sources. The ease of decompilation is mentioned as a key concern, leading to a discussion about the trade-offs between ease of use and security.

  Finally, some commenters express general enthusiasm for the project and offer suggestions for improvement. One suggests the potential for cross-compilation, allowing users to create executables for different target architectures. Another proposes integration with package managers for easier distribution.

  While the discussion doesn't reach a definitive consensus on Bunster's value, it provides a multifaceted view of its potential benefits and drawbacks, considering various aspects like security, practicality, and comparison to existing solutions. The comments highlight both the excitement surrounding new tools in the DevOps space and the critical thinking necessary to evaluate their true usefulness.