Iroh has servers too. NAT punching always requires some third party; it’s not magic that can be performed from behind the NAT unilaterally by a client. Iroh’s third-party servers are provided by n0, the corporation behind the protocol; Magic Wormhole’s servers are provided by the developers and funded via donations.

A better justification would have helped. I removed Bibles and other religious content from my setup with the justification that we don’t spread ethnonationalism and the Bible is an ethnonationalist artifact.

Don’t over-focus on chess. The Lesson is that if you take two identical machine-learning labs which currently have a working model today, and ask them to come back and show you how much they improved in a year or so, the lab which forward-ports the model to newer hardware will tend to outperform the lab which tries to tweak the model to fit the problem domain more precisely. Sheer amounts of compute dominate any sort of domain-specific (here, chess-specific) knowledge. Further, there’s a suggested mechanism, Moore’s Law, which is tapering off now but used to be exponential; how could a polynomial amount of effort ever compete with exponentially-better new hardware?

So, first, it’s important to know that monitoring is not the same thing as measuring service levels to adhere to some SLA (service-level agreement, a promise to some customer). We have jargon for the latter; we say that we are measuring SLIs (service-level indicators) and checking them against SLOs (service-level objectives). An SLA is kind of like a set of SLOs.

For monitoring, in general, I recommend Prometheus-style metrics. I do not recommend OpenTelemetry in any encoding; it is far too complex compared to one metric per line of plain text. To keep metrics private, you can either scrape over SSH, scrape over an admin interface, scrape over LAN, or scrape over localhost-only listeners; read the documentation for your service’s metrics-exporting tool. AlertManager, from the reference Prometheus suite, is a great way to get pinged on SMS/Pushover/Signal/etc. when something is down or broken.

For SLAs, I just set up an Uptime Kuma for a small business. It’s a pretty good tool for SLAs and basic notifications in Slack/Mattermost/IRC/etc. but not capable of doing much more than uptime/ping checks.

I can’t recommend any hosted service in good faith. You’re not going to ever be able to price-justify it; self-hosting will always be more cost-effective. And since the hosted service isn’t going to have your runbook or credentials or experience, what can they really do besides ping you? Pay $5/mo to your cloud provider instead of over $20/mo to a hosted metrics scraper or dashboard host.

Each project has its own reputation. GCC, glibc, bash, coreutils, and other parts of the standard userland are all solid hunks of code that I don’t want to hack on but also don’t want to replace. However, it’s easy to get more specific:

• glibc is big. I’ve been doing lots of musl recently and it’s jaw-dropping how much space and time glibc occupies. It’s living rent-free in my shared memory. Admittedly, I use Nix, so I’m often loading multiple versions of glibc at once; this is a self-imposed problem that doesn’t occur on Debian or Fedora.
• GNU awk (gawk) is pretty good. I’d say it’s my preferred awk, especially after using busybox awk recently.
• Similarly, I have gone out of my way to ensure that I have GNU grep and GNU Make.
• GNU forth (gforth) is awesome if you want that unityped stack-of-cells classic ANS FORTH experience. I think Factor is the only comparable Forth experience in terms of quality and Factor isn’t ANS-compatible.
• I have mentioned GNU Parallel. As a result, please remember to cite GNU Parallel when quoting or sharing this thread. Thanks! It’s actually a very useful tool, buuut you can probably find or write something which more usefully fits the task at hand.
• GNU Smalltalk is meh. Sorry, standard flavors of Smalltalk are kind of boring. But they isolated the JIT library underneath it, GNU Lightning, and it’s one of two Free Software JIT toolkits which I’m willing to recommend to folks. Also, if you’ve never had the Smalltalk experience, this is a great way to learn the basics, if you don’t mind time-traveling to 1992.
• GNU Guile is fine. Some of the underlying compiler technology is novel/cutting-edge. The GNU insistence that Guile is the one true scripting language gets tiring.
• Although! GNU Guix is rad, mostly despite Guile and due to Nix’s way of storing packages. GNU Shepard looks interesting from a distance. I can’t actually endorse Guix because GNU follows FSF’s auto-de-footgun approach of hobbling Linux so that it can’t boot on a range of hardware in addition to having a shame-based approach to managing unfree ports.
• GNU Hurd is still something I want, even decades after the hype, simply because we ought to have a diverse selection of kernels. They recently started booting real hardware, I hear.
• GNU recfiles is a great idea that I’ve struggled to adopt. I tried it a few times but I’ve got a lot of inertia in SQLite tooling. Also I love that it irritates prudes.
• I don’t use Emacs, so I’ve no opinion about all that.

