moth-fuzz

Your division of 'artists' and 'programmers' into separate tribes is almost too telling.

I'm going to challenge the question - if I've got something written down, why would I need to memorize it? Maybe in school where closed-notes tests are a thing, sure, but nowhere in the 'real-world' tests one's ability to memorize in the strict sense. I write things down for a reason and that reason is not just accessory to memorizing it. I put things on paper precisely so I don't have to put them in my brain. To keep them in both places would be redundant.

On that note, I have ADHD, and very little 'brain-RAM', and really lack the ability to memorize things or recall what I've memorized. The only consistent way I've found to 'memorize' things is to deep-learn them, to the point where I can infer all the answers from prior knowledge, and draw new conclusions from existing conclusions, pretty much all the way down. I can't just brute-force-memorize the conclusions themselves. Every step inbetween has to make sense. It's like memorizing the square series as individual numbers, 1, 4, 9, 16, etc. (something I cannot do) vs memorizing the formula x^2 and being able to calculate the resulting numbers when needed (something I can do).

"I want to be able to choose to consciously support artists who don't use EQ. I want to be recommended and discover new artists, who consciously don't use EQ. I want to be able to choose to listen to real vocals as a genre. I want that choice."

Note that many recording artists do not actually make that choice; it happens further up the chain. Regardless, whether or not a singer or producer uses a particular effect on their voice does not distinguish between the vocals being 'real' or not. If you simply don't like the way it sounds, on the level of artistic taste, well, you can make that judgement for yourself, but, to claim it's more profound than that is just pure pretense.

Also, why are we talking about autotuned vocals on a thread about a speech synthesizer? Claims of 'real vocals' are already out the window at that point.

The new V6 vocaloids even with the AI expressiveness still sound very much like vocaloids. There's a specific timbre to the way they pronounce certain vowels or do odd formant shifts that always comes through that I'm unsure of if it's intentional or not - on one hand it's very signature, on the other hand it doesn't sound quite as 'realistic'.

As far as the iconic characters go, they're moving to an entirely different engine (Piapro NT) anyways, so I wonder how future works created using them will sound.

Not to mention they were integrated into the machine itself - picture 1-4 floppy disks fitting snuggly inside your PC right where they're supposed to go and where nothing else even could go, versus a handful of usb sticks of various shapes and sizes sticking out haphazardly like porcupine needles, some even pushing each other over because they're too thick, or connected by a jungle of wires, either way hooked up to a generic universal bus port that could be used for literally anything else and has no specific semantic meaning to your PC's software.

I never quite understood why this is the way it is - why is the paradigm

    impl TryFrom<&T> for U 

instead of

    impl Into<Result<U, E>> for &T

Why make a separate trait? And why make the blanket impl from-based rather than into-based?

this is what kills me about games these days, not just multiplayer games where you have to play the 'meta' if you want to stand a chance, but even single player games where every choice is viable but people will make fun of you for not choosing the 'optimal' build, which a lot of the time is backed more by personal preference than anything else. I used to play Overwatch and left for largely that reason - people would get on the microphone and try to play the leader of a group of randoms and tell other players to 'do their jobs' and pick the 'right' hero.

An example from today is in Elden Ring - largely a single player game, but with multiplayer elements. When I started playing, there was a huge variety in player stats, weapon/armor selection, and people were even encouraged to try out different things by the in-game "rebirthing" mechanic. Then someone found out that a single sword used a specific way vastly overpowers everything else, especially in multiplayer, and now everybody who plays player-versus-player is locked in to using that same sword or else it's not even a fair fight. Players have been begging the developers to change this, and they only recently (as of this week) did something about it.

I have a friend that's convinced that her ADHD 'causes depression' because her brain does not produce 'enough dopamine'. I'm noticing more and more among my peers a mythology around brain chemicals that's about as accurate as the four humors but with a scientific-sounding veneer. All brain function (and thus all bodily function, because the brain is the whole person /s) can be traced back to the presence or absence of a nominal amount of certain chemicals.

I wonder how the popular understanding of these processes will evolve as more and more is discovered and understood.

