Artifact [58b347aee9]

Artifact 58b347aee9daae96ec42e4be861051bc3b60b8bf:


# History

SquirrelJME is an idea and execution that extends from previous ideas and
projects. The base idea extends from my desire to write an operating system to
run on systems, since such things have fascinated me.

# Old Projects (2011/01/15 - 2016/02/25)

These are old defunct projects which I have previously worked on.

I will say that it can take years before you can find a project you enjoy
working on and one that inspires you. Keep searching. Just be careful where
you step and do not take in more than you can handle.

## HandOS (2011/01/15 - 2011/01/22)

This was an attempt at creating an open source implementation of Palm OS.
Palm OS was not actively used much often and additionally existing emulators
for Palm OS are sub-par in that they were either old or were horribly out
of date. The goal of the project was to run m68k and ARM Palm OS applications
on the host system.

The project was fully structured and had all the default applications in place
as placeholders for when they were ready.

However, the project could not actually be compiled, it was mostly pretty much
just placeholders, some reference documentation, and notes. It did include
some tests which showed that threading was indeed possible on Palm OS like
modern systems.

## MPA Orange-Sapphire (2011/12/12 - 2011/12/13)

This was a very short project which never really took off. It was intended
to be an operating system written in a BASIC-like language. Obviously BASIC
is rather horrible compared to the languages of today.

## MPAYAOS (2012/02/20 - 2012/02/29)

Standing for __Yet Another Operating System__.

This was a short attempt at another operating system, it never really got
past the bootloader stage. It was written in C.

## HandNIX (2012/05/28 - 2012/05/29)

Standing for __Hand UNIX Environment__.

This was an attempt to make a UNIX-like environment for Palm OS so that I could
do development for my projects on Palm OS. It existed as a single C source code
file.

Only a few things were implemented. The major thing which was implemented was
a basic cooperative tasked system which was based on Palm OS's versions of
`setjmp` and `longjmp`. There also was a basic terminal emulator which did not
support any escape sequences.

Every POSIX command that existed on the system was referenced via a function
pointer and the intention was to have virtual files (via `#!`) which would
execute those internal commands when requested. The environment would have
started on the shell (`sh`) which would then be available to execute other
programs.

## HandOS 6.3 (2012/05/31 - 2012/08/17)

HandOS is a clone of Palm OS, however the main purpose of this project was to
implement the only released in a simulated environment: Palm OS Cobalt.

It was written in C and it required the Palm OS SDK for compilation.

I did not have headers for Palm OS 6, so I was writing the headers from
scratch.

## MPAPCOS (2012/09/30 - 2013/01/16)

Standing for __Posix Compatible Operating System__.

This was an attempt to write an operating system which was compatible with
POSIX:2008 and could run such programs. A C preprocessor was written and some
basic utilities were supported, but generally that was as far as it got.

## HandOS 5.6 (2013/01/23 - 2013/02/05)

This was another attempt at writing a Palm OS clone, it did not get very far.
There was basic project structure but not much else.

## MPAMSEK (2013/03/31 - 2013/04/14)

Standing for __Multi-System Emulation Kernel__.

This project was I believe to write an operating system which could run many
other operating systems in a very bare bones emulated environment to run as if
it were on native hardware. Basically, you would boot into a system and instead
of running an OS with an emulator running on it, the emulator would be
directly running on the hardware.

I only really got a basic system launch on PowerPC's Open Firmware. I was able
to print to the system's framebuffer console but not much else.

## MPAOSKP (2013/04/14 - 2013/05/15)

This project is based off MPAMSEK.

I am not too sure what the acronym stood for, very likely it stood for
__Operating System Kernel Project__.

I wrote a memory allocator but it never really got past the boot loader and
early kernel initialization stages.

PowerPC and x86 worked on Open Firmware.

I failed to get SPARC working, I could just not get the bootloader to run
properly and it usually ended up just crashing or not working at all. It may
have been related to register windows.

I thought about writing a C compiler but I gave up quickly and abandoned that
idea because that would be too much work with too little of a benefit.

## POSIX Environment for Palm OS (2013/07/25 - 2013/07/27)

