My personal favorite acronym like that definitely goes to AROS (Amiga Research Operating System) that if I remember correctly had to - for legal reasons - change the name. Rather than come up with a completely new name, went with AROS Research Operating System.
Edit: name change was apparently to avoid any trademark issues with the Amiga name.
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.
My favorite software acronym is PINCE, the reverse engineering tool that's similar to Cheat Engine in Winblols, that stands for PINCE Is Not Cheat Engine.
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.
It's time [to] explain the meaning of "Hurd". "Hurd" stands for "Hird of Unix-Replacing Daemons". And, then, "Hird" stands for "Hurd of Interfaces Representing Depth". We have here, to my knowledge, the first software to be named by a pair of mutually recursive acronyms.
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.
Thing is, I do kind of think of a JVM as an emulator for a processor that doesn't exist.
WINE kind of blurs the line of a traditional emulator by having the executable run natively on the target machine's CPU, but everything it does in regards to dealing with the host OS, the display, disk access, etc, is emulated as far as I'm aware.
A theoretical PS4 or Xbox One emulator running on x86 hardware could be just as much of an emulator as WINE is.
Yes but an emulator emulates both the CPU and GPU of the consoles and in the case of PS4 even thought the CPU is x86 the biggest difference I can think of is the GPU drivers.
Maybe depending on how far you take it. A CPU instruction is different from hardware to hardware, but a function signature would stay the same no matter the underlying architecture. If we want to go through that logic then an interpreter can be thought of as a form of emulator.
True is not cause it not emulating CPU/GPU of a different device, is more like a translator of sorts as it translates windows modules like directx and stuff in a way that Linux can interpret them and use them!
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).
You're pretty much right on the money. In Haskell, a String is a type synonym for [Char], so we can use the list concatenation function ++ to join strings. ++ 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). When we do (++ "a"), we create a partially applied function. Now, we can supply another string to it and it will add "a" at the end of it.
iterate f x produces a lazily evaluated sequence [x, f x, f f x, ...]. So, to get the nth entry, we can do wine !! n where we use another infix function !!. With partial application, we can modify the definition of wine to create a function that takes an Int n and spits out the nth entry of it by doing
wine = (!!) $ iterate (++" Is Not an Emulator") "WINE"
We needed to wrap the !! inside parentheses because it's an infix function. $ just changes the order of application. (IIRC, it's the least significant function.) You can think that we're wrapping whatever's on the right of the $ by parentheses. Now we can do wine 2 instead of wine !! 2 to get "WINE Is Not an Emulator Is Not an Emulator".
I'm by no means a Haskell expert. (I'm not even a professional programmer lol.) So, if someone would like to add some more details, they're more than welcome.
Edit: A much more readable version might be
wine 0 = "WINE"
wine n = wine (n-1) ++ " Is Not an Emulator"
[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.
(It accomplishes this by "cheating" and turning on a feature only found in Apple Silicon that make concurrent memory access rules more similar to x86, but still)
Qemu is an emulator designed to allow you to run software for one architecture on another, much like Rosetta does. Qemu has gained the ability to run native virtual machines using hardware virtualization, which it does astonishingly well, but its original purpose is emulation. In terms of quickness, though, more modern offerings run circles around it
Do you have benchmarks to confirm that hardware accelerated virtualization on qemu is slow? It is what powers a lot of things including hypervisors like Proxmox. It also supports hyper-v acceleration. As far as Apple is concerned no one is really running a Mac so that isn't a useful comparison.
I didn't say hardware accelerated virtualization on qemu was slow. In fact, it's one of the best performing hypervisors out there. When used as an emulator, however, its performance leaves something to be desired.
GNU's Not Unix! moment
GNU's not Unix image manipulation program toolkit.
RecursionError: Maximum recursion depth exceeded image manipulation toolkit
I haven't really done much recursion in Python, but can't we do a tail-recursive version so that it (almost) never reaches recursion depth issues?
We cannot, Python explicitly doesn't do TCO.
http://neopythonic.blogspot.com/2009/04/tail-recursion-elimination.html?m=1
Is there a separate RecursionError in modern versions of Python? Been a couple years but I remember it just being a RuntimeError
Lol Edit: TIL that's what GTK stands for
GNU's not Unix image manipulation program toolkit public license
Windows should emulate Linux so it can run wine on its arm chips.
WSL 3 wishlist starts here
I refuse to use 2 because it breaks all my shit.
OG WSL 1 for me, or just Linux lol
Qemu if you can get it. It is a little hard to learn but it can use Hyper-V acceleration
It's harder to set up windows without giving microsoft the right to let 72 virgins rape your ass than to use QEMU.
Honestly, yes
My personal favorite acronym like that definitely goes to AROS (Amiga Research Operating System) that if I remember correctly had to - for legal reasons - change the name. Rather than come up with a completely new name, went with AROS Research Operating System.
Edit: name change was apparently to avoid any trademark issues with the Amiga name.
Acorn/ARM apparently did much the same thing.
i refuse to call it advanced risc Machine, it's always Acorn Risc Machine
GTK = GNU's Not Unix Image Manipulation Program Tool Kit
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.
my favorite fact about Wine is that they could've named it Pine, Dine, Fine, Line, etc
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
It's not an emulator though. That's literally what the name is explaining!
It does emulate the windows environment
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.
I'm starting to get the impression that most software older than me is defined more by what it isn't than by what it is.
EMACS makes all coding suck
VIM is marvelous
Eight Megabytes And Constantly Swapping
That joke has aged like milk
Vim is the new "I use Arch btw"
NEW?
I guess? Because I'm new to Linux
I can bet the Emacs/Vim war has been raging for longer than you have been alive.
Well, it was either that or "I've been using Unix for so long that my first text editor was ed".
Emacs is older than ed
Didn't ed released in 69 and Emacs is in 85?
73 and 76, but I got them mixed up, ed is older.
That's for original Emacs though, the gnu version came out in 85
You could argue that maybe Helix is.
New?
My favorite software acronym is PINCE, the reverse engineering tool that's similar to Cheat Engine in Winblols, that stands for PINCE Is Not Cheat Engine.
My favorite is the scanning device interface driver protocol.
TWAIN
Technology Without An Interesting Name
I really wanted this to be true but according to Wikipedia that’s an unofficial backronym. :( Sorry to be Debbie Downer.
Get outta here with your facts! /s
I'm partial to a good TLA (three letter acronym) myself.
Well looks like I finally found a cheat engine equivalent for Linux
Sadly not, Cheat Engine has a whole lot more features. PINCE is still very good though
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.
You can wine about it all day - it still isn't an emulator.
Some day when x86 is a thing no one has anymore, they're going to put x86 emulation in wine and then it'll actually be an emulator.
Well then, I guess our ideology doesn't translate into the same meaning.
Well that's LAME
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
Next you're going to tell me the People's Republic of North Korea isnt a Republic?
well it sure as hell ain’t the people’s
"The Democratic People's Republic of Korea is neither Democratic, nor the people's, nor a republic."
GNU Hurd.
– Thomas (then Michael) Bushnell
And then they slapped the GNU's not UNIX infront for good measure
LoL I guess acronyms that repeat on itself are a common thing in Linux
A Criminal Regiment Of Nasty Young Men
It kind of is though.
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.
Thing is, I do kind of think of a JVM as an emulator for a processor that doesn't exist.
WINE kind of blurs the line of a traditional emulator by having the executable run natively on the target machine's CPU, but everything it does in regards to dealing with the host OS, the display, disk access, etc, is emulated as far as I'm aware.
A theoretical PS4 or Xbox One emulator running on x86 hardware could be just as much of an emulator as WINE is.
Yes but an emulator emulates both the CPU and GPU of the consoles and in the case of PS4 even thought the CPU is x86 the biggest difference I can think of is the GPU drivers.
Maybe depending on how far you take it. A CPU instruction is different from hardware to hardware, but a function signature would stay the same no matter the underlying architecture. If we want to go through that logic then an interpreter can be thought of as a form of emulator.
HURD moment
Yaml ain't markup language
True is not cause it not emulating CPU/GPU of a different device, is more like a translator of sorts as it translates windows modules like directx and stuff in a way that Linux can interpret them and use them!
WINaE! It bugs me that it isn't "Wine Is Not Emulation"
WINE Is No Emulator
"This is no emulator, boy. No emulator."
Of course not! It's a drink!
Sorry, I should've specified, it's in Haskell. Idk where you tried running it.
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 argapplies somefunctiontoargrepeatedly, 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++suffixto its argument (which other languages might phrase something likearg += 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
headfunction reading the first X characters from it).How far off am I? What pieces am I missing?
You're pretty much right on the money. In Haskell, a
Stringis a type synonym for[Char], so we can use the list concatenation function++to join strings.++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). When we do(++ "a"), we create a partially applied function. Now, we can supply another string to it and it will add"a"at the end of it.iterate f xproduces a lazily evaluated sequence[x, f x, f f x, ...]. So, to get the nth entry, we can dowine !! nwhere we use another infix function!!. With partial application, we can modify the definition ofwineto create a function that takes anIntn and spits out the nth entry of it by doingWe needed to wrap the
!!inside parentheses because it's an infix function.$just changes the order of application. (IIRC, it's the least significant function.) You can think that we're wrapping whatever's on the right of the$by parentheses. Now we can dowine 2instead ofwine !! 2to get"WINE Is Not an Emulator Is Not an Emulator".I'm by no means a Haskell expert. (I'm not even a professional programmer lol.) So, if someone would like to add some more details, they're more than welcome.
Edit: A much more readable version might be
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
partialfills the arguments from the left, so to add a suffix, I'd have to use a reversedstrfunction. 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").iterateworks 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.
When it bears repeating, let's make it recursive.
PHP Hypertext Protocol
I've always thought of this
Qemu?
Quick Emulator
(At least it was when it was written. Rosetta blows it out of the water.)
What is Rosetta?
Apple's x86->ARM transpiler
(It accomplishes this by "cheating" and turning on a feature only found in Apple Silicon that make concurrent memory access rules more similar to x86, but still)
How does that apply to qemu?
Qemu is an emulator designed to allow you to run software for one architecture on another, much like Rosetta does. Qemu has gained the ability to run native virtual machines using hardware virtualization, which it does astonishingly well, but its original purpose is emulation. In terms of quickness, though, more modern offerings run circles around it
Do you have benchmarks to confirm that hardware accelerated virtualization on qemu is slow? It is what powers a lot of things including hypervisors like Proxmox. It also supports hyper-v acceleration. As far as Apple is concerned no one is really running a Mac so that isn't a useful comparison.
I didn't say hardware accelerated virtualization on qemu was slow. In fact, it's one of the best performing hypervisors out there. When used as an emulator, however, its performance leaves something to be desired.