Yes actually, particle motion is quantized on the planck scale, that is, snapped to the grid. That's why it's called quantum physics. Modern theories even have it that there are no particles, rather, excitations of various quantum fields.

So what we consider a discrete photon particle with a location (x,y) would actually not be an individual particle and would be more like:

  electromagnetic_field[y][x] = "excited" 

in a big (presumably infinite) grid.

Is there actually an API out there that actually qualifies as RESTful, other than the WWW itself? When you really take the time to consider the spirit of RESTfulness, and the designs and constraints of hypermedia in general, I can't really think of anything other than just... websites on the internet. Or some WWW-like that might not be transferred over HTTP nor use HTML but would be functionally the same regardless (and far less popular).

It seems that trying to build a hypermedia API in the spirit of hypermedia precludes someone actually designing an app with any particularity (themes, layouts, pages, certain requests/responses being valid/invalid, etc.), since it must be so general, the only client application that could qualify is the web browser itself - able to render any HTML document without actually knowing about the document semantically. Because having prior semantic knowledge of the API violates REST. Assuming that, are the 'apps' and APIs one would design then just hypermedia documents? Sounds like web 1.0. Not necessarily a bad thing, really, but REST seems too specific to be meaningful outside of websites, either that or I'm not imaginative enough.

I'm not sure what a 'hypermedia API' looks like that isn't just a web page or a functional equivalent thereof. It seems that either the WWW is the REST reference implementation or REST is simply the architecture of the WWW codified.

Wow, I should have read this before cadence-per-cadence making the exact same comment!

I have no idea why nobody uses bookmarks and everybody keeps hundreds of tabs open. When did that start? Who even has the RAM for that? How do you even click on them when they’re that tiny? So many things just don’t make sense.

I'm not sure at the end of the day there's such a thing as 'intelligence', in terms of how we talk about it, like some sort of RPG stat. In my experience, kids aren't really 'smarter' than other kids, they have learning styles and brain patterns that match up with how the courses are run.

Anecdotes, I know, but I was terrible at math compared to the kids in high school who could all just memorize and regurgitate (I have ADHD & very poor working memory, and no random-access). These kids also regularly looked up answers to future quizzes they found online and bsed their way through. But, in college, which involves a more abstract and rigorous (and dare I say meaningful) understanding of the material, I excelled while many of my former colleagues fell behind as these were 'new problems' they couldn't just look up because they didn't have answers.

My point is intelligence is not a scalar axis in which some people are 'gifted' and some people are not, it's a multidimensional series of mental configurations that must be adapted to in the classroom and outside. Hire better teachers and pay them more is the only concrete thing I can think of. Gifted programs aren't the way as they're entirely arbitrary to a specific environment. The wrong teacher for the right student will ultimately make the student worse for it, and these programs don't account for how truly uninspired some teachers can be. Not to mention parents, or availability of learning materials, quality of libraries, etc etc.

and to think I almost made this comment if I hadn’t continued scrolling!

Also the form of the sprites changed significantly, it was a massive shift in artistic personality and aesthetic direction that the tutorial just called it “not using straight lines”. I think they could have made their point while not swapping in a different set of tastes entirely.

how exactly is it a hard problem? You don’t have to rotate the sprite by sining and cosining pixels by hand, you can just render to the same resolution as your sprites and it’ll look fine.

The problem is that most indie games render at 2x or 3x or more natively.

Having pixel art and then each “pixel” being 4 or 16 pixels, obvious when scaled or rotated, I think is bad artistic form regardless of whether it’s a vintage styled or modern styled game. It breaks the flow and suspension of disbelief that comes with pixel art. The brain can’t interpolate anymore. Besides, it’s not hard to render to a buffer and scale it up nearest-neighbor, and it always looks better IMO

Well, historically, 4.0 was made to be roughly equivalent to 3.3 IIRC. 4.1 didn't add much and 4.2 started seeing changes going in the direction that was roughly complete by 4.5 I'd say. So each version bump in the 4.x range is just a history of getting a slightly cleaner API each version until you get to a version where you can personally say "I'm okay with this now" based on your preferences as a developer. For me personally that version is 4.3, it has the features where I think "this makes sense as an API" and things that came after that were just extra conveniences. But what are just conveniences for some developers are the basic core abstractions for other developers, and where you draw that line is up to you.

