I agree with this, Elon is a disingenuous selfish prick, but this source doesn’t provide any indication that Musk admitted anything, it’s just speculation from detractors.

I don't think we should abide hate speech in any format for any reason.

That said, it's concerning that the Australian courts were able to get recompense for Barilaro, yet Barilaro's very real corruption and straight up evil that Friendlyjordies was trying to call attention to has gone completely unaddressed.

This is such a brain dead take. The conference exists to support a group that has been and is actively discriminated against and harassed in the tech industry. All the men crashing the event care not at all about the conference, its mission, and its participants - they’re just desperate to find a job. And while I absolutely sympathize with people suffering unemployment, it’s really shitty (and sadly so typical and indicative of the problem) to flood a space designed for women and non-binary people, completely disregarding them in the race to get ahead.

There are several things I disagree with in this article, although I see where the author is coming from. I will never be onboard with "I’ll take my segfaults and buffer overflows.", and I fundamentally disagree about concurrency. I also think that cargo is fantastic, and a lack of standard build tools is one thing that holds rust's predecessors back.

However, a majority of the authors points can be boiled down to "C is more mature", which doesn't tell us much about the long-term viability and value of these languages. For example, in the author's metric of stability and complexity, they use C99 as the baseline, but C99 is the state of a language that had already had almost 3 decades of development, whereas Rust has been stable for less than a decade. Talking about superior portability, stability, and even spec, implementations, and ABI is in some real sense just saying "C is older".

That's not to say those things aren't valuable, but rather they aren't immutable characteristics of either language. And given that safety is playing an ever more important role in software, especially systems software, I think Rust will catch up in all the ways that are meaningful for real projects more quickly than most of us realize. I certainly don't think it's going anywhere anytime soon.

I think you’re confused on a couple of points.

1. The laptop just released was the 16 INCH framework, not the 16th generation. It is only the second model of Framework laptop, coming after the 13 inch. They have released parts for 3 generations 11-13) of Intel motherboards for the 13 inch laptop.
2. Framework is a fairly new company. They’ve only been around for a handful of years. I believe the very first 13 inch laptops shipped in 2021 (plus or minus a year).

So their track record so far with delivering on their promise of upgrades and repairs is short, but so far it has been stellar.

This is, in part, a correlation. To some extent, compiled Rust is fast because compiling Rust is slow. That is, Rust does a lot of work (static analysis) at compile time so that the runtime binary is as fast as possible.

I think they’re referring to the fact that Edge runs on the Chromium engine which, as the name implies, is a Google product.

The first comment literally wasn't talking about a whole group of people, they were talking about the men in this thread leaving comments that illustrate the exact reason why this space created by and for women and non-binary people should be about and for the benefit of women and non-binary people.

One alternative that seems promising is Nebula. It only fills a small part of the role YouTube currently occupies, since it focuses on being a platform for high quality professional content creators to make unfiltered content for their audience, but it's funding model seems to be much more honest, stable, and so far viable than an ad-supported platform or the other alternatives. I don't think anything could realistically replace all facets of YouTube (and I think the internet might be healthier if it were a little bit less centrally-located). A self-sustaining, straight-forwardly funded platform like Nebule seems like the best path forward to me.

My understanding is that these passkeys can be securely synced - either via your device cloud (e.g. iCloud), or hopefully soon via your password manager. So not that different in terms of UX than current 2FA, but more secure in the backend.

