| |
| ▲ | bityard 2 days ago | parent | next [-] | | There is LOADS of gray area, overlap, and room for one's own philosophical interpretation... But typically simulators attempt to reproduce the details of how a particular machine worked for academic or engineering purposes, while emulators are concerned mainly with only getting the desired output. (Everything else being an implementation detail.) E.g. since the MAME project considers itself living documentation of arcade hardware, it would be more properly classified as a simulator. While the goal of most other video game emulators is just to play the games. | | |
| ▲ | Imustaskforhelp 2 days ago | parent | next [-] | | I don't want to offend you , but this has made me even wonder more what the difference is. It just feels that one is emulator if its philosophy is "it just works"
and simulator if "well sit down kids I am going to give you proper documentation and how it was built back in my days" but I wonder what that means for programs themselves... I wonder if simulator==emulator is more truer than what javascript true conditions allow. | | | |
| ▲ | 2 days ago | parent | prev | next [-] | | [deleted] | |
| ▲ | anthk 2 days ago | parent | prev [-] | | Not the case at all. Tons of emulators are near 100% accurate. | | |
| ▲ | Brian_K_White 2 days ago | parent | next [-] | | Irrelevant to the concept being expressed, and does not invalidate. The goals merely overlap, which is obvious. Equally obviously, if two goals are similar, then the implimentations of some way to attain those goals may equally have some overlap, maybe even a lot of overlap. And yet the goals are different, and it is useful to have words that express aspects of things that aren't apparent from merely the final object. A decorative brick and a structural brick may both be the same physical brick, yet if the goals are different then any similarity in the implimentation is just a coincidense. It would not be true to say that the definition of a decorative brick includes the materials and manufacturing steps and final physical properties of a structural brick. The definition of a decorative brick is to create a certain appearance, by any means you want, and it just so happens that maybe the simplest way to make a wall that looks like a brick wall, is to build an actual brick wall. If only they had tried to make it clear that there is overlap and the definitions are grey and fuzzy and open to personal philosophic interpretation and the one thing can often look and smell and taste almost the same as the other thing, if only they had said anything at all about that, it might have headed off such a pointless confusion... | |
| ▲ | bityard 2 days ago | parent | prev | next [-] | | Huh? I didn't mention anything about accuracy. And "accuracy" (an overloaded and ill-defined term on its own) doesn't have anything to do with the differences between simulators and emulators. | |
| ▲ | Imustaskforhelp 2 days ago | parent | prev [-] | | exactly. makes you wonder , is it all just philosophical. Calling the same thing a different name. |
|
| |
| ▲ | o11c 2 days ago | parent | prev | next [-] | | In theory, an emulator is oriented around producing a result (this may mean making acceptable compromises), whereas a simulator is oriented around inspection of state (this usually means being exact). In practice the terms are often conflated. | | |
| ▲ | codr7 2 days ago | parent | next [-] | | The difference is about as crystal clear as compiler/interpreter. | | |
| ▲ | Imustaskforhelp 2 days ago | parent [-] | | compiler creates a binary in elf format or other format which can be run given a shared object exists. Intepreter either writes it in bytecode and then executes the bytecode line by line ? Atleast that is what I believe the difference is , care to elaborate , is there some hidden joke of compiler vs intepreter that I don't know about ? | | |
| ▲ | dpassens 2 days ago | parent | next [-] | | I assume GP meant that a lot of compilers also interpret and interpreters also compile. For compilers, constant folding is a pretty obvious optimization. Instead of compiling constant expressions, like 1+2, to code that evaluates those expressions, the compiler can already evaluate it itself and just produce the final result, in this case 3. Then, some language features require compilers to perform some interpretation, either explicitly like C++'s constexpr, or implicitly, like type checking. Likewise, interpreters can do some compilation. You already mentioned bytecode. Producing the bytecode is a form of compilation. Incidentally, you can skip the bytecode and interpret a program by, for example, walking its abstract syntax tree. Also, compilers don't necessarily create binaries that are immediately runnable. Java's compiler, for example, produces JVM bytecode, which requires a JVM to be run. And TypeScript's compiler outputs JavaScript. | | |
| ▲ | Imustaskforhelp 2 days ago | parent | next [-] | | Then what is the difference, I always thought of Java as closer to python in the sense that it's running the byte code. And python also has bytecode. I don't know what the difference is , I know there can be intepreters of compilers but generally speaking it's hard to find compilers of intepreters Eg C++ has compilers , intepreters both (cpi) , gcc Js doesn't have compilers IIRC , it can have transpilers
Js2c is good one but i am not sure if they are failsafe (70% ready) , I also have to thank you , this is a great comment | | |
| ▲ | o11c 2 days ago | parent | next [-] | | Programming languages mostly occupy a 4-dimensional space at runtime. These axes are actually a bit more complicated than just a line: * The first axis is static vs dynamic types. Java is mostly statically-typed (though casting remains common and generics have some awkward spots); Python is entirely dynamically-typed at runtime (external static type-checkers do not affect this). * The second axis is AOT vs JIT. Java has two phases - a trivial AOT bytecode compilation, then an incredibly advanced non-cached runtime native JIT (as opposed to the shitty tracing JIT that dynamically-typed languages have to settle for); Python traditionally has an automatically-cached barely-AOT bytecode compiler but nothing else (it has been making steps toward runtime JIT stuff, but poor decisions elsewhere limit the effectiveness). * The third axis is indirect vs inlined objects. Java and Python both force all objects to be indirect, though they differ in terms of primitives. Java has been trying to add support for value types for decades, but the implementation is badly designed; this is one place where C# is a clear winner. Java can sometimes inline stack-local objects though. * The fourth axis is deterministic memory management vs garbage collection. Java and Python both have GC, though in practice Python is semi-deterministic, and the language has a somewhat easier way to make it more deterministic (`with`, though it is subject to unfixable race conditions) I have collected a bunch more information about language implementation theory: https://gist.github.com/o11c/6b08643335388bbab0228db763f9921... | |
| ▲ | amszmidt 2 days ago | parent | prev [-] | | The easy definition is that an interpreter takes somethings and runs/executes it. A compiler takes the same thing, but produces an intermediate form (byte code, machine code, another languages sometimes called "transpilar"). That you can then pass through an interpreter of sorts. There is no difference between Java and JVM, and Python and the Python Virtual Machine, or even a C compiler targeting x86 and a x86 CPU. One might call some byte code, and the other machine code .. they do the same thing. |
| |
| ▲ | amszmidt 2 days ago | parent | prev | next [-] | | While an interpreter can do optimizations, they do not produce "byte code" -- by that time they are compilers! As for the comparison with the JVM .. compare to a compiler that produces x86 code, it cannot be run without an x86 machine. You need a machine to run something, be it virtual or not. | |
| ▲ | codr7 2 days ago | parent | prev [-] | | Thank you! |
| |
| ▲ | somat 2 days ago | parent | prev | next [-] | | I would generalize it to a compiler produces some sort of artifact that is intended to later be used directly, while for an interpreter the whole mechanism(source to execution) is intended to be used directly. The same tool can often be used to do both. trival example: a web browser. save your web page as a pdf? compiler. otherwise interpreter. but what if the code it is executing is not artisanal handcrafted js but the result of a typescript compiler? | |
| ▲ | amszmidt 2 days ago | parent | prev [-] | | An interpreter runs the code as it is being read in. A compiler processes the code and provides an intermediate result which is then "interpreted" by the machine. So to take the "writes it in byte code" -- that is a compiler. "executes the byte code" -- is the interpreter. If byte code is "machine code" or not, is really secondary. | | |
|
| |
| ▲ | ijustlovemath 2 days ago | parent | prev [-] | | Adding some anecdata, I feel like emulator is mainly used in the context of gaming, in which case they actually care a great deal about accurate reproduction (see: assembly bugs in N64 emulators that had to be reproduced in order to build TAS). I haven't seen it used much for old architectures; instead I'd call those virtual machines. definitely agree on simulator though! |
| |
| ▲ | amszmidt 2 days ago | parent | prev [-] | | I think it is more about design, emulation mimics what something does. A simulator replicates what something does. It is a tiny distinction, but generally I'd say that a simulator tries to accurately replicate what happens on an electrical level as good one can do. While an emulator just does things as a black box ... input produces the expected output using whatever. You could compare it to that an accurate simulator of a 74181 tries to do it by using AND/OR/NOT/... logic, but an emulator does it using "normal code". In HDL you have a similar situation between structural, behavioral design ... structural is generally based on much more lower level logic (eg., AND/NOR/.. gates ...), and behavioral on higher logic (addition, subtraction ...). "100%" accuracy can be achieved with both methods. |
|
