• 0 Posts
  • 19 Comments
Joined 5 months ago
cake
Cake day: May 7th, 2024

help-circle





  • [The list concatenation function] ++ is an infix function i.e. [1,2,3] ++ [3,4,5] = [1,2,3,3,4,5] (which will be equivalent to doing (++) [1,2,3] [3,4,5] by virtue of how infix functions work in Haskell).

    I think that’s the part I was most confused by. I’m coming mostly from Java and C, where ++ would be the unary operator to increment a number. I would have expected that symbol in a functional language context to be a shorthand for + 1. The idea of it being an infix function didn’t occur to me.

    Partial applications I remember from a class on Clojure I took years ago, but as far as I remember, the functions always had to come first in any given expression. Also, I believe partial fills the arguments from the left, so to add a suffix, I’d have to use a reversed str function. At that point, it would probably be more idiomatic to just create an inline function to suffix it. So if my distant recollection doesn’t fail me, the Clojure equivalent of that partial function would be #(str % " Is Not an Emulator").

    iterate works the same though, I think, so the whole expression would be (def wine (iterate #(str % " Is Not an Emulator") "WINE") )

    This code was typed on a mobile phone in a quick break based off of years-old memories, so there might be errors, and given it was a single class without ever actually applying it to any problems, I have no real sense for how idiomatic it really is. I’ll gladly take any corrections.

    NGL though, that last, readable version is sexy as hell.


  • Game Conqueror also works, but is missing a lot of features too from what I can tell. Don’t know how it holds up against PINCE.

    I’ve had success getting CE to run with Proton though, specifically by using SteamTinkerLaunch to run it as additional custom command with the game. There are other ways too, like protontricks. In my experience, it has been mostly stable, with the occasional freeze, but generally usable for pointer scanning and such.


  • I’ve never worked with Haskell, but I’ve been meaning to expand my programming repertoire (particularly since I don’t get to do much coding at work, let alone learn new languages) and this makes for a nice opportunity, so I wanna try to parse this / guess at the syntax.

    I assume iterate function arg applies some function to arg repeatedly, presumably until some exit condition is met? Or does it simply create an infinite, lazily evaluated sequence?

    ( ) would be an inline function definition then, in this case returning the result of applying ++suffix to its argument (which other languages might phrase something like arg += suffix), thereby appending " Is Not an Emulator" to the function argument, which is initially “WINE”.

    So as a result, the code would produce an infinite recurring “WINE Is Not an Emulator Is Not an Emulator…” string. If evaluated eagerly, it would result in an OOM error (with tail recursion) or a stack overflow (without). If evaluated lazily, it would produce a lazy string, evaluated only as far as it is queried (by some equivalent of a head function reading the first X characters from it).

    How far off am I? What pieces am I missing?





  • If it’s real, I’m confident he had some competent assistant hire a competent crew for that photo-op. I’m guessing a competent PR consultant suggested a good photo-op in the first place, hit the right buttons to appeal to his wannabe cool image.

    If it’s fake, some competent developer created a good tool, fed with competently selected data to create a rather convincing image.

    What I’m trying to say is that there most certainly were several competent people involved in the making of this picture.

    Just not the subject.




  • Both Medieval Europe and Antiquity were defined by wealthy landowners and poor workers. We don’t always see a whole lot of that in the writings that have survived until our time, but that doesn’t mean they didn’t exist.

    Most of the ancient sources we have were written by people with the both leisure to learn, travel around and write stuff down and the connections to have their writings be considered worth duplicating and preserving. In a word: the elites.

    The issue here is that the poor and destitute didn’t exist in a vacuum just because resources were scarce. Even in bad years for the peasantry, the elites generally did fine.

    These ancient sources don’t always spell that out, because it isn’t worth spelling out to them: this is just how they and their peers live. Most of these elite members owned property or the workshop and tools with which their workers labored.

    By and large, they were rich. Whether that richness is defined in numbers on some net worth estimate or just in the amount of things they owned, the result is the same.

    And even in Ancient Greece, the rich had to make some contributions back to the community (except for Sparta, but they’re a whole different beast of exploitation). Philanthropy has its roots there, even if it is a far cry from what we would term Philantropy today: The wealthy either voluntarily or out of obligation funded buildings, artworks etc. for the general public.

    What changed with Industrial Capitalism and later Globalisation was mostly the scale of exploitation. But the principle - an owner class exploiting a labour class - has been around forever.




  • I had my start with Python, albeit as a kid and I didn’t actually understand too much about the principles at the time. Still, I think that was a good place to start learning about the concepts of instructions and variables.

    I learned more about the ideas underpinning it all later, and most of my understanding came when actually working in software development on a live and in-development codebase. I think that’s a good progression: start small, then learn some theory just so you’ve heard the terms once, then try to make sense of actual code using that.

    Edit: definitely work on some goal though. Don’t code in a vacuum, think of something small you want to achieve and learn to do that.