Lem can also render via ncurses, which works fairly fine if you don't need mouse support. It used to also have an SDL2 frontend, but it was deprecated for reasons I don't remember
The compatibility layer mention is valid for many projects, and I personally greatly appreciate that it exists, even if it's a bit buggy
osu! however, is only officially distributed on Linux via AppImage (and semi-officially via Flatpak) and bundles its own SDL for the reasons that, to my knowledge, range from the general pinning to a known stable version approach to the team backporting functionality from SDL3 to SDL2 (last one I remember is non-text-based clipboard functionality, not entirely sure though)
osu! has spent a lot of time trying to switch from SDL2 to SDL3, but due to their high platform coverage (all three major desktop OSes + iOS and Android) and an attempt to keep all functionality native (so properly working Wayland supporr, along with other things) delayed the switch by around 2 years total. For the first time, the current switch seems actually final
That's mostly because BEAM uses an actor-style approach while predating the concept of actors, isn't it? Interesting artefact of history if so
Edit: upon rechecking, apparently that's not exactly right, and Erlang designers learned of actors after designing the language, which makes it all the more interesting
Unsafe code can break certain invariants of Rust, as `unsafe` is just a compiler "hold my beer" flag, which is why you're meant to do safety checks in your safe interface around unsafe code. If the unsafe code is wrapped in a way that does no guarding (or does something stupid in general), it is technically marked safe (because you said "rustc, hold my beer" as `unsafe` is also a contract) despite actually being unsafe
Google people were specifically talking about memory safety. Logic bugs happen. All of the issues in TFA are effectively logic bugs or POSIX stuff, which is a different category entirely that Rust never claimed to solve
1. uutils as a project started back in 2013 as a way to learn Rust, by no means by knowledgeable developers or in a mature language
2. uutils didn't even have a consideration to become a replacement of GNU Coreutils until.... roughly 2021, I think? 2021 is when they started running compliance/compatibility tests, anyway
3. The choice of licensing (made in 2013) effectively forbids them from looking at the original source
Very tangentially related comment, but I remember seeing a post on a local Facebook clone with a prompt to throw at Claude to "make a custom YouTube downloader for MacOS", so the general "Here is a prompt to feed an LLM" is somewhat real for some, apparently
A lot of software projects have names ranging from silly associations to very cheesy puns, and IMO this should never discourage anyone - everyone should have some whimsy when naming things, because it makes names more memorable. After all, people use Python, and name doesn't even refer to snakes!
I personally wouldn't be able to remember "kitty" if it was named "featureful-python-terminal-emulator", and I certainly wouldn't want to recommend it to others under this name
Please note that I explicitly said "past year 2". I believe the first two years were fairly decent, especially those who had worse basics than mine (not that mine were that good).
Notes (because the reply might sound weird without them): I do live in an authoritharian pseudo-democratic country which I will not mention explicitly for reasons; I do think some parts of the education system are effectively brainwashing (primarily the way we study history), but it doesn't affect my statements; I do think (or at least hope) that this is an issue of my university specifically and not our education system as a whole; I do admit that I slightly exaggerated, and that technically speaking there was some useful material in more courses than one, but I do stand by the opinion that the way we were taught only makes few of them actually useful. Also, I use the word "teacher" as there is only one professor in our department, which should've been a weird sign from the beginning, but as this is a story from a local university, you might imagine I didn't have much choice thanks to circumstances of my life.
Now, the fun way to start this would be to mention the specifics first.
Our databases course (now extended into database administration) did have a little bit of theory, primarily normalization and transactions. However, in practice, most of the information we were actually allowed to use within assignments are something you'd learn within 10 minutes of learning SQL (so very basic operations). We were not taught or (effectively) allowed to use constraints until last semester (4 semesters into learning about databases), we did not have a single mention of joins or indices, we did not have any discussions of ACID. It took us a year to even get close to data integrity. We were not allowed to use primary keys until the last semester. A lot of the course (the entire first year of it, really) was focused either on FoxPro DBMS or the visual parts of Microsoft Access, so much so that our assignments required basically documenting our GUI navigation of the latter without letting us do actual database work. We did switch to Oracle SQL DB in semester 7, except that we are forced to work with Oracle APEX and working with raw queries was basically self-sabotage due to the description requirements for the assignment write-ups.
As an extension of the above, we received a frankly ridiculous amount of scrutiny for everything BUT the actual database management. I was once forced to spend 2 hours staring at a Word document in far commander (which the teacher was obsessed with) as Microsoft Word weirded out at me typing out a word and screwed up an error underline, which triggered the teacher so much he forced me to find a reason it happened, or I would have my grade decreased. The same person made us spend the entire first lab class of this semester writing up what Oracle as a company is and what other non-Oracle products are named Oracle. This person alone soured my higher education to a degree that nearly made me quit university.
Our mobile development course consisted of the person running it making us choose a topic and implement a mobile application and effectively screwing off for the rest of the semester. As a result of no guidance, I would argue this is about as useful as making us watch and follow a Flutter (or Compose or whatever) tutorial and making a 10k words long write-up based on that. Also, a single mixup of "phone" and "smartphone" was punishable by extra assignments, initially in a form of making us make a presentation on what's the difference between a telephone and a smartphone.
Our operating systems course was relatively decent, except for the fact that due to the reduced hour count for the program, the only practical things were: write up some Windows batch scripting commands; write up some bash/coreutils commands; launch some Windows utilities from the command line and screenshot the process. The lectures were decent though, even though it was just a fairly high level overview of OSes people use and not what an OS really is. Not having an assignment on multithreading was funny when we got one for oru Java course.
Our neural networks course had us solve a set of quizzes about neural networks. We had no lectures, despite having no proper introduction to what a neural network even is. The course was stolen from a paid one, which I know because, incidentally, after half-intentionally breaking the grading system of the LMS ours was running on (tldr Python ACE due to unescaped evaluation in code runner tasks, go figure), I was tasked with rewriting this same course in a hardened way. The only benefit of this one was that I got paid for it, though you could argue that forcing us to learn on our own was technically useful under the guise of "you need to learn to learn"
Our project management course's exam (or, well, pass/fail oral attestation?) had us talking about Windows COM, Waterfall architecture and manual testing. There was a single mention of unit testing. The course material also assumed that debuggers still could only debug 16-bit code.
Our pre-diploma course project on project management forced us to pre-plan the whole application we were going to write. Architecture, specific library structure, specific class hierarchies, specific classes, fields and methods. While actively forbidding us from writing code. People were also forced to write up about database structure even if their projects did not imply having one. All while we had no choice over our project topics, as those are supposed to be work we do for a company. My friend has a 9k word long write-up about an S3 cache microservice, as that's the only way to pass the requirements.
These are just some parts of the torment we've seen here, as I am only listing out things from years 3+4, ignoring years 1+2 (which had their problems, making a C++ per-symbol parser was a fun one). The history of bias and straight up bullying from the tutors is long, documented and not acted on. The only reason corruption isn't openly involved is that one of the people teaching here was sued for taking a bribe about a year before I got into the university.
On top of all this, we've not learned anything about actual system design, security, distributed systems, functional programming, Linux, ethics, embedded, performance engineering. Our parallel programming class was just a set of questions in a quiz about OpenMP without an actual introduction. Our graphics class was us making models in Blender and p much nothing else. Our web development course forced us to write everything in Notepad in pure HTML4, and using JS was punishable. Our OOP class was overfocused on C++ so much that we've got `std::function` as an exam question because "well, it's a callable object, who cares that it's actually used for HOFs". Anything related to deployments and DevOps was only mentioned thanks to the fact that one PhD student was forced to run a subject that was meant to be entirely about Windows Active Directory and made a proper course of "from zero to CRUD in production" instead, which was arguably the most useful course in those 4 years for the majority of my peers, as it actually forced people to learn about CRUD workflows, frontend, REST API design and Docker.
I strongly believe that the way we were taught things related to most subjects actively harmed students, as we were not allowed to do our research and use results thereof, with the lecture material being either mostly useless or grossly outdated and out of touch with reality, even though the subject structure is pretty good and seemingly on par with normal universities.
I am in my final year of my bachelors in Software Engineering. I was (mostly still am) very interested in both SWE and CS in various angles - I studied a decent bit of PL theory, I tried to get into systems programming, I've built a bunch of "portfolio crud" software and had a short internship in a real company, with all of the above being roughly equally interesting to me. All this is to say I genuinely love the field so far.
However, the only benefit I've got from my local university is that it saves me from military while I study. Past year 2 (out of 4, country-specific quirks) there was roughly one subject actually worth paying attention to, so I also have switched to a "just get a decent grade at any cost" mode, as most of the material we're studying (and especially most of the assignments we've done) has negative value in real world.
Most of my peers consider me both more enthused and more knowledgeable than the average student, which mostly makes me realise that roughly 95% of my peers don't care about the contents of the courses.
All this is to say that, while grading is hard, the only thing that might get people to actually care is a proper course, no matter what threats you make.
You can't cut down a language without breaking changes. And there fairly often are internal changes to simplify the compiler and the tooling. Just in the latest release, annotation internals were finally fully unified between rustc, cargo, clippy and other tools. This was a fairly considerable effort in deduplicating code. Borrow checker is being rewritten to move to tree borrows, trait resolution is being refactored for a variety of reasons. Code is being simplified where possible, but this doesn't mean Rust doesn't have areas to improve in, especially if there is a goal of replacing Ada/SPARK
There are ways to handle these effects without bloating up normal applications. For example, using attributes implemented as intrinsics, which wouldn't really affect anything that isn't using them.
The thing is, some of these things are very useful in specific domains, and all these domains are closely related to the ideas of safety. Nondeterminism and IO are important for purity/referential transparency, which is a fairly important effect for business logic IMO. Guaranteed termination matters for formal verification. Unwind removal matters for embedded. I don't think wishing for these things is really all that unwarranted
> I actually don’t see how this is any more beneficial than the existing no_panic macro
no_panic and similar macros are doing a very hacky workaround which isn't really a great static guarantee. The simple fact that building with panic = abort makes the macro useless is an annoyance in and of itself. dtolnay did great when figuring out some path forward but it's somewhat shaky
> What I need is an emacs with more lisp and less javascript
Lem[0] in ncurses mode might be your friend. Unfortunately the BDFL deprecated the SDL frontend seemingly due to the SDL3 breakages, but the web one uses webview + a homegrown system instead of electron and framework magic, so it's still fairly lightweight
its main proposition is that the whole thing is written in Common Lisp, so it retains the hackable model of traditional Emacses without retaining the legacy of GNU Emacs
From this perspective - not sure, to be honest. For me an important factor was that Zed is getting way more love from its devs than my old editor of choice Helix. But also not being constrained to a cell grid is very nice in terms of readability to me.
One thing that Zed doesn't solve but likely will is that I found "jump to label" style of features (I think flash.nvim is the closest for neovim?) is almost unreadable to me with inlined labels, but that's so highly specific I'm almost willing to live with it
A lot of people use VSCode. Zed's value proposition is being basically that but with fully native code, so without the madness that is Electron. If you're not a fan of this kind of tooling, it's totally fine, but many people see the value in having an extensible graphical code editor
I believe latest Iced versions do have a `Lazy` widget wrapper, but I believe that effectively means you need to make your own virtual list on top of it
After using projects named like "slurp", "eww" (combined with "yuck"), "yay", "honkers railway", "jason" and many many others, I personally kind of gave up on any attempts to judge projects by their titles. Partly due to many developers being whimsical nerds, partly because even marketable names say nothing about the product half the time so what's the point anyway