In my personal opinion, 4.2 is like, halfway to 4.3

But sometimes it's more comfortable to go none of the way than half of the way, hence me targeting 4.0 in my most recent library.

the thing about Rust's ownership model is that a reference is not ownership, it's 'borrowing', and should be treated as such. But - and here's the kicker - the borrow happens as long as that reference is stored, not just when it's accessed i.e. dereferenced. This makes a number of data structures and patterns difficult and impossible to implement as you can't keep track of references to anything. You can't really make an opaque handle, for example, that can do operations through a stored reference. You have to store some ID or something and then when you want to do operations you need to pass the original container to the function anyway - so what's the point of even having reference types at that point?

IMHO Rust's lifetime analysis should consider borrows only at the point of dereference, not just whenever you encounter an & symbol. They already do that with raw pointers - you can have as many pointers as you want but you only need to mark `unsafe` if you actually dereference one. So at least someone on the team knows how to make that work functionally.

This has been kicking my ass lately as I am trying to build a generic GL abstraction over the past year or so. OpenGL is in such an odd state that the actual graphics hardware hasn’t changed significantly in a decade or more, but the API certainly has grown to be more elegant. OpenGL 2-3 had a nice way of doing things, 3.3-4.1 is a weird and inconsistent API, and 4.3+ is nice again. But good luck finding support for 4.1+ anywhere. Not on macs, not on old cards, not on web, not on mobile.

So in 3.3-4.1 land, you get to do the exact same things you’d do in 4.3 land, but in more tedious ways programmatically, because the drivers and implementations decide how elegant you are able to make your code and abstractions. The commands that end up on the GPU are the exact same regardless but the developer experience is highly variable.

My point is GL versions do not delineate features nor performance enhancements past a certain point, they delineate periods of programmer happiness. It is solely up to the drivers, not the hardware, not the actual machinery, to determine this metric. GL, being a standard rather than an implementation, suffers for this. I happily await webgpu finalization.

Let's try an analogy - you dole out the whatever thousands of dollars it takes to buy a robot from whatever engineering company you fancy, including all the parts, labor, rare earth metals, venture capital interests, and whatever else went in to making it, you buy the whole damn thing off the shelf. If you then go and make it make mud pies, that's your problem. Furthermore, if the robot doesn't perform as adequately as you want, that's also your problem. You already paid for the thing. You can't just go complain to boston dynamics and say "actually, I've personally decided this robot is worth less than I paid for it, so I'm going to take back half my money and keep the robot". That's not how it works in the market of things, but in the market of labor, it is, because workers are under threat of homelessness and starvation. Companies get the labor they can't afford anyway.

What I'm saying is that fundamentally, a human livelihood has an upfront cost and that's the cost it takes to keep a human alive. I'm not talking about what work you as a hypothetical manager end up making this hypothetical person do, or how good at it they hypothetically are, I'm talking about living human beings as they are, baseline, whether or not you consider their labor valuable or potentially valuable.

The rest of your argument hinges on this misunderstanding, willful or otherwise. You've torn apart nothing but your own strawmen. Pragmatically, I'm not even sure minimum wage is the right choice to rectify this indignity, other options range from nothing to UBI to free housing programs to guaranteed jobs to communism. I'm not commenting on which one is best, I'm commenting on the moral framework from which these ideas come from.

My argument for minimum wage has always been a philosophical one - human life and human labor has intrinsic value and any company's bill of materials ought to include labor. The 'market price' of a human life is, say, rent and food and medical bills (grossly oversimplified but the philosophical point is the same). Anything less than that is an undersell, equivalent to selling a food for less than the cost of farming it, or selling a device for less than the manufacturing cost. I.e. nonsense in the general case. Companies have been allowed to undercut worker's value for centuries under the threat of homelessness and starvation. That's not a free market. That's robbery.

