We should separate criticism of tools based on legitimate concerns from criticism of tools based on tribal or class issues. Plenty of tools can be used well but largely aren’t because most of their devotees are beginners (see: Java, C, C++, Python). Other tools are fundamentally flawed, and while using them well is not impossible, it is a trick that takes a great deal of experience and is beyond the scope of nearly all of its audience (see: PHP, Perl, Javascript).

This is a really important point. The idea that expressing contempt for specific programming tools should be forbidden because the use of those tools is associated with an underrepresented group about whom criticism is forbidden doesn’t make the problems with those tools go away - but it does strengthen the association of those bad tools with the underrepresented group.

I consider this really to be an issue of beginners graduating to higher levels of understanding (and systematic pressure making it harder for certain groups to graduate out of the beginner classification), and one way to help this is to be extremely clear in your criticisms about the nature of the problems you criticize — in other words, rather than saying “PHP users are dumb”, say “PHP is a deeply flawed language, and PHP users should be extremely careful when using these particular patterns”.

This is always good advice. Criticize the actual problem as precisely as you can.

Another way is to make it clear that using a single language is not acceptable in a professional context: any serious developer has a large toolbox already, and if beginners understood that language preference is not a reasonable basis for long-term tribal divisions because any professional belongs to multiple tribes, the toxic identity-based hostility between programming language communities would mostly go away, allowing concrete and issue-based critiques to become more visible.

Absolutely, 100% agree. Languages should be tools, not foci for tribal identities. Every programmer should be expected to be familiar with multiple programming languages, even absolute beginners.

This article is a good argument against treating a lack of gender diversity in video games as a problem to be solved. Men and women are systematically interested in different types of video game experiences, and game creators who cater to one type of experience or the other will naturally have a gender imbalance in the sorts of players who want to play that type of game.

I would love to have a feedback post, three years later. I don’t really know the status of Neovim right now

This is exactly the sort of situation that status code 451 is for.

One thing that is clear to me: the author hasn’t actually written much (or perhaps any) Rust. This is clear to me because I think one of the traps that the merely Rust-curious fall into is a disproportional fear and loathing of the borrow checker. This is disproportional because it ignores many of the delightful aspects of Rust – for example, that algebraic types in a non-GC’d language represent a revolution in error handling. (I also happen to love the macro system, Cargo, the built-in testing framework, and a bunch of other smaller things.) Yes, the lack of things like non-lexical lifetimes can make for some wrestling with the borrow checker, but once one is far enough into Rust to encounter these things, they are also far enough in to appreciate the value it brings to systems programming.

To sum, the author shouldn’t weigh in on Rust (or any language, really) so definitively without having written any – or at least make clear that his perspective is informed by reading blog entries, not actual experience…

As a result the internet age has seen an exponential increase in the complexity of programming, as well as its exclusivity.

This is precisely false. The internet age has seen decreases in the complexity and exclusivity of programming, compared to what existed before. Millions of people are programming computers in some capacity or another. In fact this is a large part of the reason why there is no “American Programmers Association” - the barrier to entry is so low, that there’s no chance for such a cartel to form. You don’t need anyone’s permission to start programming, just access to some kind of computer. And computers are cheaper and more widely available now than they ever have been.

No amount of coaching and cheerleading is going to make most people enjoy spending their lives playing Dungeons & Dragons and Rubik’s Cube. Why is making the technology itself more humane off the agenda?

This is true, I think, but I don’t think this article makes a good case that this requirement of abstract mathematical thinking is incidental to programming, rather than an inherent requirement of the discipline. Even spreadsheets, I would argue, require some amount of abstract mathematical thinking to make use of, which is why not everyone is an accountant - but accounting is less sexy than programming, so no one thinks that’s a problem.