TypeScript React (although I like Svelte better, it's hard to pitch for business projects), C# ASP.NET Core API, Postgresql.

NixOS is a distribution built around the package manger Nix. Nix is not necessarily an iteration of Flatpak ( especially since it’s been around since 2004), but it does accomplish many of the same goals in a more robust way with fewer trade offs.

The main idea of nix is that EVERY dependency of a package is tracked, from the exact glibc version all the way up to e.g. Python packages. I am not a Nix expert, but my surface-level understanding is that this is accomplished by hashing the package and all its dependencies, very aggressively, so that even if a hot fix patch is released that doesn’t change the version number, the new package is still different (as is every package that depends on the new version). That enables Nix to be the best of all worlds as far as sharing system packages like a native dependency while assuring stability and encapsulation like a flatpak. So it ends being as fast and small as the former while being as convenient and cross-distro as the latter. There are other innovations, like declarative dependency management and perfect rollbacks, that make Nix/NixOS stand out, but the above is it's main innovation over Flatpak and older system package managers.

Have been using it since early Alpha days, and I like it a lot but it definitely is still lacking some of the polish of more established tools like Notion.

1. Does it work offline? Yes, it does. Your changes are saved locally and synced at the next opportunity. Obviously this can occasionally cause conflicts but in practice I've never had issues.
2. Does it have databases like Notion? Not exactly. I was never a Notion power user so I can't say how well they compare, but Anytype lets you define your own custom objects with custom relations (sort of like database columns) and link any objects together, as well as creating Sets of objects of the same type and Collections of objects of any kind. So I think in principle it can replicate all the features of Notion databases but in practice you'd want to change how you think about it to fit Anytype's model more easily.
3. Nothing like that yet, although they just open-sourced all their code and the devs are very active on the official forums receiving feature requests.

Since I am not a woman, transgender or otherwise, I won’t comment on the differences or similarities of their experiences. That said, excluding transgender women from a woman-oriented space does not seem helpful or thoughtful to me, just transphobic.

Also, distinguishing between women and females is not something I’m familiar with and don’t feel good about it. It’s certainly self-evident that afab women and transgender women have on average different lives experiences especially during their formative years in which an interest in tech and CS is likely to be either cultivated or discouraged. Nonetheless, given the significant prejudice against transgender people, I imagine few women would begrudge them participation in this community.

I certainly see where you’re coming from, but I think the designers of C# have done fairly good job evolving the language to balance backwards compatibility, simplicity (in terms of having “only one way” to do things), and the ergonomics expected of modern languages. I think C++ and JS are great comparisons because C++ has at this point added everything and the kitchen sink to it’s language and standard library, whereas C# has gone much more like JS introducing features that evolve the best practices for writing but still feel and read like essentially the same language. For example, primary constructors still look just like regular C#, it’s just a nicer way to define simple POCOs when desired.

As far as important language features, I think it’s easy to pick on discriminated unions because it seems like C#’s users unanimously want that. However, if you read through proposals and discussions, it’s obvious that there’s a lot of nuance and trade offs in deciding how and what form of discriminated unions should exist in C# (and the designers are very active in working through that nuance and trade off - they said they have a working group that meets weekly to discuss it I believe*). And to be fair, they have introduced a LOT of other important features (like records and the vastly improved pattern matching) in just the last few years. Without those features, discriminated unions wouldn’t be nearly as appealing, and those features are great for the language even without DUs.

*Edit: Source for my claim is the recent Languages & Runtime Community Standup on the official dotnet YouTube channel. Mads talks about the working group at 21:05, but the discussion of discriminated unions begins at 7:09.

This is a fantastic overview of the issue with this proposal, in the broader context of enshittification.

Nushell is so great! I’ve been using it for a couple years. It has completely replaced my need for tools like grep, sed, awk, etc. and because it handles JSON and so many other data formats natively I rarely even need to think about parsing.

Interesting, I thought Floatplane only hosted LTT content. Nebula has a LOT of creators spanning a very wide gamut of highly content. It has been gaining momentum steadily for several years now.

That said, I'd be happy to see them both succeed. We need more competition, having all internet video (minus NSFW and some short-form) hosted on one platform seems neither sustainable nor ideal.

I think the point is that they don't want to have to use a full JS framework (which is what HTMX is) for this behavior.

And this is where HTMX fits in. It's an elegant and powerful solution to the front-end/back-end split, allowing more of the control logic to operate on the back-end while dynamically loading HTML into their respective places on the front-end.

But for a tech-luddite like me, this was still a bit too much. All I really want to do is swap page fragments using something like AJAX while sticking to semantically correct HTML.

EDIT: Put another way, if you look at HTMX's "motivation"s:

motivation

• Why should only ](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a) & [ be able to make HTTP requests?
• Why should only click & submit events trigger them?
• Why should only GET & POST methods be available?
• Why should you only be able to replace the entire screen?

By removing these constraints, htmx completes HTML as a hypertext

It seems the author only cares about the final bullet, and thinks the first three are reasonable/acceptable limitations.

If you dig the structured output of powershell, you might want to check out Nushell. It’s a cross-platform shell that builds on powershell’s structured data approach but is much less verbose and, in my opinion, more intuitive than both powershell and Posix shells.

I've heard it as a word, "Rustles". Not sure how canonical that is though.

Have you tried developing a GUI app for Windows in the last 5 years? All the official first-party frameworks are either mostly deprecated (WPF, WinForms), or half-baked and despised by every developer I’ve talked to about them (MAUI).

Because at the end of the day, SQL it what's being run by the database. For example, in the Showcase on the front page, they have an "Orthogonality" example that demonstrates filtering both before and after an aggregation, which compiles to a WHERE clause and a HAVING clause respectively. WHERE and HAVING have very different impacts on SQL queries, and vastly different performance implications, but the simplification in PRQL obscures that complexity.

At the end of the day, the transpiled langauge will have to either support only a subset of SQL's features, or else be at least as complex as SQL. It cannot support all of SQL's features and yet be less complex, because it is just a wrapper around SQL.

I suppose for the right crowd, possibly people who run queries only once and do not care about performance implications, data integrity, etc., this could be a really useful tool. And in all fairness, they mention exactly that on their homepage:

"PRQL’s focus is analytical queries

PRQL was originally designed to serve the growing need of writing analytical queries, emphasizing data transformations, development speed, and readability. We de-emphasize other SQL features such as inserting data or transactions."

But for developers who need to maintain an application database, I don't foresee this becoming a useful substitute for SQL.

I'll stick with nushell for terminal-first data interactions.

I don't know anything about the newsletter. The core of the article seems to be observing a shift in AI/ML/LLM opportunities. Where before, most people in the field were developing the base models and doing the arduous and highly complex work of training models (what the author calls ML Engineers), now the majority of this field will be people who use those pre-made and pre-trained models, tweaking and applying them for more and more specific and quantifiable uses (what the author calls AI Engineers). He drew a malleable line between the two as whether you're interacting with the model directly or via an API.

My preferred variation of this is to make it an open question that leaves them in the position of authority, and assumes that they made a deliberate decision.

For example, instead of "Why aren't you using StandardLib that does 90% of this?", I would try "Could this be achieved with StandardLib? Seems like it would cover 90% of this".

This seems nice in theory, but the tradeoffs make me question it's real world viability. It has to be a transpiled language, because SQL is so ubiquitous is may never die. And yet, because it's a transpiler, I'm skeptical that it will actually be easier to write than SQL, because you'll still need to know all the gotchas and eccentricities of SQL.

Maybe for users who already experts in SQL this would be a quaint alternative syntax. However, personally I've already invested so much time developing familiarity with SQL that I see no advantage in moving to a new syntax that would take more time to become deeply familiar with, and that my co-workers won't understand.

"the only primary difference was that one happens before the aggregation and the other happens after, and all the other implications stem from that fact."

This is correct. The biggest implication of that difference is that, when you filter rows via a HAVING clause, the query will first select all the rows and aggregate them, and only then begin to filter them. That can be a massive performance hit if you thought that the filter would prevent filtered rows from ever being selected. Of course this makes perfect sense, there's no logical way to filter an aggregate without first aggregating, but it's not obvious.

"PRQL's simplification, rather than obscuring, seems like a more clear and reasonable way to express that distinction."

My main point is that PRQL makes no distinction. If you didn't inspect that SQL output and already know about the difference between WHERE and HAVING, you would have no idea, because in PRQL they're both just "filter". Hence, PRQL is not simplifying the complexity (you still need to learn the full SQL syntax and the specifics of how it works), but it does obscure (you have no hints that one of your filter statements will behave completely differently from the other).

As far as removing arbitrary SQL features, I agree that that is it's main advantage. However, I think either the developers or else the users of PRQL will discover that far fewer of SQL's complexities are arbitrary than you might first assume.

It’s not just a proposal, it’s already fully defined and almost completely implemented - I believe they’re just waiting on a standards update from ISO for time zone stuff.

I mean, the simple proof is that Rust has been growing by leaps and bounds in the embedded world, which is the closest to bare metal you get. It’s also being used in the Linux kernel and Windows, and there are several projects building new kernels in pure Rust. So yeah, it’s safe to say that it’s as close to the metal as C.

Also, the comparison to Java is understandable if you’ve only been exposed to Rust by the memes, but it doesn’t hold up in practice. Rust has a lot more syntax than C (although that’s not saying much), but it’s one of the most expressive languages on the market today.

This misses the fact that even the experts have been using “AI” to refer to whatever technology used to seem impossible, until it becomes commonplace. Before LLMs there were heuristic algorithms, and then expert systems, and then intelligent agents and then deep learning. As the boundaries of what is deemed achievable expand, the definition of AI moves to just beyond the frontier.

Ah ok I think I get you now. To be clear, fall through is implicit - when the case being fallen through is empty. I forgot that, if you want to execute some statements in one case, and then go to another case, you need gotos. To be fair, I’ve never needed that behavior before.

I absolutely see your point on break not being the default. It is sad, although I will say I don’t mind a little extra explicitness in code I’m sharing with a large team.

I’m not sure I understand your point about fall through having to be explicit, but I agree that switch statements are lacking ergonomics - which makes some sense considering they were added a looooong time ago. Luckily, they added recently the switch expression, which uses pattern matching and behaves more like Rust’s Match expression. It’s still lacking proper exhuastiveness checks for now, but that’s a problem with the core design of composition in C#’s type model and one they are looking to solve (alongside Discriminate Unions in all likelihood).

I really like Anytype.

This is not true. The higher complexity of frameworks is unarguable, but it reflects the higher complexity of modern web apps. The reality is that React/Vue/Svelte achieve things that are simply infeasible with e.g. the LAMP stack or jQuery.

Yes, that is true. But actually it’s more than that: you don’t need a dev to display static content or a decent commerce page anymore. Square space and it’s competitors give more options at a better value to the layman than devs using PHP or jQuery could hope to these days. We have the simple websites, so frameworks very specifically target productivity and maintainability for complex web apps.