Write Your Own Virtual Machine (2022)
jmeiners.com
jmeiners.com
I feel like one could learn every level of computing this way- from designing a real cpu for a FPGA, to writing a simple OS and programs that run on it. This stuff is all shockingly simple if you just want it to work and don’t need all of the extra performance and security modern computing needs.
[0] https://store.steampowered.com/app/1444480/Turing_Complete/
I often feel like those who haven’t done the exercise of understanding the ISA of a “fantasy cpu” have a really hard time understanding those more advanced features.
I guess all I am saying is that learning the “fantasy cpu” still has value even if everything else in the real world is more complex.
Walking before running and all that.
It was launched with the Neo Geo, an arcade system (called MVS) with a home console counterpart (AES). Games on the Neo Geo (MVS and AES) were well received and it spawned several long-running and critically acclaimed series, mostly 2D fighters. Later, SNK released the Neo Geo CD, a more cost-effective console with games released on compact discs, which was met with limited success. A new arcade system, Hyper Neo Geo 64, was released in 1997, but it did not fare well. SNK also released a handheld console under the brand, the Neo Geo Pocket, which was quickly succeeded by the Neo Geo Pocket Color, which have been given praise despite its short lifetime.
SNK encountered various legal and financial issues resulting in a sale of the company in 2001. Despite that, the original Neo Geo arcade and console continued receiving new games under new ownership until 2004. The Neo Geo brand was revived in 2012 with the release of the Neo Geo X[1] handheld. Since then, a number of other Neo Geo products have been released based on the original Neo Geo.”
— Wikipedia
Seems to be from about 30 years ago in the 1990s.
I was easily 12 months ahead of other students in my CS education because I learned 6502 assembly in high school. I wish all CS courses started with "make a VM".
I think the hard thing to understand is that C’s pointer syntax is backwards (usage follows declaration is weird).
I also think understanding how arrays silently decay to pointers and how pointer arithmetic works in C is hard: ptr+1 is not address+1, but address+sizeof(*ptr)!
Pointers are not hard. C is just confusing, but happens to be the lingua franca for “high level” assembly.
Beginner programming languages universally (since BASIC and Pascal) were designed to hide this fact. There's nothing in a beginning Python course that explains the true nature of computers. You learn about syntax, semantics, namespaces, data structures and libraries. But there's nothing that says, "a computer is endlessly incrementing a counter and executing what it finds where the counter points". And this is probably partly because of "go-to considered harmful", which posited that a lack of control flow (which is a fundamental fact of how computers actually work) is harmful to reasoning about programs.
It's probably objectively true. But a lack of go-to also restricts people from seeing the fundamental truth of the indistinguishable nature of data and instructions in the Von Neumann architecture. Which may also make it difficult to explain GPU computing to students (because it must be understood by contrasting it with Von Neumann architecture).
A wonderfully different early CPU with plenty of existing software is the https://en.wikipedia.org/wiki/RCA_1802 which was a target of the https://en.wikipedia.org/wiki/CHIP-8 interpreter.
if you look at this from the riscv angle, moving from "u-mode only vm that doesn't use paging under the hood" to "u+s-mode vm with sv39" isn't an enormous jump in complexity imo
i think i might teach it starting as like, "sv21" (page tables aren't nested), then pose real sv39 and the tree structure as the solution to making a sparse mapping over 512GiB
then moving on to the idea of having a TLB is simple, especially if students have already been introduced to hashtables
https://en.wikipedia.org/wiki/Zilog_eZ80
may be the best realization. You can almost run a real operating system on that chip in the sense of a 24 bit supervisor that could run multiple 16 bit processes (if you could get CP/M to run you have one heck of a userspace) Unfortunately you can't trap the instruction that switches back to 24 bit mode.
Would be nice too if a 24 bit supervisor could contain a 24 bit application, that requires some kind of memory management and I'd imagine something a little lighter weight than the usual paging system, say something that maps (0..N) in logical space to (i+0..i+N) in physical address space. I like the "access register" concept
https://en.wikipedia.org/wiki/Access_register
but would probably have a small number of memory banks such as 16 or 64. In a load-store architecture it doesn't seem like much of a burden to add a bank id to stores and loads. In return you get not just more RAM but also separation of code and data, video memory, file mmap(ing) and such.
What bugs me is how to control the mapping of memory banks to physical memory, on one hand you want the supervisor in charge so it can be used for memory protection, on the other hand some programming techniques would want the speed of changing the memory banks from user space.
The 80286 was a turkey because it didn't meet the minimal viable product level of being a target for a 24-bit OS that could virtualize DOS applications. It was already crazy fast and became affordable pretty quickly but it seemed tragic that it couldn't do that.
That's mainly because it was designed before the IBM PC was a success and backwards compatibility with DOS applications important.
If OS fully utilizes memory segmentation it can be the most secure OS and makes borrow checker languages like Rust becomes unnecessary since not unlike Rust it can mitigates data races and race conditions (better at the latter).
This can considerably reduce developers' cognitive load or overload [1]. It also can contribute towards more secure computing and containers can be made as secure as VMs.
Someone can probably propose a new memory segmentation extension to the Linux kernel in the similar manner of real-time Linux. But again it can takes 20 years to be accepted into the mainline Linux kernel [2].
[1] Cognitive load is what matters:
https://news.ycombinator.com/item?id=42489645
[2] 20 years later, real-time Linux makes it to the kernel:
One of the assignments was to do a simple multiply (i.e. add in a loop).
Rather than do that, my friend simply altered the program and created a new MUL command.
The teacher was not amused.
My first 360 assembler class our first assignment: add two numbers, fault, print the crashdump and circle the answer to the ADD in the printout.
I wrote an RPN calculator, had it do a series of calculations and print the result. Turned that in.
The teacher wrote on it "You have 24 hours to turn in the required assignment"
From the instructor's perspective, it sounds like you didn't even try to do the intentional assignment (which the fault/crashdump/find info in the crashdump was the most important part), and either did your own thing or sent in someone else's assignment because you didn't look closely enough at what it was. Yes, this is a big accusation, but it happens every semester.
The professor just wanted you to learn what you were supposed to from the assignment, so that you could build off it.
Your cynical take on it now shows that you still don't understand how to teach or the importance of that fundamental skill.
Is there a place for fun, exploratory projects? Of course, and I always incorporated them into my syllabus. But there's also a place for structure. If you want to explore along the way, then that is even better! But you still have to meet the incremental checkpoints along the way, otherwise you have not demonstrated that you have met the core competencies of the subject, as reflected by your grade.
There's a lot of shortcomings in modern university education, but I loved teaching, and would still be doing it today if it paid reasonably. My biggest headaches were the cheaters and the know-it-alls, mostly because neither of them knew enough to respect the subject matter and its importance. The students that made me the most proud, though, were those that trusted the roadmap, and in the end were able to do bigger and better things than they thought that they were capable of.
It's not about extra work. We did plenty of it, btw. We just didn't always tell you about it. The University system referrs to it as "service", and you, the student, are the beneficiary of it, either directly or indirectly.
"Teachers don't want extra work." I'm sorry, but this sounds like a toddler stomping their foot and saying "Mommy and Daddy don't love me because they went to work today instead of staying home to play with me."
I'm glad that you wrote the RPN calculator. That's cool! I'm disappointed that you use this as an opportunity to bash the educator who agreed to take a low salary so that they could help you learn important things that are fundamental to your craft and chosen field of study.
IT need innovation. As you are not just building systems or maintaining one, you need to people think beyond what is assigned. As most likely it is this innovation drive us.
Not rule followers. Obviously we need those as well. But a few rule breaker does not kill you.
Unless he goes all the way to say to the whole class not to be rule followers. That is revolution. ... I may still with him but I would understand then you fail him. But if just one ... why not accept computer or IT guys has exception. After all are we in hacker news. Do you have all those rule followers are reading these!
Yes, it is sad that people of my "kind" "exist as professor." I helped students start a business. I started a makerspace for them so they could explore the world of 3d printing, arduinos, etc. I guided them build projects that were worthy of showing off on their resume (which resulted in some getting jobs). I was proud of the cool things that they did, and I worked with those who had difficulty. I was just so horrible!
Actually, my students quite liked me, and I was often forgiving if a student came and talked to me... after all, that's part of their learning process. Either the student cared or they didn't. I made it clear from the beginning that I cared about them, even when I had a class of 165 in the middle of Covid.
Do you actually understand what a diploma represents? It is a certification of knowledge (binary in nature... you either have one or you don't, so it is by definition a very coarse measure). A grade (or GPA) is a one-dimensional measurement of that certification. That is what your tuition is paying for. It is paying for someone who is qualified to teach you something and then evaluate you on the standard to which everyone else from that institution is also held. It is also a ranking against their peers (which is a reason that I had no patience for cheaters, which I found some every semester). As an aside, this is why a course transferred from one institution to another will often not be included in the GPA of the later institution, because it is not the same standard.
In education, you need both structure as well as innovation. I taught both. You seem stuck on the "rule follower" and "rule breaker" mentality, but that is completely orthogonal to what I am saying. I taught mastery. Whether you follow or don't follow the rules (however you define "rules") you must still master your craft, and the university exists to certify that mastery. That is the point of the university. Certification of mastery.
If you don't want certification, then don't go to a university. You aren't required to get a degree. You can learn everything that you need to from books and other places. But if you want certification of your knowledge, then you have to actually go through the steps that verifies your knowledge and ability, as determined by other people from a variety of backgrounds who have each had their knowledge and ability certified by even more people from a variety.... you get the idea. That is what a university is.
Consider the similarity with the martial arts world. You can buy a black belt online, but do you have mastery? Someone would ask how you got it. Who considered you worthy of posessing the black belt? You might say "it doesn't matter... I can fight and win!" You might be right. But the black belt isn't about fighting. It's about self-discipline, philosophy, experience, and yes, mastery, as learned from and evaluated by someone else who has an applicable certification.
I have a Ph.D. in Computer Science from the University of Notre Dame, an R1 research university, as conferred by a panel of experts from a variety of universities (meaning faculty from other universities, not just Notre Dame itself) based on my academic achievement in the field of Computer Science, peer-reviewed conference and journal publications in the field of Computer Science, as well as my creation of a peer-reviewed, published, and publicly-defended dissertation over graph grammars (blending formal language grammars and graph theory). That is my certification. Every grade that I gave derived its credibility from that certification, and was my communication to the world of my assessment of the mastery of that student to the expectations of the university, me, and their relation to their peer group (you've heard of a grade curve, right?). That's the way it works.
You are not requrired to take part in it, but just don't treat it like sour grapes (from Aesop's Fables, it might be an obscure reference).
I understand that it's a sensitive subject, students that stray from the boundaries of the lesson plan, so often to no good effect. Making work for an overworked teacher, I have complete sympathy.
But understand that there's also room for the teacher that doesn't stomp their own foot and petulantly demand every student stay in the herd like good little scholars.
Maybe even encourage exceptional students, maybe suggest something more appropriate for them, another class perhaps. But no, that certainly didn't happen, just the deliberate ignoring of the effort spent, because it didn't serve their tiny objective.
Just that one weary, autocratic bland statement, telegraphing as sure as a digital signal "I am the teacher, and you will not do anything I don't sanction, like learning way more than I demand for today's lesson"
> "I am the teacher, and you will not do anything I don't sanction, like learning way more than I demand for today's lesson"
The person explicitly made it clear that while you can be encouraged on your own initiatives you still need to be graded/ranked on a common scale with your peers and hence the need for some sort of standardization.
For example, in a recent HN discussion on "Software Developer Productivity" lots of folks were arguing on how you can have no common scale/metrics and so you can make no comparisons at all between developers which is plainly wrong.
Education is about giving everybody a minimum standard of knowledge/tools needed for the Modern World and that is what a Teacher/Professor focuses on. Every Society needs to revere/honour (and pay well !) their Teachers/Professors because they are the ones who build the next generation.
But to resort to primary-school gold stars and points and such is possibly the very worst way, the lowest common denominator of the educator's craft.
I dare say my enthusiasm was evident. Knowledge and skill were on ample display. A better educator would have responded to that, advised more advanced study, given a different book and a different challenge.
I know; I was still naive, anticipating my college experience would be somehow different from the mass-indoctrination that had been primary and secondary school. It was my first inkling that no, that was not to be.
When it comes to our own selves we are all necessarily biased in our own favour. Hence we need to step back and take a broader perspective so that we can be objective in our assessments. In today's society Teaching as a profession (in School/College/University) has been unfairly denigrated and become a thankless job. They are asked to operate only within a defined policy framework and not really allowed freedom to change that framework. In spite of that there are scores of stories (and even movies made) where Teachers have gone well beyond their boundaries to help students learn and perform. If you want to blame somebody blame the "System" built by policy-making idiots with no idea of human psychology, behaviour, needs etc. Teachers are really caught between a rock and a hard place i.e. policy says follow standardized curriculum/tests and don't do any creative individual things whereas students want individual recognition/attention and don't want to be called out on their lack of hardwork and application to proper studies. Hence we need to be understanding of them.
Never underestimate how few fucks teachers give about anything beyond their small bubble.
- Mark Twain.
> I wrote an RPN calculator, had it do a series of calculations and print the result. Turned that in.
The teacher wanted you to learn:
1. how to write a (very simple) assembly program for 360 to add to numbers
2. how to create a fault
3. how to print a crashdump
4. how to read a crashdump
By using a RPN calculator, you learned none of these objectives.
Which, by the way, required accomplishing those bullet points many times over. Obvious to anybody who's ever written anything in assembler.
it is, but the thing is that these simple building blocks end up quite far away from an actual production level outcome that someone looking at a computer might see or interact with. It's hundreds of levels deep.
Someone with curiosity and eager to learn will be able to easily learn these foundational layers. Someone looking to "get rich quick" and be ready and employable ASAP won't.
1) Virtual Machines: Versatile Platforms for Systems and Processes by Smith and Nair - Seems to be a comprehensive subject overview book.
2) Virtual Machines by Iain Craig - Seems like a more hands-on book with languages and VMs.
3) Virtual Machine Design and Implementation in C/C++ by Bill Blunden - Seems like an hands-on implementation.
If somebody who has read any of the above can add some comments that would be helpful to everybody.
In a deep sense, virtual machines are what make computers computers, as we use the term today. Turing's 01936 paper about the Entscheidungsproblem hinged on virtual machines being able to emulate one another.
Other than the above i can only think of studying "QEMU Internals" for more knowledge - https://airbus-seclab.github.io/qemu_blog/
I just wish I could find the time to sit down and design the damn thing.
Most people who want to learn a bit about how their machines work would be better served by taking an operating systems course. Same goes here: if you only have time for a short tutorial, I recommend "Writing my own bootloader" instead. [1]
(This is not meant to say that the Write your own VM tutorial is a bad tutorial; only that, in my experience, most people who'd do it would be best served by a different subject)
Can you please elaborate why it is bad to use LC-3 for studying computer architecture? I do understand it is completely different from real hardware, and too simplified. But from the perspective of writing CPU emulators, is it bad for me?
You say you want students to be able to write emulators/simulators etc. (you list a bunch of software.engineering tasks). I say writing an LC-3 emulator won't give you any transferable skills for writing, say, a Gameboy Emulator (still a 30yo system), because these educational arhitectures are bad and abstract away precisely the things that you have to get right to do that, leaving you with something trivial to implement: a C array for "memory" and a few bitwise operations.
Since we're largely looking at the same things and coming to orthogonal conclusions, I suggest we agree to disagree on this one.
Yes, there are fewer instructions.
https://en.wikipedia.org/wiki/Hacker%27s_Delight
which mainly depend on conventional numeric representations.
There have been decimal and hybrid computers built since the 01970s (especially for pocket calculators, but new decimal instructions were still being added to Intel's lineup in the 8086 with AAM and AAD, and I think decimal continued to be a consideration for the AS/400 into the 90s), but MIX is really kind of an 01950s design, with:
- word-addressed memory
- five bytes per word (plus a sign bit)
- one word per instruction
- six bits per byte (in binary realizations)
- possible decimal
- a single accumulator
- sign-magnitude
- no stack, and
- a nonrecursive subroutine call convention relying on self-modifying code.
You can find one or another of these characteristics in machines designed since 01960, but the combination looked old-fashioned already when it was introduced.
Let's look at just one thing every programmer has to deal with, memory.
On an LC-3, the address space is exactly 64KiB. There is no concept of missing memory, all addresses are assumed to exist, no memory detection is needed or possible, and memory mapped IO uses fixed addresses.
There are no memory management capabilities on the LC-3, no MMU, no paging, no segmentation. In turn there are no memory-related exceptions, page faults or protection faults.
When an x86 machine boots with 1MB of RAM, the 4GB address space still exists in full, but accessing certain addresses will cause bus timeouts, crashes. One must track and manage available memory. There's a BIOS, and manually probing memory locations may trash its critical structures. There's INT 0x15.
I picked memory arbitrarily but you run into the same limitations no matter what you pick. Would a students who was educated on LC-3 know how a computer keeps time? Of course not, there's no PIT, there's no CMOS clock. Would they have thought about caches? Nope.
Oh, but wouldn't a student who implements a timer emulation extension for LC-3 learn more about timers than somebody who just learned to use an x86 PIT? Alas, no. There are 20 equally easy and reasonable mathematical ways to implement a timer abstraction. A good 15 of these are physically impossible on real hardware, out of the remaining 5 two would be prohibiitively expensive due to electrical engineering reasons, one has never been implemented in real hardware due to historical accidents, and two are designs that are actually in use. So to write timer emulation that teaches you anything at all about how actual timers work, you'll have to look at and understand a real architecture anyway.
That's why educational architectures are so contraproductive. They abstract away exactly the things that make modern computers modern computers. One comes away with fundamentally wrong ideas about what computers do and how they actually work, or could work.
It's like learning to drive in GTA: in principle, there could be plenty of skills that transfer to the real thing, but in practice you'll prefer to teach how to drive to the person who didn't play GTA at all.
They are usually not for learning about application or even systems programming, in assembly and otherwise. They are about CPU architectures (and some surrounding concepts) themselves. The goal is to be able to quickly build your own emulator/simulator (like the VM behind the link), and maybe an assembler. Or, coming from the other side, given a working emulator/simulator, implement a high level language compiler, such as for a simplified C language.
In both those goals the CPU architecture is geared towards quickly converging towards a working system. So of course they don't require you to implement (as someone learning architecture engineering) or even use (as someone learning to build a compiler) an entire MMU, much like your first project car likely wouldn't contain a computerized double clutch transmission. Instead, they are simplified CPU architectures that allow you to make steady progress, without being slowed down by the tedious complexity that a real architecture brings for reasons that are not relevant yet when starting out.
Then, once that is achieved, you can freely add things like an MMU, a cache controller, maybe shift towards a pipelined or even superscalar architectures...
Besides, a very large class of computers don't have many of the things that you mentioned. For one, even very advanced microcontrollers explicitly don't even have an MMU, because that would destroy latency guarantees (very bad for automative controllers). For the rest, I've got to say that there is a certain irony in complaining that computer architecture students don't know about "modern computers", while in the same breath mentioning things like INT 15h, segmentation, and x86 PITs, as if we were in the 1990s.
> There are no memory management capabilities on the LC-3, no MMU, no paging, no segmentation. In turn there are no memory-related exceptions, page faults or protection faults.
Sounds an awful lot like a Commodore 64, where I got my start. There's plenty to learn before needing to worry about paging, protection, virtualization, device discovery, bus faults, etc.
It sounds like it's not teaching the wrong things like your GTA driving example, but teaching a valid subset, but not the subset you'd prefer.
It seems like a student would need to know a significant amount of coding in order to learn those abstractions in an interactive manner.
And by learn them I mean learn them (not just following a tutorial), organizing the code for a fully working x86 architecture is no joke.
But a student with that level of skill probably doesn't need to learn the x86 architecture so intensively, they are probably already employable.
I am asking this seriously, by the way, not trying to nitpick. I'm trying to put together a free course based on the video game Turing Complete[1] but from what you're saying it sounds like it might not be very effective. (to be clear the goal is to teach programming, not Computer Engineering)
[1]: https://store.steampowered.com/app/1444480/Turing_Complete/
My working assumption throughout was that the people in a computer architecture class already had 1 or 2 semesters of other programming courses where they worked in a high-level language, and are looking to learn how computers work "closer to the hardware". And educational architectures create a completely false impression in this domain.
If I had to teach assembly programming to people who never programmed before, I'd _definitely_ not want to start with x86 assembly. I'd start by teaching them JavaScript so that they can program the computers that they themselves, and other people, actually use. At that point they'd be ready to learn computer architechture through an x86 deep dive, but would no longer need to learn it, since, as you said, they'd probably already be employable. But the same goes for learning LC-3, and much more so.
To be honest, my opinion is only that educational architectures are a poor way to learn what modern computers actually do, and while I think I have good reasons for holding that particular opinion, I don't have the breadth of experience to generalize this specific observation into an overarching theory about teaching programming and/or compsci. I hope your course will be a useful resource for many people, but I doubt listening to me will make it better: my experience does not generalize to the domain you're targeting.
MIPS was, I think, a decent compromise between academic architecture and industrial architecture. There was a decent amount of practical stuff the students had to deal with without having to eg do the dance from x86 real mode to protected mode.
One of the most memorable lectures though was on the second last day. As it turned out I had gotten through all of my material one say early. We had a review/Q&A session scheduled for the last day but needed 1h30 of filler. I ended up putting together a lecture on JVM bytecode. Throughout the course I would often use C <-> MIPS ASM throughout examples because the 214, which was a prerequisite, was a C course. All of their first year work had been in Java. Anyway, we took real Java programs and disassembled them down to bytecode and walked through it, showing how it’s very similar to hardware assembly but with extra instructions for eg placing objects on the stack or calling methods on objects. The class ended up going almost an hour over because everyone was oddly engaged and had a ton of questions.
The first one covers the lowest level of how logic gates are physically wired to produce a Turing-equivalent computing machine. For that purpose, having the simplest possible instruction set is a pedagogical must. It may also cover more advanced topics like parallel and/or segmented instruction pipelines, but they're described in the abstract, not as current state-of-the-art industry practice.
Then, for actually learning how modern computers work you have another separate one-term course for whole machine architecture. There you learn about data and control buses, memory level abstractions, caching, networking, parallel processing... taking for granted a previous understanding of how the underlying electronics can be abstracted away.
Reasonable adults might have reasonable questions about those facts, such as, "what does any of that have to do with a computer?"
To my embarrassment, I realized they were completely right and my early exposure to software made me overlook some extremely important context.
So for these adults, the expectation of struggling through a few semesters/years of javascript is not an optimal learning route.
My hope was that working from the logic gate level up would at least provide the intuition about the relationship between computers (Turing Machines, really, not modern computers) and software.
However, I think based on your excellent critique I will be sure to include a unit on how "educational architectures are very different from modern architectures and I may have ruined your brain by teaching you this" haha.
Apparently a lot of CS courses in India still use the 8086/8088 too.
No cycle accurate anything. Simple I/O. Since I/O on the 6502 is all memory accesses, adding console is as simple as echoing whenever a character is stored in a particular memory address. No reason the simulate a VIA chip or UART or anything that low level.
Fun project. You can take it as deep as you like.
Books - https://www.safetty.net/publications
Video Lectures - https://www.youtube.com/user/SafeTTynet/videos
Far more 8051 cores are shipped than all of those combined, excluding ARM.
You can't always use the term "emulator" instead of "virtual machine", because while you could say wasmtime was an "emulator", you can't correctly say that WebAssembly itself is an "emulator". Rather, WebAssembly is the virtual machine which wasmtime emulates. It's also common to call emulators "virtual machines". (The Wasmtime web site mostly calls wasmtime a "runtime" and WebAssembly an "instruction format", FWIW.) And of course a running instance of an emulator is also a "virtual machine" in a different sense.
I think it's also reasonable to use "virtual machine" in the way you are describing, and it has some overlap with this last sense of "virtual machine". Perhaps in your current environment that is the overwhelmingly most common usage, but that is definitely not true elsewhere.
Really, a virtual machine is literally what it says on the tin: something that isn't a physical computer (machine), but presents itself as one. You know, with a virtual CPU or a virtual disk or a virtual keyboard etc., whatever a computer would have. If it doesn't present itself as a machine, it's not a virtual machine.
Calling JVM a virtual machine just because it interprets some bytecode the same way a machine does is like calling me a virtual doctor just because I read text the same way a doctor does.
No, it isn't and doesn't. What in the world does it have that makes you think it pretends to be a computer? A bunch of pretend registers and a memory limit?
https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-2.h...
I just mixed it up with Dalvik having multiple registers, but that makes it even worse. At least normal machines have more registers.
And literally here:
The following section provides general guidelines for tuning VM heap sizes: The heap sizes should be set to values such that the maximum amount of memory used by the VM does not exceed the amount of available physical RAM.
https://docs.oracle.com/cd/E21764_01/web.1111/e13814/jvm_tun...
Maybe instead of telling me I'm clueless, tell me how you're right? What do you see in it that is actually virtializing a computer in your mind? Because I'm pretty sure that if someone sold you a VM service and it turned out to be just them running your programs under the JVM, you'd be kind of mad.
In the article the author even states as one example emulation a classic console, but it’s clear from the article that there are many other possible VM’s from the definition they provide.
Anyways the point is VM is abstract, and there are many many types of them. Simulators, emulators, hypervisors, etc… are all VMs, but also there are VMs that don’t quite already have a name for them yet because they’re strange.
I don’t mean to be rude at all - quite the contrary, I want to be respectful - but I also want to be clear about these terms for people who are interested in learning.
I don't think the distinction you're advocating for actually exists. 'Virtual machine' is commonly used for any software that executes machine- or bytecode, irrespective of the reason. This can include virtualisation, but you also commonly see the term used for language runtimes: e.g. Java's JVM, Ruby's YARV (Yet Another Ruby VM).
The one area you don't actually hear the term that often is in emulation, and this is in part because most modern emulators have tended away from emulating entire systems, and towards techniques like dynamic recompilation (dynarec) of emulated software.
Context and convention are important. This subthread is filled with people who are technically right, but choosing to cheer for an unclear and idiosyncratic terminology. A VM means hardware virtualization. Choosing other meanings is at best confusing and at worst a terrible security bug.
I always thought that it made sense to use the word for both things, and I never even thought twice about it when people used it for programming languages.
It would have to be a very strange conversation for someone to misunderstand someone else in the way you mentioned.
Sure, in precisely the same way that a kitchen knife and a sword are the "exact same concept underneath". But if you use the words interchangeably you'll confuse people.
And I'll just repeat the point, if you tell your boss your web app is "running in a VM" when you just wrote it in Java, you'll be fired for some really terrible security analysis.
What do you mean with “in this context”? The article is clearly using the term in the same sense as JVM and LLVM.
(Also your relationship with you boss sounds pretty toxic. If there is ambiguity in the terminolgy why don’t you just ask a clarifying question? Many words can have multiple meanings.)