Companies are the only entities we allow to just take, setting their own prices, without quarrel, because laborers don't have bargaining power when selling their labor. Hell, the interview process should be proof enough of that. Oppositionally, I believe in human dignity - I think a worker should be able to bargain. Frankly, since us regular people can't just go up to the store and say "well, I don't wanna pay full price for this item, so I'll just pay less for it - what're you gonna do about it anyway?" (we'd get arrested) I don't think a company should be able to either. When you frame it in terms of an open market, the current labor situation sounds obviously and patently absurd.

Honestly this type of workflow is what I love(d) about rails. ERB is a nice enough templating language such that most trivial functionality is pretty much HTML, but dynamic content can be added in in a php-like way. Equally 'jammable' is the server side code as well - Database is abstracted away, and all server side APIs and application code is all the same ol' Ruby. Django is similar with their own system for python, and equally easy to use. These web frameworks were exceedingly popular at one point, to the point where when node came along, along came express.js with it touted as "rails for node". But aside from rails itself, and possibly django, and php in a more minimal sense, there really isn't this kind of thing anymore? Why did we abandon it?

I guess the common criticism is "it doesn't scale" but it seemed perfectly fine for me and my needs, and countless others, right up until every major rails project on github was "last updated: 2014". Feels like the rug was pulled out from under our feet. An exodus without cause, an ark without a flood.

I find it difficult to articulate, so forgive me if I'm not getting my point across, but the gist of what I'm trying to say in that section is less about straight binary compatibility and more about API design in general, playing to the respective language's strengths. I feel like Rust encourages more "C-like" APIs, and its added features (such as memory safety) are in effect the whole running time of the program, regardless of where that memory comes from or how it's initialized. On the other hand, C++ has something of a vendor lock-in regarding how it functions - RAII, constructors, exceptions, inheritance, etc. etc. all assume you have objects with a lifecycle that starts and ends in C++, and that those objects see most of their use according to C++'s object model. All of C++'s features come together in a brilliantly harmonized way and build off each other, but, if you forgo even some of those features, you end up missing out on most of them.

C++ has a myriad of wonderful language features that exist entirely within C++ and cross no language boundaries. I really adore C++ as a language but unfortunately I find little pragmatic use for it unless I'm working 100% inside C++ and using native APIs only. If you're doing that, it's a dream. Rust, on the other hand, speaks the same ABI as C, and with serde, can read and write to most formats and/or APIs with utmost ease.

C++ I find can get a little unwieldy quite fast, but is generally easier to keep simple. It maps to higher-level concepts in easy and intuitive ways. Rust, I hate to say it, but unless you know best practices / idiomatic Rust from the start, you'll have to do a lot of refactoring as you learn the language. Some constructs simply aren't possible using safe Rust. Many embrace the limitations, many else frustrate themselves again and again until 'the Rust way' drills into their heads. But, of course, once you get a feel for it, it's pleasant to write in.

How much difficulty you'll have with Rust or C++ depends on what problems you try to solve, and what your approach to programming is generally. If you're more of a pragmatic "I write simple programs that actually do things" I don't think you'll have any problems with Rust. It's very straightforward. And the tooling is second-to-none. If you like to partake in exploratory programming, trying out different theoretical models and different abstractions, C++ caters to that by allowing you to write more elegant designs than in Rust, with the downside that it also lets you make worse mistakes.

The wider cross-language library ecosystem is mostly C-based I've found, so, in C++ you can just use those libraries directly with no hassle (the only hassle being the build system, or lack thereof). Rust can use those libraries as well (as long as you don't have a gut-reaction "ew" to using `unsafe` everywhere) but unfortunately the safe and idiomatic Rust library ecosystem is kind of on the bleeding edge at the moment. Hopefully things will stable out soon, and all these hip new technologies will come to fruition, but that day is not today.

I know this isn't really nudging in one way or another but really it comes down to what you value in a language and what projects you want to see through using these technologies that will determine which one you like better. Have fun!