This project was essentially similar to an earlier but was a POSIX environment
for Palm OS. By reverse engineering bits of Palm OS previously I determined
that some things were very possible. For Palm OS 5 I had pretty much a concept
background threading and server system. Basically a daemon would be launched
in the background which would keep the environment running. There would be a
connection made to the daemon with locks and semaphores. There would then be
a terminal interface which would show what was being output to the console.

There would be threads in the background running tasks. However to access the
server process a pointer would have to be remembered. This is where the
feature manager was used to keep a persistent handle in memory so the daemon
could be connected to. I determined that it was very important to be able to
switch programs outside of the environment.

For SquirrelJME on Palm OS, I have an idea to do something very similar so
that it runs in the background while other applications may be used.

## POSIX Environment for Palm OS (2014/10/12 - 2014/10/12)

This project never went past a few files and headers. The purpose of this
project was the same as the previous.

## k5 (2013/12/25 - 2014/04/25)

This project had 503 commits.

This is basically the start of my delving into Java virtual machines. It was
written in Java and was pretty bloated when it came to the compiler, using very
abstract concepts for compilation. It was to target Java SE but I am not too
sure which version it was for. Very likely it was Java 7 as Java 8 was released
shortly before this project ended.

I never really got past the JIT stage in the project. It was also quite massive
of a project.

Anything that was made for documentation was written in LaTeX, which is far
less friendly compared to Markdown.

## k8/Squirrnix (2014/04/26 - 2016/02/25)

This is the direct predecessor to SquirrelJME. Utilities and classes in
SquirrelJME have been derived from this project. Generally if I find a class
which is missing in SquirrelJME I check this project and copy all of the code
from there since the bulk of it is just placeholder.

This project had a massive number of commits: 9041.

It intended to implement the entirety of Java SE 8 with all of its profiles.
This was for the most part a very unrealistic goal. As with _k5_, it never
really got past the JIT stage. The massive requirements in place were
unrealistic. This project was doomed for failure even when it began but I was
a bit foolish to take up this task.

# SquirrelJME

## Starting Background

SquirrelJME stems from the following ideas:

I had a growing fascination with J2ME. I had an old cell phone which could run
J2ME applications. I would make a few concept projects but they did not last
long because programming for J2ME is quite horrible as it is very lacking when
it comes to Java. I did have the idea of writing a virtual machine that could
run J2ME applications so that I could use some again.

Another thing is that the write once and run anywhere aspect of Java pretty
much fascinated me also. The idea of writing a program once and having it
work pretty much everywhere was indeed interesting. I wanted to do this with
_k8_ but it was not really a feasible thing to do because it was so gigantic.

However, there was much frustration with my then current project _k8_. It was
gigantic and the number of classes to implement was essentially an impossible
mountain to cross. There was a growing sense of doubt that the project would
never get anywhere because it had unrealistic goals that would be impossible
for a single woman to obtain all by herself. I calculated that it could take
perhaps up to a decade to implement the core classes of Java SE 8. By a
decade's time, Java SE 8 would be obsolete and nobody would be using it anyway.
So this compounded a wasted effort. Additionally being a third-party VM, there
would quite literally be very little interest in it, so it could not be for
fame. Basically it was too much and too ambitious of a project and sadly it
took two years to realize that.

Near the end of the project's life span I was a very depressed person, I felt
like the project was a complete waste of time and that life was rather
meaningless. I felt trapped working on the project with no escape. My life was
melting away into nothingness and worthlessness. I did not want to admit that
the project was a failure and would be going nowhere, I was naive.

