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

help-circle






  • There’s different levels of “fluency”. Roughly summing up the CEFR[1] model:

    A1: Can ask and answer simple questions
    A2: Can hold simple conversations
    B1: Can talk about interests or events
    B2: Can understand the main ideas of more complex or subject-specific texts
    C1: Can use language flexibly without much searching for expressions
    C2: Can easily speak and comprehend virtually everything in the target language

    C1 is probably what I’d consider fluency, and looking at my own peers and language, some adults don’t even fit the criteria for C2 in their own native language.

     

    CEFR doesn’t entirely map to native language development well, since it assumes fluency in the speaker’s native tongue and a certain ability to grasp more complex topics in the firsts place, where a child would still have to develop the mental faculties.

    Still, attempting to describe native language development in CERF, at age 5, children are expected to “have mastered all basic grammatical markers at this age and should be speaking in grammatically correct sentences most of the time”[2], which I would consider somewhere between A2 and B1.

     

    If the mental development for fluency in your native language are present, I do think that comprehensive immersion in a target language for five years, supported by helpful natives, can bring you a long way to fluency. The Goethe-Institute estimates that learning German will take approximately 600-750 hours[3] to reach C1, though it bases that estimate on its own dedicated language courses. Investing an average 3h of learning the language per week for five years would put you at 780. With additional support and practice outside of lessons, I think you could do with much less than that.


    [1] Wikipedia: Common European Framework of Reference for Languages, https://en.wikipedia.org/wiki/Common_European_Framework_of_Reference_for_Languages, accessed 2024-09-02
    [2] Speech and Language for Kids: 5-Year-Old Speech Checklist, https://www.speechandlanguagekids.com/what-speech-and-language-skills-should-my-5-year-old-have/, accessed 2024-09-02
    [3] Goethe-Institut: Frequently Asked Questions, Section “Our Courses”, Question “How long does it take to learn German?”, https://www.goethe.de/ins/gb/en/m/sta/lon/kur/faq.html#accordion_toggle_6206750_2, accessed 2024-09-02


  • As I’ve been told, they* tend to be more polite to you if you make an attempt at least, considering it a gesture of respect for the country you’re in. They may roll their eyes at how bad an attempt it is, but it’s still a credit.

    There is a similar phenomenon in Germany, where we may switch to English, not necessarily because we’re annoyed at your bad German, but simply because we consider it more efficient or courteous to engage with people in English. Maybe the French have similar reasons.

    I’ve caught myself in that reflex too: I learned English from the start of primary school, consume a lot of English media, speak English with international colleagues and consider myself fairly fluent. If you struggle with German, I’ll be quick to offer using a language we’re both good at because it makes things easier for you. That’s not a lack of appreciation, it’s an offer of convenience.

    On the other hand, if you wish to practice your German, I’m more than happy to help. I get the impression that many generally are willing to humour you, provided we have the time for it. If you’re ordering at a restaurant or asking for directions, odds are we’ll switch to English to speed things up. But if I have the time, I’ll gladly listen to your German and offer corrections and explanations.


    *Possibly just a specific subset of localities or businesses; I can’t give a first-hand account nor obviously make a blanket statement about a country of ~68 million people (1.66 times the population of california, for comparison).







  • [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?