diffxx

I'm ready for their follow up product.

The instantaneous fertility rate dipping below replacement level does not mean humanity dying out. It might mean that this particular civilization with this particular population level is. Infinite growth ad infinitum leads to an inevitable (and likely catastrophic) collapse. No one can say with certainty what the "correct" fertility rate is. That being said, if a society is set up as a pyramid scheme, it must have infinite growth to sustain itself so I won't argue that this way of life is likely dying.

Every EU nation should be thinking about how to fast track and incentivize American immigration.

Yes, though don't forget about the incompetence of adding the wrong person to the chat which goes part and parcel with the embarrassingly superficial/cynical discourse.

As a good friend who is the maintainer of a widely used oss tool likes to quip: the two hardest problems in computer science are naming things and making money in open source.

Here's my countervailing advice for keeping your phone safe: don't use a case or any protection at all. This trains you to take care of it.

I don't think correlation vs causation is the right question. Loneliness was clearly rampant long before chatgpt showed up. The question is whether chatbots are capable of reducing people's loneliness. To me it feels self-evident that in the long run, they are far more likely to increase feelings of loneliness than reduce them.

For me, the only thing that can reduce loneliness is conversation with another conscious entity. Many, if not most, people are barely conscious so this is hard to find in the physical world. But I don't believe llms are conscious, so for me they are a complete dead end for reducing loneliness whatever other virtues the may have.

Imagine putting your time and energy into something other than building a bigger imaginary pile for yourself.

It sometimes feels like there is a strange resistance to defining ad hoc sum types. If your language has good pattern matching capabilities and an expressive syntax for declaring data types, then this scales very well.

For example in a pseudolanguage:

    data FooResult = Number | Error
    def foo(n: Number): FooResult = ...
    foo(42) match {
      case n: Number => print(n + 1)
      case e: Error => // handle error case
    }

This gets you very far most of the time. If the tag overhead matters (which should largely only matter in a hot loop), then try to refactor so that the hot loop doesn't error out.

Granted in many languages the above cannot be expressed succinctly and is often avoided for this reason.

My definition is very different. It is about my ability to have control over my life in the areas that matter most to me. I value my time and personal development above material wealth (to a point). I don't need a giant house. I don't need regular fancy vacations or to own a car. I personally have been not working and living comfortably on much much less than 5mm in a high cost of living city for over five years. I do have to make many tradeoffs but I am happier than working a soul sucking job. It's not a path for everyone.

This does not feel like at all a good faith reading of the situation. Hardcore anti trans-activists on the right would like to make life so miserable for transpeople as to essentially eliminate them from public life entirely. That is the context in which these supposedly hysterical responses emerge. I say supposedly hysterical because transgender people of all ages do commit suicide at a higher rate than other groups. This should be considered a public health emergency but it largely isn't because transgender people are the most useful scapegoat of the day (even better than immigrants). Of course that doesn't mean that every child who questions their self identity should be given immediate medical intervention, but neither does it mean we should deny care for all.

I'm long on humans and suspect that many people will begin to prefer imperfection in reaction to the overproliferation of ai generated content.

I agree with the author that slow can be good and that taste and diligence can trump raw smarts.

I think what is often missed though is the opportunity cost of shipping bad products. Our industry lionizes fast delivery to juice short term earnings but this is very often at tremendous long term cost. When your revenue depends on shoddy products, you must devote an excess of resources to patching the holes that are slowly sinking your ship. The best people will tire of this and jump aboard the next vessel that offers better working conditions and/or higher compensation. But of course one never escapes the fundamental problems by job hopping.

To build something great, reliable and high value takes time. If it were easy, the market would be awash with cheap high quality products. It clearly isn't.

For things to improve, I believe that a small group of workers will likely need to join together and sacrifice short term earnings to build viable long term companies on a different set of ethics and values. I have personally made this sacrifice and am working on something I think is great and valuable that I could not possibly do within a typical company.

I have optimism that soon alternative approaches to building companies will emerge outside of the current VC funding model, which I believe has run its course. There are many, many software developers who are wealthy enough to sacrifice short term compensation to build more equitable companies with longer term vision and with a much higher ownership percentage that will pay off in the long run.

I know I'm being pedantic but zero dependencies is impossible. I'm all for minimizing dependencies though.

I unfortunately do not have a good reference of my own, but it strikes me that this list is missing resources for language design. This is the underdiscussed hard part of compiler writing. Good language design can also make compiler implementation much easier.