I’m amused that this thread is on the Lobsters front page at exactly the same time as this thread (https://lobste.rs/s/gpzhu8/is_freedom_zero_such_hot_idea), which argues against general purpose computing - on the grounds that some users of software are immoral and the authors of general-purpose software have an obligation to try to prevent these immoral users from using their software, using the mechanism of selective software licensing. This sounds to me a lot like “Make me a general-purpose computer that runs all programs except for one program that freaks me out”, albeit enforced in a somewhat different way.

Maybe free software licenses should have a provision explicitly barring people from using the software if they publicly advocate for licenses that try to prevent their political enemies from running a program as they wish for any purpose.

Yeah, why not post the source? Any reason why it only provides links to the posts, rather than an embedding of the post on the page?

This is pretty far off-topic, and most likely to result in a bunch of yelling back and forth between True Believers.

Flagged.

EDIT:

OP didn’t even bother to link to the claimed “increasing evidence”. This is a bait thread. Please don’t.

Eh, not a bad read and in principle I don’t disagree. Google is essentially trying to mold the world into their politically-correct version of what it should be. As an uninformed non-UX-trained mere user of their products, I find that there is plenty of things that Just Work material design and several things that are a mistake (like that damn floating plus button to add or do something new… I keep looking for a real button, not one floating over the content in the middle of the screen).

But also keep in mind who wrote the article. They don’t want you taking a free off-the-shelf design framework when you could instead be paying them to build you a custom one.

I actually do most of my programming on a Thinkpad laptop, using the built-in keyboard there, which I have no issues with. I own a K-Type hooked up to a PC I mostly use for gaming, but I haven’t made as much use of the firmware programming functionality as I could. I told myself when I bought it that I would make it display a pretty light show, but so far I haven’t gotten around to doing that yet.

I would like to switch to open street map, but the ecosystem around it doesn’t seem to be quite there yet. I’ve installed Osmand on my (android) phone as a google maps replacement, but I’ve noticed that it tends to be very laggy, and it’s often very slow to pick up my GPS signal. These basic things make it so that using Google maps in the browser is the more effective way for me to route myself places. I was informed about the existence of maps.me the other day, but haven’t tried it out significantly yet myself, so maybe that app will work well and prove to be an adequate google maps replacement.

The underlying factor that caused the github purchase to be a problem was that github was free. As long as the service is free, then selling out is always a risk.

Why not take the total server costs at the end of the month, divide by the number of users, and charge that as a monthly subscription to keep the lights on? If the system is even marginally profitable, that makes any kind of selling out (via acquisition or selling user data) less attractive.

If the system is costing the administrators money, then they have a high incentive to sell out.

I distinctly remember including HotBot in a list of Internet search engines I had to compile for some kind of “internet literacy” school project I had to do in 4th grade or so. So that’s a hell of a nostalgic name for me. Interesting that they’re still around, and claim to be a “private” search engine along the lines of Duck Duck Go - anyone have any idea of how trustworthy that claim is?

I’m not entirely happy with this tutorial, which seems to be the only official source of documentation on how to use LLVM in practice. I’m working on a toy programming language implementation myself, and I’d like to have it compile to LLVM, but I found it a little difficult to apply the lessons learned from this tutorial to languages (like my toy one) that work even a little bit differently than Kaleidoscope.

Love the tech, going to donate. Web is moving the opposite direction though. Even email is having a rough time. Quite a bit of the communication moved to Slack, social networks, chat etc. IRC & RSS are having a rougher time.

Amazing how this article can talk about how great the fediverse is (a network that exists for nearly a decade now) without once using the word or mentioning its history.

I don’t think using a formal language with syntax closer to formal written English, rather than one with syntax like that of currently-extant programming languages, does anything to help reduce the complexity of programming computers.

Here’s a random function (in Scala) from one of the codebases I work on. I picked this because it was relatively short and in a file I happened to have open anyway:

def sarkLogin(session: Session, authCode: String): Future[Done] = for {
    sarkAuthResponse <- exchangeSarkCodeForTokens(authCode)
    data = SarkAccount.Data(sarkAuthResponse.access_token, sarkAuthResponse.refresh_token)
    _ <- setUserService(session.userId, SarkAccount)(data)
  } yield Done

And let’s imagine that, instead of a programming language like Scala, I wanted to write this function in a language with syntax similar to formal written English:

SarkLogin in a function. It has two arguments, a Session called ‘session’ and a String called ‘authCode’. In the context of a Future, it does the following things in order:

It takes the authCode and exchanges that sark code for tokens, calling the result ‘sarkAuthRespose’. This might fail in the way that Futures know how to handle.

It makes a SarkAccount.Data out of the sarkAuthResponse’s access_token and refresh_token, calling it ‘data’. This might fail, but not in a way that Futures know how to handle, but rather the old way from before they came up with Futures.

It sets the user service with the session’s userId and the SarkAccount, and then it takes the function that returns and immediately calls with with the data from earlier. If that didn’t fail in the way that Futures know how to handle, throw the returned result away.

If that all worked, yield a Done wrapped in a Future.

Does the latter seem any easier to understand than the former? I don’t think so - because most of the cognitive work a programmer needs to do to understand this isn’t in grokking the syntax, but rather knowing what all the specific technical terms mean.

To understand this code you need to know what a Scala Future is (and how it is a monadic type that has its own idiosyncratic behavior when, hence the “fail in a way that Futures know how to handle” verbiage). You need to know what a Sark is (it’s a custom service that someone else wrote, and I don’t really know what it does other than that the clients of this software need to talk to it sometimes). You need to know what a couple of different data structures involving Sarks do, and you need to know that there’s a distinction between an “authCode” and a “token”, and that’s why that exchangeSarkCodeForTokens function exists (I learned about this from reading documentation on Sark months ago when I wrote this originally and forget why that mattered now).

In short, there’s nothing about writing out this code as a precise technical description of what this function is doing (which even this isn’t, not unless I told the compiler exactly what all the natural English phrases I used like “This might fail in the way that Futures know how to handle” mean) that makes the functionality easier to understand for anyone, and it definitely took longer to type because I didn’t use the convenient math-like notation that is a programming language.

I’ve read a number of posts by Uncle Bob that I’ve disliked - I don’t think that programmers are a special class of people who are duty-bound to take an oath to uphold the honor of the profession, as opposed to just people with a particular skill/interest in manipulating computer systems; and he’s said things about unit testing vis a vis static typing that I thought were wrong. In light of this though:

Only when he writes something that I strongly disagree with, does the hunch about Clean Code became clear. The > last days on Twitter we watched Uncle Bob implicitly decry the violation of Godwin’s law rather than the internment > of thousand children under conditions that Amnesty International compare with torture. In the following days, Uncle > Bob fought back against his critics also stressing that he thinks the situation is horrible, “but…” not as important as > “unhonorably” comparing others to Nazis. I think his priorities are horribly wrong. I responded “In light of @unclebobmartin’s recent tweets, ideas like Clean Code have started creating a bad taste in my mouth. Let’s just say “code”, eh? I’m officially instituting “dirty code Monday’s” to remember to question dogma, tribalism and things- before-people mentality.” Bob asked me to explain “why you decided to lead a boycott against the concept of Clean > Code”. Thus this blog post.

I think it’s pretty clear that this blog post is in large part motivated by a political disagreement rooted in very contemporary (as in, the past couple of weeks) American national politics, and that leaves a very bad taste in my mouth.