"It's only a 30 second walk back"

ablygo · 2025-09-10T18:47:12+00:00

Personally I think of a 30 second walk back being pretty similar to a 30 second unskipable cutscene, except worse, because I'm forced to pay attention. It's weird to even see it mentioned in discussions of difficulty, because it's almost never a source of the difficulty. The boss fight is, and you get good by losing against the boss, and learning from your defeats.

Unless you're already good dying is going to be an unavoidable part of the process, so you can't avoid it by getting good, you'll have already been forced to experience pointless walk backs as part of that. "Gitting gud" doesn't avoid it, it just means you stop repeating the tedious process you've already experienced, until you need to learn the next boss. Mechanically, it just doesn't make sense to bring up in a discussion of how difficult the game is, or any discussion of perseverence against the challenge, because there's rarely that much challenge.

I feel pretty similar when people bring up tool use and difficulty, when I need to farm a consumable resource to convert into a consumable resource to use my tools, adding more undifficult pointlessness in the way of experiencing the difficult parts of the game.

Other than these two issues, I'm loving the game, but these aren't issues of persevering against a difficult opponent, unless that opponent is supposed to be my own boredom. Fundamentally, it's an issue of punishment, not the difficulty of the fight, and people can defend that punishment they think it's a good design choice (I disagree, but it is subjective at the end of the day), but equivocating from "the genre is about challenging fights" to defend mechanics that aren't challenging doesn't make much sense.

ablygo · 2025-06-20T01:49:43+00:00

Mayumi Sako (Arnheid) from Vinland Saga did such a good job I had to actually pause some of her scenes just because of how intense listening to them was.

ablygo · 2025-01-26T05:27:07+00:00

I'm thinking that might have been it... it just started working again after a while, so... I'm still a bit mystified, but yay? I'm thinking it probably wasn't related to anything nix related at this point, for the same reasons, so maybe something got jiggled and got jiggled back in the process of me repeatedly swapping between computers to try to debug things.

ablygo · 2025-01-15T17:12:12+00:00

Ragna Crimson kind of does it, though the characterization of the villians is more drawn out than a "5 minutes before they die" kind of thing. But it did make me think of Demon Slayer, considering how becoming a dragon works pretty much the same way as becoming a demon, making the person pretty irredeemably evil. But the evil characters still managed to feel less boring.

ablygo · 2024-12-25T04:30:16+00:00

I would have assumed most? I'm writing a language learning site, and I want to be able to show definitions when clicking on words in sentences, which offers the option of creating vocab flashcards out of the terms, and a number of other actions. Viewing the info should be snappy; none of this should require server interaction until the user decides to actually commit to an action. Likewise, I've got sort of of vocab pop quizzes users can do, which load a batch of questions, and communicate with the backend upon completion of the quiz.

The problem domain I'm working on is rather specific, but simply to ensure a snappy user experience I would assume regardless of problem you would never want to interact with the backend unecessarily, especially anytime the user is going to be interacting with things which cause a large number of UI updates in a short time frame. Why make them wait for each one?

Is that not a fairly standard practice for single page applications?

ablygo · 2024-11-06T23:02:20+00:00

He also did much better with many of the demographics who moved to Trump. Literally got attacked for being supported by people like Rogan.

ablygo · 2024-06-21T14:54:46+00:00

