<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Hacker News: metasim</title><link>https://news.ycombinator.com/user?id=metasim</link><description>Hacker News RSS</description><docs>https://hnrss.org/</docs><generator>hnrss v2.1.1</generator><lastBuildDate>Fri, 15 May 2026 16:53:31 +0000</lastBuildDate><atom:link href="https://hnrss.org/user?id=metasim" rel="self" type="application/rss+xml"></atom:link><item><title><![CDATA[New comment by metasim in "Bun's experimental Rust rewrite hits 99.8% test compatibility on Linux x64 glibc"]]></title><description><![CDATA[
<p>In my experience with Claude Code, it writes most of the code, including tests, without invoking the compiler until the very end (almost like a spelling checker). Rarely are there any compilation problems, and when there are, it’s often a token issue like a missing brace. I hypothesize this is possible because of the robust invariants of the language itself, and its strong types, such that the LLM can encode deeper meaning in fewer tokens.<p>Also remember, `cargo check` is quite fast, and wholly sufficient for confirming correctness.</p>
]]></description><pubDate>Tue, 12 May 2026 12:18:33 +0000</pubDate><link>https://news.ycombinator.com/item?id=48107193</link><dc:creator>metasim</dc:creator><comments>https://news.ycombinator.com/item?id=48107193</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=48107193</guid></item><item><title><![CDATA[New comment by metasim in "The future of software engineering is SRE"]]></title><description><![CDATA[
<p>Thank you!</p>
]]></description><pubDate>Mon, 26 Jan 2026 13:51:09 +0000</pubDate><link>https://news.ycombinator.com/item?id=46765614</link><dc:creator>metasim</dc:creator><comments>https://news.ycombinator.com/item?id=46765614</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=46765614</guid></item><item><title><![CDATA[New comment by metasim in "The future of software engineering is SRE"]]></title><description><![CDATA[
<p>What’s an “SRE”?</p>
]]></description><pubDate>Mon, 26 Jan 2026 13:03:01 +0000</pubDate><link>https://news.ycombinator.com/item?id=46765137</link><dc:creator>metasim</dc:creator><comments>https://news.ycombinator.com/item?id=46765137</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=46765137</guid></item><item><title><![CDATA[New comment by metasim in "I've always wanted to be an open-source maintainer- now I regret it"]]></title><description><![CDATA[
<p>Who says he has to maintain it? It’s open source… 100% free for anyone else to start maintaining it.</p>
]]></description><pubDate>Fri, 29 Aug 2025 02:24:24 +0000</pubDate><link>https://news.ycombinator.com/item?id=45059372</link><dc:creator>metasim</dc:creator><comments>https://news.ycombinator.com/item?id=45059372</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=45059372</guid></item><item><title><![CDATA[New comment by metasim in "Big Ideas from 8 Programming Languages"]]></title><description><![CDATA[
<p>Borrow checker in Rust? Implicits in Scala?</p>
]]></description><pubDate>Sat, 10 Sep 2022 19:00:29 +0000</pubDate><link>https://news.ycombinator.com/item?id=32793569</link><dc:creator>metasim</dc:creator><comments>https://news.ycombinator.com/item?id=32793569</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=32793569</guid></item><item><title><![CDATA[New comment by metasim in "“Mostly functional” programming does not work"]]></title><description><![CDATA[
<p>It's worth noting that `Option(null)` is `None`. And while it's possible for any reference to be assigned `null`, it rarely happens in Scala code as a) it's well known to be bad form, and b) the IDE's can be configured to yell at you about it. Practically speaking (from the middle), it's not a problem.</p>
]]></description><pubDate>Sun, 27 Apr 2014 15:24:21 +0000</pubDate><link>https://news.ycombinator.com/item?id=7655415</link><dc:creator>metasim</dc:creator><comments>https://news.ycombinator.com/item?id=7655415</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=7655415</guid></item><item><title><![CDATA[New comment by metasim in "“Mostly functional” programming does not work"]]></title><description><![CDATA[
<p>I can't substantiate this, but my sense is that the generation of general-purpose, non-academic programming languages C++ lowered the barrier to writing software in the industrial context (think VB.Net, etc.). This can be seen as a good thing in these business contexts, but for those who are driven to be deeper and more concise in their problem solving, and are interested in solving more challenging problems, are only starting to realize that we've not been expecting enough out of our languages and compilers. Furthermore, the last two decades of software tool development have gained "lowest common denominator" accessibility at the cost of "dumbing down" the ways we generalists think about and solve problems. The first thing that picking up Scala did for me was realize I was expecting <i>way</i> too little from the compilers I use. Why should I be figuring out what the damn type of a value should be (while not throwing out types all together)!?!<p>Since Meijer is as an employee of Microsoft I'd extrapolate to say he's heavily influenced in his experience of the "average programmer" by the primary clients of his company.</p>
]]></description><pubDate>Sun, 27 Apr 2014 14:28:04 +0000</pubDate><link>https://news.ycombinator.com/item?id=7655179</link><dc:creator>metasim</dc:creator><comments>https://news.ycombinator.com/item?id=7655179</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=7655179</guid></item><item><title><![CDATA[New comment by metasim in "“Mostly functional” programming does not work"]]></title><description><![CDATA[
<p>If you strongly restrict mutability (significantly facilitated in Scala with case classes), then OO and FP dovetail quite elegantly. The Kiama language processing library is a fantastic example of getting the best of both (there are many others):<p><a href="http://code.google.com/p/kiama/wiki/Dataflow" rel="nofollow">http://code.google.com/p/kiama/wiki/Dataflow</a><p>That said, one of Scala most compelling (business) features--great Java interop--is also it's greatest liability. While I appreciate the great interop, Java's lack of state mutation controls in the language and JVM instruction set interfere greatly with the FP/OO impedance matching, generating misconceptions about the viability of hybrid FP/OO approaches.<p>From 1994 to 1996 I went from being a 80%/20% C++/Python developer to 90%/10% Java/C++ developer. My productivity went through the roof, but the lack of something akin to C++'s `const` references and `const` methods were a glaring mistake, one that remains to this day a shadow mandating contorted defensive programming techniques. Adding `final` almost made it worse, as it's nuanced and overloaded, and ultimately doesn't do what less-experienced developers think it does. Because of that one serious flaw, was I ready to go back to C++? Of course not, because I was able to render my ideas into working software at a faster pace--an extremely important factor--but I had move forward being ever aware of the language weaknesses and how to effectively ameliorate them.<p>Over the last year I've gone from developing in Java 90% of the time to Scala 75% of the time. In this transition I have seen a similar jump in my productivity (almost, but not quite as big as C++ to Java, and after a longer learning curve). However, have approached it with the same multi-dimensional awareness of one's paradigmatic assumptions and how they play with and against the language facilities.<p>For me, Scala was my gateway into the world of FP thinking, which radically changed the way I think about software problems. Scala has also had a profound impact in developing a deeper appreciation of the power of a more formal type system. Both of those paradigm-shifting features of the language have allowed me to be more creative, expressive and concise in my software writing, with bountiful rewards on multiple axes.<p>However, I've also stumbled along the way--becoming enamored of features I didn't fully understand, being too expressive when simplicity would suffice, being FP for FP sake, etc.--but I sure am glad I had those opportunities to stumble, and do so in a "fail-fast" manner. The process has been invaluable, and I'm a <i>much</i> better programmer today for it. I never entered the process assuming the FP/OO/CT academic visionaries or the Smalltalk/C++/Scala/Haskell/ML/OCaml language inventors offered me any "promises". They gave to the world constructs for others to think about and solve software problems, take it or leave it, to live and die in the ecosystem of ideas. I know it is <i>my</i> responsibility as a professional programmer to understand the pros and cons of those constructs and tools, weigh them against my goals, experience and intelligence, and go into a relationship with these tools knowing, <i>I'm</i> ultimately the one responsible for the final product, and need to know what I'm doing.<p>All this is to say, I don't think sweeping generalizations nor pointed nick-picks help in assisting people select the best language and paradigm for their problem at hand, understanding the strengths <i>and</i> weaknesses, and how to manage those trade-offs. It isn't, and doesn't have to be a "one-size-fits-all world" (as someone else here already referenced the great Stroustrup﻿ quote: "There are only two kinds of languages: the ones people complain about and the ones nobody uses."﻿). And at the end of the day, the ultimate responsibility rests in the hands of the individual professional developer. In my developing awareness of the FP viewpoint I have most appreciated and benefited concretely from those pragmatic viewpoints in the middle. It is from the middle that one can more clearly see <i>both</i> perspectives, and from that develop a third, more holistic and encompassing viewpoint that harnesses the power of both.</p>
]]></description><pubDate>Sun, 27 Apr 2014 14:13:13 +0000</pubDate><link>https://news.ycombinator.com/item?id=7655121</link><dc:creator>metasim</dc:creator><comments>https://news.ycombinator.com/item?id=7655121</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=7655121</guid></item><item><title><![CDATA[New comment by metasim in "“Mostly functional” programming does not work"]]></title><description><![CDATA[
<p>Is your argument that deep experience in Clojure is sufficient in determining FP/OO hybridization isn't a good idea or can't be done well? I didn't think that was in the sphere of Clojure's goals.</p>
]]></description><pubDate>Sun, 27 Apr 2014 14:05:53 +0000</pubDate><link>https://news.ycombinator.com/item?id=7655096</link><dc:creator>metasim</dc:creator><comments>https://news.ycombinator.com/item?id=7655096</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=7655096</guid></item></channel></rss>