GNU's not Unix image manipulation program toolkit.

WSL 3 wishlist starts here

I wrote a rule engine for processing data called ORE - ORE Rule Engine I wanted to call it Odoyle Rules Engine. It had a QueryTracker, that had a RulesAppliedQueue aka a QT with a RAQ. This is what happens when you have 4 friends from college working in a 4 pack office.

It’s a cheeky play on “WINdows Emulator” as well as “WINE’s Is Not an Emulator”, but I think for both legal (trademark) and logistical (it really isn’t an emulator) reasons, you’ll never officially see that bit sanctioned

Pine was already taken by an email reader. One of the early ascii email readers was called elm, for ELectronic Mail. Pine was made after elm and it stands for Pine Is Not Elm.

Eight Megabytes And Constantly Swapping

Vim is the new "I use Arch btw"

My favorite is the scanning device interface driver protocol.

TWAIN

Technology Without An Interesting Name

Well looks like I finally found a cheat engine equivalent for Linux

But I thought LAME Ain't an MP3 Encoder?!

Actually I never got that. WINE isn't an emulator, but LAME very much is an MP3 encoder

Not really. It is just translating the Windows system API calls into Linux system API calls. It's not emulating Windows, it's an entirely different implementation that doesn't necessarily match that of Microsoft's implementation. It had it own workarounds to make buggy code work.

You wouldn't call a Java Virtual Machine an emulator of another JVM either, they're just different implementations of the same specification.

WINE Is No Emulator

Internal errors - invalid parameters received

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?