My only contention with Optional<T> types as opposed to NULL/nil/null is that in practice they're almost useless. An Optional<T&> is a pointer, plain and simple. If NULL is one of the expected values, it should be handled as expected. This leads to a vast simplification of a number of algorithms and data structures and no need for `.unwrap().unwrap().excpect("unreachable")` in the cases you can't do anything anyway. I've rarely seen cases where null values were possible at the algorithmic level, and expected, and not handled, because, lazy programmers I guess? Honestly all I can say for that particular case is that if you write half an algorithm, expect it to fail half the time...

On the other hand, if NULL is not an expected value, then how often do you really find the logic error at the same spot that the panic occurred? Not very often in my experience. We have callstacks for a reason. You usually find the NullPointerException at the bottom of the stacktrace or the None.panic() after 100-something other function calls in significantly complex codebases. No, if a function expects a value 100% of the time, and it was passed a NULL value, that's the caller's problem. And Option<T> won't help you if the user-facing calling code is still passing None or std::nullopt for whatever misguided or erroneous reason they may be doing so.

Certainly I agree there're benefits to encoding this kind of behaviour into the type system, but I don't agree that it's ultimately a solution to the '4 billion dollar mistake', since mistakes ultimately still happen. You just swap NULL for None and you still have a bug in your logic, just no longer a bug in the types. It's kicking the can.

What does one have to do to get as clear and pretty of a UI as that on the modern desktop OSes? Everyone switched from bitmaps to vectors over a decade ago and now everything is fuzzy, antialiased, scalable, flat, hard to make out.

Of course you can always run dwm on linux with a hodgepodge of makeshift utility apps, write your own keybinds to set your brightness and volume and other such inanities, but in order to get a 'complete' desktop experience you kinda have to opt-in to GNOME/KDE which are trying to do the same things as Apple or Microsoft, aesthetically speaking. And tough luck if you actually use Apple or Microsoft to begin with. I tried running bug.n and it seems to not work in win10, let alone win11.

This article is chock full of cynicism with no actual factual reasoning. Deeply reactionary and without any actual point. A polemic, at best. Need I count the number of references to tumblr, tiktok, social media memes, dyed-hair left-leaning millennials with quirky personalities? All that self-victimization, which is all for the purpose of, let me guess, attention? You're the one writing articles on the internet, my man.

The best evidence this article can come up with is equally polemic articles and a hand-picked troupe of social media teens. Selection bias at its finest.

Is this as tiring for anyone else as it is for me?

Note the top comments saying the same things about homosexuality and transgenderism, of course.

The thing about DID and IFS is the underlying recognition that most people have parts, sometimes dissociated (as is the case with BPD, for example, and other dissociative disorders), and that this is part of normal human psychology. The crux of it is that this is simply one of the fundamental tools our brains has to use in response to trauma. The whole disorder part of dissociative identity disorder is when it becomes a problem that impedes healthy functioning. Just like we all have anxiety, it's there to protect us and warn us of potential dangers, but an anxiety disorder is when the anxiety is no longer helpful, damaging, even.

I think this is what a lot of people mean when they say that FOSS (and Open Source in general) 'lost' in the grand scheme of things. Sure, FOSS is running the entire show from sites to servers to databases to build systems to programming languages, but, whether or not you can actually see the code seems to hold little sway when the war is really over personal data and privacy. Who cares if I can see the tensorflow source code when the real danger is in the models these companies are building, which themselves are aggregated of petabytes of 'anonymous' user data. You'd have to open-source the data, too, to see how these businesses are truly run.

> This is a red flag for your complains: Is VERY likely you believe Rust is wrong, when the fact the problem is that your code is not good.

I'm gonna be blunt: This is the worst thing to come out of the Rust community, bar none. Rust is a fine language and I love to write in it, but I loathe the way Rust developers have convinced themselves that Rust is an axiomatically 'better' language and that the things you can't do in Rust, or the things that are painful to do in Rust, are a perfect circle venn-diagram overlap with the things that are just bad to do in general. It's a mindset that shuts down discussion and constantly shifts goalposts. It doesn't help anyone.

Why do these types of comments come up in every thread about C++? Sometimes people who like C++ just want to talk about C++ on the internet. It doesn't have to be for everybody.