This is my experience too. I switched about five years ago and haven't looked back but many people still feel strongly that Google is better so like you I'm not sure if I'm doing it right or wrong. What I will say though is that I do not feel limited in any way by my choice of search engine. Every time I try Google, I genuinely hope it will be better than DDG (otherwise why even bother?), but it isn't.

Python is too big to be a proper Lua replacement.

I feel that the problem is not text but language design. A great language should be close to a pareto optimum for both human and machine legibility. Most languages are optimized for human familiarity, which is definitely not the most machine readable format and probably not the most human readable (in a platonic sense).

Being more specific, most languages, in my opinion, are far too permissive with whitespace and use too many keywords. The former leads to there being no canonical form of the program text and results in reliance on external formatting tools, when the compiler could be just automatically enforcing canonical formatting rules. The latter makes it hard to distinguish between types of words, which is why it is almost necessary to rely on syntax highlighting.

If each program has a unique canonical form, it would be very hard to beat text based diffing on that form. Lisp is quite good from the diffing perspective but weaker on human legibility (for most humans).

Definitely an interesting report. The conclusions seem skewed by the author's existing coding skill and fluency though. If anything, I'd expect on aggregate these tools to disempower smaller businesses relative to their competition because their force multiplier will be proportional to existing skill and expertise. In other words, if I create something of value, it will be even easier for my competitors to copy it than it is today and they will have more resources and ability to execute quickly than they do now (if the tools do deliver on the promise they've been selling).

This is why most of the best software is written by people writing things for themselves and most of the worst is made by people making software they don't use themselves.

Yes, but you could bypass the login page.

Late Carlin got far too misanthropic for my taste.

Like all things, we need balance. This is a good argument against guilds, but there are positive aspects of the system too. Imagine a world that was truly a free for all -- one in which there were no trusted authorities in any field. I believe such a society would quickly devolve into a dystopia and collapse.

From my perspective, the big problem is when there is no competition among guilds and the guild leaders wield disproportionate societal power. That is how you end up with oppressive oligarchy, which honestly is a reasonable description of the global order right now. My hope though is that we are better able to organize and compete against the current oligarchic order.

I'd imagine cool is up there as well: https://nguyenthanhvuh.github.io/class-compilers/cool.html

I personally a prefer a stricter syntax with less redundancy. With a sufficiently fast and accurate compiler, things like indentation issues can be resolved very quickly when there is a copy/paste issue.

I found the section on forward declarations at least partially off. I have never needed to use forward declarations for single recursion like the fibonacci example he gave. Mutual recursion does of course require forward declarations.

True story: I wrote my ph.d. thesis on a special case of a general problem. After about one year of work, I realized that the approach would never work for the general problem for intractable reasons. But I also really wanted to finish my ph.d. within 5 years, so I spent the next two years refining the work enough to be able to write a dissertation on it and ignored the fact that it would never really work for what it was intended. I did do some interesting work and learned a lot, but I couldn't really bring myself to try and publish the results (beyond my thesis) because I very clearly had not made an advance in the field. Of course, I do think it would have been useful to publish why I thought that essentially the entire field of inquiry was a dead end, but that would not have made me very popular with my collaborators or others in the field and it wouldn't likely have ingratiated me with anyone else.

The first two properties can be handled by adding optional fields to your struct. The third can be done at compile time rather than runtime if you define a strict class hierarchy. I think really the problem is that many languages make struct definition needlessly verbose so it feels convenient to just use a map. The price of using schemaless includes runtime performance as well as the compiler being unable to warn you about easy (for a compiler) to detect and report data mismatch errors. I have spent a lot of time using lua the way I think many people use clojure. It is quite seductive and does feel very productive at first, but eventually I find that for a sufficiently complex program, I want the compiler to validate my data usage for me.

- def foo(): int | None + def foo(): None | int

Whether or not this makes a semantic difference is language implementation dependent. I think that is why this kind of tool is not especially appealing to me. I would have to have almost complete knowledge of the compiler and the diff tool to truly trust that there is no semantic difference. Moreover, I would like to know why changes to the text that are being made that have no semantic effect are being mixed with those that do.

For me, text is king and that is the level at which I want to evaluate diffs 99% of the time, but I do recognize that others have different goals and preferences.

Hobbes doesn't get the last word on the natural state of mankind. Thank God.