The author reflects positively on their experience using Lua for a 60k-line project. They praise Lua's speed, small size, and ease of embedding. While acknowledging the limited ecosystem and tooling compared to larger languages, they found the simplicity and resulting stability to be major advantages. Minor frustrations included the standard library's limitations, especially regarding string manipulation, and the lack of static typing. Overall, Lua proved remarkably effective for their needs, offering a productive and efficient development experience despite some drawbacks. They highlight LuaJIT's exceptional performance and recommend it for CPU-bound tasks.
Feldera drastically reduced Rust compile times for a project with over a thousand crates from 30 minutes to 2 minutes by strategically leveraging sccache. They initially tried using a shared volume for the sccache directory but encountered performance issues. The solution involved setting up a dedicated, high-performance sccache server, accessed by developers via SSH, which dramatically improved cache hit rates and reduced compilation times. Additionally, they implemented careful dependency management, reducing unnecessary rebuilds by pinning specific crate versions in a lockfile and leveraging workspaces to manage the many inter-related crates effectively.
HN commenters generally praise the author's work in reducing Rust compile times, while also acknowledging that long compile times remain a significant issue for the language. Several point out that the demonstrated improvement is largely due to addressing a specific, unusual dependency issue (duplicated crates) rather than a fundamental compiler speedup. Some express hope that the author's insights, particularly around dependency management, will contribute to future Rust development. Others suggest additional strategies for improving compile times, such as using sccache and focusing on reducing dependencies in the first place. A few commenters mention the trade-off between compile time and runtime performance, suggesting that Rust's speed often justifies the longer compilation.
Plandex v2 is an open-source AI coding agent designed for complex, large-scale projects. It leverages large language models (LLMs) to autonomously plan and execute coding tasks, breaking them down into smaller, manageable sub-tasks. Plandex uses a hierarchical planning approach, refining plans iteratively and adapting to unexpected issues or changes in requirements. The system also features error detection and debugging capabilities, automatically retrying failed tasks and adjusting its approach based on previous attempts. This allows for more robust and reliable autonomous coding, particularly for projects exceeding the typical context window limitations of LLMs. Plandex v2 aims to be a flexible tool adaptable to various programming languages and project types.
Hacker News users discussed Plandex v2's potential and limitations. Some expressed excitement about its ability to manage large projects and integrate with different tools, while others questioned its practical application and scalability. Concerns were raised about the complexity of prompts, the potential for hallucination, and the lack of clear examples demonstrating its capabilities on truly large projects. Several commenters highlighted the need for more robust evaluation metrics beyond simple code generation. The closed-source nature of the underlying model and reliance on GPT-4 also drew skepticism. Overall, the reaction was a mix of cautious optimism and pragmatic doubt, with a desire to see more concrete evidence of Plandex's effectiveness on complex, real-world projects.
Summary of Comments ( 85 )
https://news.ycombinator.com/item?id=43723088
Hacker News users generally agreed with the author's assessment of Lua, praising its speed, simplicity, and ease of integration. Several commenters highlighted their own positive experiences with Lua, particularly in game development and embedded systems. Some discussed the limitations of the standard library and the importance of choosing good third-party libraries. The lack of static typing was mentioned as a drawback, though some argued that good testing practices mitigate this issue. A few commenters also pointed out that 60k lines of code is not exceptionally large, providing context for the author's experience. The overall sentiment was positive towards Lua, with several users recommending it for specific use cases.
The Hacker News post discussing the blog post "What do I think about Lua after shipping a project with 60k lines of code?" has generated a moderate number of comments, many of which delve into the nuances of Lua, its strengths, and its weaknesses, especially concerning larger projects.
Several commenters discuss the challenges of maintaining a large Lua codebase. One commenter points out the importance of establishing robust conventions and leveraging tools for static analysis and linting early on, citing their own experience with a 200k-line Lua project. They emphasize the need for clear coding guidelines to prevent the code from becoming unwieldy, especially when multiple developers are involved. This resonates with another comment that suggests using Typed Lua to mitigate some of these issues.
Another prevalent theme is the discussion around Lua's lack of a robust standard library, with several commenters agreeing that this often leads to developers reinventing the wheel or relying on external libraries. This can lead to dependency management challenges and potential inconsistencies in the codebase. One user specifically mentions missing functionality for handling HTTP requests and JSON parsing as common examples where external dependencies become necessary.
A few comments praise Lua's speed and simplicity, recalling positive experiences using it for embedded systems and game development. One user specifically mentions the ease of embedding and the performance benefits it offers in these contexts.
The discussion also touches upon Lua's dynamic typing. While acknowledging that this can be convenient for smaller projects, some commenters express concerns about its suitability for larger codebases, where static typing can offer better error detection and maintainability. This ties back to the earlier discussion around Typed Lua and the desire for better tooling to improve code quality in large Lua projects.
Finally, a couple of comments compare Lua to other languages like Python and JavaScript, discussing their relative strengths and weaknesses in different scenarios. One commenter suggests that Python's richer ecosystem might make it a better choice for some projects, while another highlights Lua's speed advantage, particularly when embedded within a larger application.
Overall, the comments paint a picture of Lua as a powerful and performant language well-suited for specific niches like game scripting and embedded systems, but one whose lack of a robust standard library and static typing can present challenges when scaling to larger projects. The discussion highlights the importance of adopting rigorous coding practices and potentially leveraging tools like Typed Lua to mitigate these challenges.