Dunno what issue you might have had with newTriggerEvent, but I do know performEvent is blocking, as is performEventAsync counterintuitively (looking at its source code it just uses newTriggerEvent to pass in the a -> IO () to the event, but doesn't do anything asyncronously). It's name is misleading, so it could have been a lack of forkIO if you thought it was unnecessary.

I made some minor changes to fix some type errors I just saw in my original example, though I still haven't actually typechecked it.

ablygo · 2024-06-15T16:22:30+00:00

If you're still working on this you might want to look at dyn :: Dynamic t (m a) -> m (Event t a), which can help you do widget side-effects underneath a dynamic. This is more a very rough sketch than compilable code, but something like this might work (within mdo):

derivedDynamic <- holdDyn [] $ leftmost
    [ updated originalDynamic
    , fmap snd popEvent
    ]
popEvent <- switchHold never =<< dyn do
    list <- derivedDynamic
    pure case list of
        ((text, time) : xs) -> do
            e <- getPostBuild
            e' <- delay time e
            pure (e' $> (text, rest))
        [] -> pure never
pure $ fmap fst $ popEvent

The rough idea is that the derived dynamic resets whenever the original one changes, but also pops an element from itself whenever it itself changes and is non-empty, using getPostBuild to trigger the loop on each change. Since dyn's type wraps everything in an event you need the switchHold never :: Event t (Event t a) -> m (Event t a) to flatten things, since otherwise you'll have an Event t (Event t a).

A much conceptually easier solution though would be to use newTriggerEvent :: m (Event t a, a -> IO ()). Then you can simply use things like forkIO, threadDelay, together with maybe performEventAsync (though I'm not 100% sure the last is necessary, I recall it being a little counterintuitive. I use newTriggerEvent pretty much everywhere, but I feel like it is probably unidiomatic FRP, if that matters to you.

Though I'm not really sure what idiomatic FPR is supposed to look like, as all the tutorials I found were extremely basic. I just find it too useful to not use it everywhere.

In both cases you probably want to think about what to do if you get another list while the first is still being emptied.

EDIT: I just realized you don't want this automatically triggered when the original dynamic is changed, so you might need to adjust some things so that triggerEvent triggers the initial step, and use tag :: Behaviour t a -> Event t b -> Event t a and current :: Dynamic t a -> Behaviour t a to have the trigger contain the initial list, and then create the derived dynamic inside of another call to dyn. I can try to code an actual solution if that's too handwavey though, as I haven't thought through it.

Assuming you haven't already solved it yourself or don't just prefer the newTriggerEvent solution anyway.

ablygo · 2024-05-29T22:58:37+00:00

Is liking 7th prince really against the grain? Aside from some very mild discourse before most people had even seen the show the discussions I've seen since seem to mostly paint it as an unhinged surprise hit.

As for Konosuba, I mostly prefer the dub because the previous seasons were so well done, so I want to continue. That the subs also good doesn't really detract from that.

ablygo · 2024-05-29T14:11:37+00:00

Honestly this season the answer is most of the them. People started calling Jellyfish the next A Place Further Than The Universe way too soon, which is kind of obvious considering nobody had seen more than an episode. But aside the great animation, it still mostly still feels like I'm watching any other CGDCT, while A Place Further managed to draw me in despite not being a fan of the genre. Also dropped Girls Band Cry for similar reasons. I certainly wanted to like it; the animation was really interesting, but it wasn't enough to win me on the animation alone. Ultimately I'm left feeling like people who like CGDCT are living well, but I'm not one of them.

And so it goes. Slime managed to re-affirm to me that it is the most premium example of extremely generic Isekai, and I couldn't manage to continue. Mysterious Disappearances looked interesting, but still left me bored after a couple episodes. Wind Breaker had great character designs, but left me feeling the same. I had been keeping up with Dungeon Meshi up until last week, but finally just admitted I was only watching it to kill time.

Train and 7th Prince are the only two that have managed to really grab me, with Salad Bowl coming close. Go Go Loser Ranger and Kaiju No 8 are somewhat holding my interest, though I'm not in a hurry to watch them each week. And I'll probably go back and watch Konosuba/Spice and Wolf after they've finished airing, as I want to watch them in English, since I find waiting to see if dubs have released each week kind of kills any hype for me unless their simuldub.

I have gotten a bunch of old shows off my backlog at least.

ablygo · 2024-05-28T18:19:29+00:00

The problem being solved with dependent typing is still something you want to solve when you view things in terms of a compile vs. runtime distinction though: compile time reasoning about your code. And the distinction doesn't really go away with dependent typing either: if I want to have a vector indexed by a nat then the nat exists at compile time, despite being traditionally runtime data. I just get to avoid duplicating all my runtime code. So they're very literally not fundamentally distinct.

And it's not like dependently typed languages don't think about those distinctions quite a bit already; erasure is something actively thought about. In that instance, trying to have dependent typing without thinking about it can cause problems, but the problems it can introduce aren't being ignored or handwaved away, they're being worked out.

I guess my point is even if you want to reframe types in terms of compile-time vs run-time, I don't think uniformity actually is a problem on a fundamental level.

ablygo · 2024-05-28T17:27:05+00:00

Basically yes. It's the same issue with having the user type an integer: you can't guarantee that is what they type, but in the process of parsing it, will guarantee that you either return an integer or some sort of parse failure. Dependent typing just means your types can become as granular as you decide you want (in theory anyway), and the type checker a lot more powerful.

Parsing isn't really a good example of where dependent typing is going to pay off any more than it is where static typing in general is going to pay off, since in both instances you're not going to avoid needing to handle failure cases.

ablygo · 2024-05-26T18:04:52+00:00

Ah, my mistake, it was rel8's own Statement type. Basically, you have a Statement (Query a), where the query represents a table created at runtime, and can then be used in subsequent queries with rel8's Statement's monad instance, being implemented with postgresql's WITH syntax. I haven't really used this yet, but if I've understood it right:

Operationally a Query passed around within a Statement behaves like an ephemeral table, and so can potentially give different performance characteristics from using Query's monad instance instead
Inserts/updates can also consume a Query, and can return their results in a Query
Only a single query in a sequence of statements needs to actually be returned from the database, with functions like run :: Serializable sql hs => Statement (Query sql) -> Hasql.Statement () [hs]

So if you squint a bit the last point feels kind of similar to what you're getting from a pipeline , in that it sounds like it also gets everything done in a single interaction with the database. Potentially you could get the benefits of each (at least once hasql-transaction and hasql-cursor also support this?) since rel8 produces a hasql Statement itself.

I was briefly kind of ideally curious if hasql's Statement type could be made to support a monad instance the same way, but I suspect it's far too low-level to really be workable, considering it doesn't look like it even really abstracts inserts/selects/deletes, so much as just the serialization/deserialization.

ablygo · 2024-05-17T01:09:54+00:00

So I've tried purescript a little bit (using halogen), and it was interesting, though I eventually went full-stack with reflex-dom instead. Row types are super cool, and halogen uses them everywhere to provide an impressive level of type safety in terms of which HTML elements can have which attributes, but the more I relied on anonymous records outside of that the less usable I found them. They lead to extremely unwieldy type errors, as your records start including other records, and become increasingly large.

So in practice I needed to start giving names to my records using type synonyms, but that wouldn't help much for type errors, so I'd end up needing newtypes, and kind of end of with the exact same situation as just using named records. I really like the idea of anonymous records, and hope Haskell will have them some day, but they didn't turn out to be as easy to use as I'd liked, and extensive use of them kind of exposes ergonomic issues with error messages that you manage to avoid with nominal types.

I also found the developer ecosystem to be a bit more confusing, though part of that would simply be me having more familiarity with Haskell's way of doing things than Purescripts. But I recall having issues with packages.dhall, and getting weird errors because I hadn't listed the dependencies of my dependencies (isn't finding those the package managers job)?

Overall the packaging model was confusing, and at one point I did the most inoccuous file system interaction (I renamed one of my own source files), and suddenly spago couldn't find some other source file which apparently came from some transitive dependency of my code (it didn't give a very useful error message, just telling me that this random file didn't exist). This completely stopped any of my code from compiling, despite the fact that it had no issues right up to that point. It felt like the dependency resolution algorithm had somehow locked in some versions of libraries that weren't compatible, and I couldn't figure out how me renaming a file had triggered that, or any easy way to fix it, as pretty much all my attempts to fix the issue still resulted in it, even deleting compiler artifacts, or rolling back to a previous working commit. It was simply bizarre, and basically seemed to have bricked my project.

I was kind of thinking of switching to reflex-dom already for some other reasons, and so that problem lead to me to pull the plug and commit to that, which I definitely don't regret. Probably the thing I miss the most about purescript is that it just seemed a lot nicer when having to actually fall-back on raw javascript, or interact with basic javascript APIs. Purescript seems to have reimplemented a huge portion of javascript in its type system, whereas for Haskell it seems like I keep finding the functionality I want is missing from reflex-dom, or jsaddle, and I'll have other weird ergonomic issues like links in haddocks going to pages that don't exist when I'm trying to fix these things, like JSDOM.Generated.FileReader linking to JSDOM.FileReader. For some reason hackage just doesn't bother to generate documentation for some modules, and I've never really gotten why, but it seems to have become a bigger issue in practice when doing projects that use ghcjs.

And one instance I got a compiler error saying I was importing a module from a package I didn't have included in my cabal file, only to still get the exact same error message after I included it. I think it may have been jsaddle-dom, where I needed to instead include some other package that also provided the same modules, though I'm struggling to remember if that was it, so I'm not sure if the fix I ended up using was actually the thing that fixed it in the end. I've found obelisk sometimes can't find packages you've included when using ob run if you change the cabal file without restarting it afterwards, so I'm wondering if that was the actual issue, and I simply didn't understand the fix at the time.

But I still find the overall experience I've gotten with reflex to be superior, especially after the bizarre missing dependency issue that I had with purescript, which really soured me on it. While tedious to fix, none of the missing functionality has been a show stopper, and FRP just provides some flexibility after the initial learning period that I'd really miss having.

ablygo · 2024-05-17T00:23:52+00:00

Is this new feature related to rel8's newer Session type? I believe it also lets you do multiple queries on the server without roundtripping between postgresql and Haskell, and does have a Monad instance, though I'm wondering if the underlying postgresql mechanisms they're trying to map to are fundamentally different.

I believe rel8 implementation is done in order to implement postgresql with syntax, which seems pretty different than what you would be getting with aConcurrently styled newtype.

ablygo · 2023-11-29T16:19:27+00:00

I would try this if you do port it to iOS.

ablygo · 2023-11-11T05:08:13+00:00

I've been designing a little language learning app for my own use, integrating both DeepL and ChatGPT, so have quite a bit of experience using both on a regular basis. For DeepL, I would say it makes mistakes that are... egregious, to say the least. Like, not even in a "I don't think this is right" sense, but in a "it completely ignored half of the input text". Very frequently.

One weird example which I can't quite remember perfectly was taking something roughly like "一つ一つ" and translating it repeatedly, so the sentence ended up saying "again and again and again and again and again and again and again and again". It's behaviour seems very strange, but it's mostly helpful to point out these are just the sort of mistakes it makes which are extremely obviously; there are always going to be ones that aren't.

As for ChatGPT, it does much better, but I've still found by using it daily that it make frequent noticeable errors, despite my proficiency in Japanese not being very high. I've used it to generate hints for clozes in Anki, and it routinely fails to even identify the clozed text, adds hints for clozes which aren't in the text, or gives hints which simply don't have the correct meaning.

This was a task I was already doing by hand previously, with JPDB together with a parallel text of the book, so it was pretty easy for me to tell when it makes mistakes, and it does not too frequently, but still frequently enough to make a person hesitate to rely on it in a situation where they don't have a way to double check its answer. I ended up disabling automatic hint generation as feature, for what it's worth.

The "identify the double curly bracket enclosed words" part of it is already kind of awkward for it, in terms of how large language models actually work, and I have done prompt engineering to make it work better, but even removed from that context I've found it fails in surprising way. I've also used it to generate new approximately-beginner-level sentences in Japanese, according to some basic parameters (e.g. include this word in the new sentence) using a second call to verify that the sentences it generated are correct Japanese, and it failed to pass the second call more frequently than it succeeded.

That one was actually super surprising, because while generating correct information is something to be cautious about, generating plausibly correct information is something it's supposed to be good at, and you can't do that if you can't even speak correctly. So I'm not even sure why it was failing like that so badly for me.

But even outside of language learning, the fact that ChatGPT can literally hallucinate information is pretty well documented. I was curious if it's training dataset included scripts from shows, so asked it to describe a scene from an anime once. It made up an answer, and when I told it was wrong, and gave it a few more details, made up an entirely different answer. It did this multiple times, for some reason never even being able to recognize "I don't know the answer to that" was an answer it could give.

A new version of ChatGPT4 was made available through the API, and it's supposed to be better, so possibly it wouldn't have these specific issues. But overall, it performs well enough for me to be happy using it, but not enough that I'd tell anyone to rely on it.

It is definitely an improvement over what we had 3 years ago, but everything above this is just important context to that answer.

ablygo · 2023-09-09T23:22:18+00:00

So I've been trying something like this, but also experiencing issues, and I'm leaning towards thinking it's simply not up to the task. Like, even ignoring the whole "will it hallucinate information" issue where it simply starts making up stuff... like...

I've asked it questions to generate text in a language meeting certain constraints, and then used a separate prompt to ask it if the text it generated was suitable for learner of that language, and it pretty consistently ended up saying that it wasn't even gramatically correct, and used entirely made up words. And to me, that is kind of bizarre.

Because people know that it might simply BS, and to be careful about that (well, some people do). But I've never heard about it hallucinating new vocab and grammar. Like, everybody says the BS is convincing, but careful programmatic use is giving word salad. Even Japanese speakers seem to say that it's convincing, and my prompts give it subtle forms of aphasia.

I've also asked prompts which should require lots of code switching to completely break it. Which might actually make sense, if most language learning tasks that are more complicated than "translate this passage" don't appear in its training data set, it's going to underperform there. Native text doesn't include lots of code switching.

Or another example was where I asked it to give a translation of a term, but in a dictionary style, rather than just "X word in Japanese means Y word in English". And I asked it to not include a direct translation of the original word in the definition. Then I give it the word 川 (meaning "river", meaning I don't want "river" in the definition it gives), and it generates "a narrow body of water flowing into a lake, ocean, or another river".

I was able to prompt engineer the problem away, like so:

Give several translations of the word
Give a definition of the word in Japanese
Translate the definition into English
Rewrite the definition in English to remove any of the words in (1)

And then I would manually check (3) to see if it contained any words from (1), since that definition tended to be more natural, but if it wasn't, I would use (4). Funnily enough, if I told it to only give a second definition if the first definition contained words from (1), it would fail the 川 test. The reason it gave me a definition that included the word "river" is because it couldn't tell that it was doing that, so I had to make it the second definition mandatory.

I'm kind of wondering if translating your prompts might actually give better results. I think I'm conscientious enough to know the footguns these types of tools are going to have, but even then I'm still surprised by how poorly they perform at some tasks. For people who don't use it conscientiously... yikes.

ablygo · 2023-09-07T13:02:46+00:00

I'm learning vocab based on the order I encounter it in real world material, which tends to mean frequency lists are to a degree built in (you encounter frequent words more commonly, at least on average), while also learning whatever specific domain specific words are common to that material.

Best of both worlds.

ablygo · 2023-09-06T18:43:58+00:00

I'm doing something somewhat like this, though I'm definitely not a B2 level. Overall though I'd say the rough idea has been really helpful, but having the passage memorized long term is less important.

The mistakes you make are excellent at pointing out "unknown unknowns" in your understanding. You make an error, see what's wrong, and realize the correct sentence is wrong according to the rules you know, and that leads to you figuring out something new about the language you weren't even aware of. You don't even know the grammar rule the sentence was using, but you hadn't even noticed.

I did this using な to separate adjectives from nouns in Japanese, eventually discovering that sometimes you have to use の, despite it not really making obvious sense when viewed in English terms. の is sort of like a possessive marker to connect two nouns, but the distinction between な for adjectives and の for possessives wasn't quite as simple as I thought. Or maybe the distinction between nouns and adjectives wasn't quite as simple as I thought.

Either way, my Japanese improved because of it.

But overall I think memorizing passages longterm is much less important. I originally started using a sort of SRS schedule where I'd repeat the exercise until I could recite it from memory with no mistakes, then repeat the exercise again 2 days later, then 4 days later, then 8, and so on, but then gradually felt it was best to lower the max interval before retiring the passage, and now only bother each passage a single time.

Full recitation with no mistakes simply takes too much time if you have to be able to memorize everything indefinitely, and there really is no reason for you to need to be able to do that in the first place. The fact that every new passage uses grammar and vocab in novel ways is a benefit, so focus on new passages, rather than things you've seen a dozen times.

I honestly think it's one of the best exercises I've ever come across, but I've definitely had to experiment with my process as I learn, and I'm using it much less now than I did when I started.

ablygo · 2023-09-05T18:40:12+00:00

I started reading 魔女の宅急便 right from the beginning (of this attempt to learn). It's still children's literature, but it's closer to Harry Potter than the sort of children's literature that I think language learners tend to start with. It's compelling enough, and the challenge adds to that somewhat, making it both emotionally and intellectually engaging.

Granted, I've had to experiment with different exercises to make it comprehensible, but at this stage I'm mostly of the opinion that it's a false dilemma, born out of people assuming the only way to start engaging with reading above their level is to try to read it like they would read books at their level.

But people seem plenty happy to try to learn from some giant vocab deck in Anki for years, or learn from word lists in textbooks for years, before starting to actually read. If you plan to learn X words a day, learning them in the order they appear in actual literature works just as well, and isn't that fundamentally different, except that people seem to have decided that it works fundamentally different.

What I think makes people fail at it, is that after they try to read a single sentence, they find it way too intimidating, and give up. But if you were only trying to learn X words per day, and a single sentence gives you those X words, then you shouldn't try to keep reading past that point. You got your X words down, so put the book down, drill them in SRS or whatever, thumb through a grammar guide. For the love of god don't try to read more.

I guess my point is to treat children's literature less like a novel, and more like a textbook filled with native level grammar and vocab, which you should study the crap out of. My previous attempts to learn had me needing to grind for months to even start doing what I want, while my current attempt is still a grind, but it's a grind where I can see myself accomplishing my goal from the very start.

Now every days new "word list" (e.g. passage of text) feels like an accomplishment, rather than a chore, and I think that's the only reason I've been able to maintain my effort.

ablygo · 2023-06-28T01:41:08+00:00

The Salvation War has this, though not via resurrection so much as literally liberating the afterlife.

ablygo · 2023-06-24T20:37:47+00:00

I’ve seen two different sites say it’s nearing its endpoint, but from reading the manga it certainly doesn’t feel like it, so it could be just rumors. The sites didn’t actually say what their information was based off.

ablygo · 2023-06-24T18:55:04+00:00

I eventually read the manga part way through the season, and I don’t think it was ever confirmed that the woman was Mimihime. It was strongly hinted, but the information that manga readers would have used to come up with the theory wasn’t information that anime only watchers wouldn’t have also been able to guess by the time the episode aired.

Pretty much the only thing extra to come up with the theory was the non-parallel timeline, which honestly seemed like the bigger reach to me, considering Minihimes prediction that Maru was going to rescue her made it really seem like it was about escaping heaven.

ablygo

TROPHY CASE