In February of 2016 I watched Hack Summit 2016, it was pretty much the first
online conference which I have visited. It was really exciting and it did move
me a bit. But I think the one talk which really moved me was the one by
_Sarah Allen_ (you can see her on YouTube here:
<https://www.youtube.com/watch?v=S1iYeThQO-g>). It really resonated with me and
it has really given me the light shining through my own fog to realize that my
own project was ruining my life. After that I decided that my own project was
not something I really wanted to do, that my ambitious goals were not even
caring for myself. I decided that I should care more about myself and that I
had to cut my project loose.

When that happened, I was still so very much interested in Java and having
write once and run anywhere, portability and virtual machines. I found Java to
be very awesome. I knew that _k8_ would never fit on the systems I would have
liked to target. I got the motivation to push Java as small as it can go. I
knew the gigantic size of _k8_ was too much, so I decided to switch to the
small scale. I remember my fascination with J2ME and I wanted to clone that
environment because I found it interesting. Java was seen as this gigantic
bloated monster that ate so much CPU and so much memory. But working with the
JVM so much made me realize how wrong it was. Java was in fact very small and
very light. J2ME was very light and very simplistic.

The first thing to do is determine has J2ME been updated ever? To my surprise
it actually was updated for Java 8. So this was quite something. Although it
was not really a microscopic Java 8 VM it was Java 7, which was good enough.
It added extra classes and was in general quite cool. JSR360, which is the
specification for Java ME 8 was proposed on October 2, 2012. The final release
was made on April 30, 2014. Java SE 8 being released on March 18, 2014. So
Java ME 8 came out very shortly after Java SE 8. However with Android and iOS
being everywhere it never really stood a chance and Java ME 8 never really got
the chance to actually be anything.

I decided to study Java ME 8, to see if it was indeed viable. I took a quick
glance at it and then deeper dives into it. Java ME 8 imported quite a number
of things from Java SE 7. It basically was bringing it up to date with the
modern Java language rather than languishing in the past. It did remove some
things but, in the essence of compatibility those could still be brought in.
These removed things were stuff such as LCDUI, which were pretty much
nowhere. It took a bit to verify compatibility but the changes made do not have
an impact on backwards compatibility. As such this was a bonus.

One added bonus that I liked is that Java ME was so small compared to Java SE.
It is very tiny and extremely compact. Basically what is in the language is the
bare minimum sane choice. I will say that there are some errors and perhaps
some omissions but in general it has been rather good. The thought of Java SE
being implemented and the gigantic task I knew was impossible and the small
size of Java ME is actually is within reach. The small number of classes, up
around 512 classes for the standard makes it very reasonable. This estimated
512 classes is about half the size of Java SE 8's compact1 and does not include
things such as SQL. I really liked the fact that it gave you the minimum set
of classes and you could just bring your own classes in if you care about it.
Personally, I do not really care for SQL and stuff like CORBA because I do not
often use them at all.

## Naming and Mascot

The name _SquirrelJME_ comes from the fact that I personally find squirrels to
be very interesting and curious animals, not to mention that they are cute.
Where I used to live I would see squirrels all the time so they were quite
common, although where I live currently as of this writing I do not often see
squirrels.

Originally my plan for a mascot at least for _k5_ or _k8_ would be to have a
pink bunny rabbit in reference to _The Legend of Zelda: A Link To The Past_.
In this game there is a region that you can enter called the _Dark World_ where
every human who enters is transformed into an animal that reflects their
inner self. I then switched my idea to having the mascot be albino because
these animals are a bit more rare (since they are more easily predated in
nature because their bright white fur stands out). Then when _SquirrelJME_ has
come around I decided to keep the same mascot but make him a squirrel instead.
So the green tunic that Link wears is a reference to the Zelda series.

It was difficult finding a name for him, as such I initially decided on just
placeholder name for awhile. I thought about _Lexer_ but that was quite long
and slightly complicated, so I shorted it to _Lex_. It was nice and for the
most part the name stuck since I was happy with it. Therefor it was never
changed.

He was uploaded on 2016/05/07 to the repository.

He has subsequently been redrawn on 2018/10/19 by Kat Adam-MacEwen, where he
ended up very handsome. She is quite a wonderful artist.

The C based virtual machine **RatufaCoat** was named by _meepingsnesroms_ of
the Mu project. Ratufa being the sub-species of squirrels in southeast Asia.

## Gaining a Sister Project

On 2018/11/03 the developer of Mu, _meepingsnesroms_, wanted to become a sister
project of SquirrelJME, so this was very exciting! The link to her repository
is in the [readme](readme.mkd)! We will be cooperating mostly by word of mouth
by linking to each other's projects to hopefully gain interest in both of our
projects.

## The First Release

The first version of SquirrelJME was released along with Mu on
December 25, 2018.

## The Second Release

To be written...

 * [There is this article here you may read](assets/articles/anewvm.mkd)!