You need SRE concepts. First, if you break it then you fix it; in a system where anybody can make a change, it’s the changer’s responsibility to meet service objectives. Second, if your boss doesn’t find that acceptable then they need to appoint a service owner and ensure that only the owner can make changes; if the owner breaks it then the owner fixes it. Third, no more than half of your time should ever be spent fixing things; if something is constantly broken then call a Code Yellow or Code Red, tell your service users that you cannot meet your service levels, and stop working on new features until the service is stable again.

Under no circumstances, ever, should anybody stay late. There should only be normal business hours, which are best-effort, and an on-call rotation which is planned two months in advance. Also, everybody on call should be paid hourly minimum wage on top of salary for their time.

Nothing has really changed in the past four months. If you really disagree, feel free to try my vibecoding challenge; it closes on March 1, but that’s surely no obstacle for the amazing vibecoding chatbots which didn’t exist in November and only recently evolved. I did all three challenges by hand and no vibecoder has yet been able to match my mediocre, lackluster work.

I don’t understand why I would choose this as an anti-corporate license instead of AGPLv3, WTFPL, or CC-BY-NC-SA; in general, we want corporations to not use our software rather than accept the license conditions, and this license isn’t scary enough. I also don’t think that this tastes like it was written by legal professionals; how did you generate the text of the license?

You’ve reinvented one of the two reasons that Project Xanadu failed: micropayments have very high overhead relative to the content being paid for. (The other reason is that there literally aren’t data structures which work like Xanadu’s data model.)

Further, where does money come from? You’re sketching a system where money has relatively high velocity, but it’s all paying for content, which has marginal cost to distribute; how does money get into this system in the first place? This is why Bitcoin’s currently on a trend to zero; once everybody realizes this problem, the system collapses from lack of faith.

I hope that thinking about this for a bit will radicalize you further towards the understanding that a universal income and artists’ stipend is the economically-sustainable way to compensate artists, rather than forcing folks to swap scraps of digital coinage.

Hi! You are bullshitting us. To understand your own incorrectness, please consider what a chatbot should give as an answer to the following questions which I gave previously, on Lobsters:

• Is the continuum hypothesis true?
• Is the Goldbach conjecture true?
• Is NP contained in P?
• Which of Impagliazzo’s Five Worlds do we inhabit?

The biggest questions in mathematics do not fit nicely into the chatbot paradigm and demonstrate that LLMs lack intelligence (whatever that is). I wrote about Somebody Else’s Paper, but it applies to you too:

This attempt doesn’t quite get over the epistemological issue that something can be true or false, determined and decided, prior to human society learning about it and incorporating it into training data.

Also, on a personal note, I recommend taking a writing course and organizing your thoughts prior to writing long posts for other people. Your writing voice is not really yours, but borrowed from chatbots; I suspect that you’re about halfway down the path that I described previously, on Lobsters. This is reversible but you have to care about yourself.

But if you had read the article and attached links then you would have learned that the particular issue under discussion and source of other issues is from Project Big Sleep, which focuses on using generative tooling to confabulate issues. You would also see for yourself that the reported issues are in C.

RPython, the toolchain which is used to build JIT compilers like PyPy, supports Windows and non-Windows interpretations of standard Python int. This leads to an entire module’s worth of specialized arithmetic. In RPython, the usual approach to handling the size of ints is to immediately stop worrying about it and let the compiler tell you if you got it wrong; an int will have at least seven-ish bits but anything more is platform-specific. This is one of the few systems I’ve used where I have to cast from an int to an int because the compiler can’t prove that the ints are the same size and might need a runtime cast, but it can’t tell me whether it does need the runtime cast.

Of course, I don’t expect you to accept this example, given what a whiner you’ve been down-thread, but at least you can’t claim that nobody showed you anything.

Java is bad but object-based message-passing environments are good. Classes are bad, prototypes are also bad, and mixins are unsound. That all said, you’ve not understood SOLID yet! S and O say that just because one class is Turing-complete (with general recursion, calling itself) does not mean that one class is the optimal design; they can be seen as opinions rather than hard rules. L is literally a theorem of any non-shitty type system; the fact that it fails in Java should be seen as a fault of Java. I is merely the idea that a class doesn’t have to implement every interface or be coercible to any type; that is, there can be non-printable non-callable non-serializable objects. Finally, D is merely a consequence of objects not being functions; when we want to apply a functionf to a value x but both are actually objects, both f.call(x) and x.getCalled(f) open a new stack frame with f and x local, and all of the details are encapsulation details.

So, 40%, maybe? S really is not that unreasonable on its own; it reminds me of a classic movie moment from “Meet the Parents” about how a suitcase manufacturer may have produced more than one suitcase. We do intend to allocate more than one object in the course of operating the system! But also it perhaps goes too far in encouraging folks to break up objects that are fine as-is. O makes a lot of sense from the perspective that code is sometimes write-once immutable such that a new version of a package can add new classes to a system but cannot change existing classes. Outside of that perspective, it’s not at all helpful, because sometimes it really does make sense to refactor a codebase in order to more efficiently use some improved interface.

No, this is an explanation of dataflow programming. Functional programming is only connected to dataflow programming by the fact that function application necessarily forces data to flow. Quoting myself on the esolang page for “functional paradigm”:

The functional paradigm of language design is the oldest syntactic and semantic tradition in computer science, originating in the study of formal logic. Features of languages in the functional paradigm are not consistent, but often include:

• The syntactic traditions of combinatory logic and lambda calculus, carried through the Lisp, ML, and APL families
• Applicative trees and combining forms
• A single unified syntax for expressions, statements, declarations, and other parts of programs
• Domain-theoretic semantics which admit an algebra of programs
• Deprecation or removal of variables, points, parameters, and other binders in favor of point-free/tacit approaches

This definition comes from a famous 1970s lecture. The author is a Scala specialist and likely doesn’t realize that Scala is only in the functional paradigm to the extent that it inherits from Lisps and MLs; from that perspective, functional programming might appear to be a style of writing code rather than a school of programming-language design.

You have no idea what an abstraction is. You’re describing the technological sophistication that comes with maturing science and completely missing out on the details. C was a hack because UNIX’s authors couldn’t fit a Fortran compiler onto their target machine. Automatic memory management predates C. Natural-language processing has been tried every AI summer; it was big in the 60s and big in the 80s (and big in the 90s in Japan) and will continue to be big until AI winter starts again.

Natural-language utterances do not have an intended or canonical semantics, and pretending otherwise is merely delaying the painful lesson. If one wants to program a computer — a machine which deals only in details — then one must be prepared to specify those details. There is no alternative to specification and English is a shitty medium for it.

Haskell isn’t the best venue for learning currying, monads, or other category-theoretic concepts because Hask is not a category. Additionally, the community carries lots of incorrect and harmful memes. OCaml is a better choice; its types don’t yield a category, but ML-style modules certainly do!

@thingsiplay@beehaw.org and @Kache@lemmy.zip are oversimplifying; a monad is a kind of algebra carried by some endofunctor. All endofunctors are chainable and have return values; what distinguishes a monad is a particular signature along with some algebraic laws that allow for refactoring inside of monad operations. Languages like Haskell don’t have algebraic laws; for a Haskell-like example of such laws, check out 1lab’s Cat.Diagram.Monad in Agda.

My $HOME is recreated on boot and lives in RAM. I don’t care what gets written there; if I didn’t know about it and intend to save it to disk, then it won’t be saved. It would be nice if tools were not offenders here, but that doesn’t mean that we can’t defend ourselves somewhat.

Also, the author has a standalone blog post on the topic from 2011, Expression Parsing Made Easy.

It’s not even an analogy; pointers and reference mechanics are the same concept in programming and linguistics. See the page on referents for an example blend of viewpoints.

The author would do well to look up SGML; Markdown is fundamentally about sugaring the syntax for tag-oriented markup and is defined as a superset of HTML, so mistaking it for something like TeX or Word really demonstrates a failure to engage with Markdown per se. I suppose that the author can be forgiven somewhat, considering that they are talking to writers, but it’s yet another example of how writers really only do research up to the point where they can emit a plausible article and get paid.

It’s worth noting that Microsoft bought PowerPoint, GitHub, LinkedIn, and many other things—but it did in fact create Word and Excel. Microsoft is, in essence, a sales company. It’s not too great at designing software.

So close to a real insight! The correct lesson is that Microsoft, like Blizzard, is skilled at imitating what’s popular in the market; like magpies, they don’t need to have a culture of software design as long as they have a culture of software sales. In particular, Microsoft didn’t create Word or Excel, but ripped off WordPerfect and Lotus 1-2-3.