This article is under construction and needs to be completed. You can help by expanding it.
(Taken from ticalc.org user article)
http://www.ticalc.org/community/articles/01.html
Posted on 17 September 1997
The following text was written by Michael Wyman (author of CShell):
Although I've retired myself from active TI-85 programming, I've kept up with the events occurring with the newest programs, shells, etc. most noticeable of which is what many people have termed "The Shell Wars."
Since my release of CShell, it seems that many people have decided to release their own shells, all aimed (in my opinion) at becoming the next standard, as ZShell was the first! Please understand that I'm not saying that CShell was better than the newer shells.. In fact, I've almost completely stopped programming for the '85 (I'm currently learning C and Pascal for the PC), and have removed myself from the mailing lists.. I've decided to stay impartial to the shell wars, not saying that any shell is better than another. After its release, Usgard became the standard for many of the experience programmers. This was due to its support of many more functions.. Relocation, libraries, TSRs and interrupts, plus many more ROM calls. Later, PhatOS came out, a smaller shell, with relocation, though no libraries, TSRs or interrupts. This didn't quite gain the popularity of Usgard, and eventually it seemed that the authors had given up on it.
Programmers' support of Usgard was at times almost fanatical. Whenever someone would say that they didn't program for Usgard, and preferred to program for ZShell compatible shells, or something like PhatOS, regardless of their programming competence people would often flame them! Just read the ASM85 archives… You'll see a number of such exchanges; sometimes rational arguments, sometimes just flames…
Recently a new shell, Rigel, has come out, and promising all of the features of Usgard in a far smaller space. If true, this shell could become the next victor in the "Shell Wars." I would hope, however, that whoever the victor is, that they can win so on, so as to keep new shell from popping up so often that programs are being written for a hundred different shells at once.
I also would caution people about the merits of certain features in the shells. My main concern would be libraries… If libraries become too numorous, and too large, program users would become discouraged and confused at the size and number of libraries they are required to have to run the games they want. I recommend that libraries be kept few and small! Remember, we only have 28K to work with…
I would certainly hope (for the sanity of calculator gamers everywhere) that the shell wars soon turn out a clear victor, and let programming return to normal (i.e. programs and games, not shells) soon.
"Of course, these are my opinions; I could be wrong…"
(Taken from http://www.ocf.berkeley.edu/~pad/faq/ti85.html)
What about all of the other shells? Why is Usgard the preferred shell?
The first assembly shell for any TI calculator was ZShell for the TI-85, undoubtedly a major achievement and a major factor leading to the development of the many assembly programs on many different TI calculators that exist today. The first version of ZShell was released in 1994; this was the first assembly program that would allow you to start other programs (before then, you would have to recall each individual program you wanted to run onto the graph screen before you could run it). The current version of ZShell (4.0) was released a year later, and it supports all versions of the TI-85 (except the very old [and rare] version 2.0).
However, time marches on, and newer shells for the TI-85 have been written also. One of the earliest (if not the earliest) replacement shells was UShell, written to support ROM versions 9.0 and 10.0 when ZShell didn't. Once ZShell supported those versions, interest in UShell faded.
The new shells in the "third generation" were fully (or almost fully) compatible with ZShell. One of them (OS-85) provided a fancier interface, whereas most of the others (such as CShell-NT, OShell, and OS/7) tried to be smaller and/or offer minor new features. Since they provided the same features to programs as ZShell, they didn't create very many problems.
However, the OS-85 shell did cause some problems due to failing to handle checksums. A checksum is a short extra piece of data kept in addition to the file itself which is the sum (or some other simple function) of all values in the file that is used to detect unintended changes to a program (e.g. when another program accidentally overwrites it). If the checksum is incorrect, ZShell assumes the program is corrupt and won't run it. Of course, sometimes programs change themselves intentionally (as when saving highscores in themselves) so this must be provided for; in ZShell, the program would set a flag before exiting that tells ZShell to recalculate the checksum. However, OS-85 didn't recalculate it, resulting in the checksum becoming invalid if you ran the program in OS-85 and it modified itself in any way. This was a big problem for ZShell users, as running programs under OS-85 made them unable to later be run in ZShell. In some cases, users thought that OS-85 was better than ZShell because it could run programs ZShell wouldn't, not realizing that the programs (in their original form) worked fine in ZShell and the problem was due to OS-85 corrupting them.
This was nothing compared to the next change that would happen in the TI-85 scene. It happened in the summer of 1997, when three new shells were released: Usgard, Rigel, and PhatOS. All of these shells could run programs written for ZShell, but each one also had its own special format that would only run on it.
One of the most important new features of these shells was relocation, something which was badly needed for a long time; on the TI-85, files can be moved throughout memory by the operating system, so programs that reference data in themselves by any way other than relative jumps must take their address into acocunt. Under ZShell, programs would have to reference data by reading their own address out of ZShell and adding that to offsets in the program, and would have to do subroutine calls and long-range jumps by special functions inside ZShell that would calculate the right address in the right circumstances. Both of these methods are inconvenient to the programmer and make resulting programs both larger and slower.
Usgard solved the problem by using a relocation table, which is a list of places in the program that referenced other addresses in the program; when Usgard starts a program, it adjusts all the addresses to point to the right place. The relocation table took some space in the program, but much less than was used by the methods needed under ZShell. PhatOS and Rigel solved the problem by simply moving the program to a constant address before running it, which saved even more space since the relocation table wasn't needed.
Other features supplied by Usgard were libraries (also present in Rigel) and new ROM calls to help with the manipulation of variables and interrupts. It also allowed more direct ROM calls than the method used in ZShell (this method actually also worked in ZShell, but was undocumented there; some ZShell replacements like OShell didn't support it, causing some compatibility problems).
When Usgard was first released, it was supported by most of the greatest programmers of the time, including Andreas Ess (one of its initial developers) and Jimmy Mardell. However, many users disapproved of it for a variety of reasons, primarily because they believed it took more memory, but also out of deference to the "tradition" of ZShell and because they thought that having three "main" files as well as libraries was too confusing. The concerns about memory were partly true, especially for users who installed the rather large win shell (which was the default). This reason to prefer ZShell is mostly bogus, however; if you install the simple shell, the total size of Usgard is only about 750 bytes larger than ZShell, which is more than overcome by the space saved in programs that are written for Usgard.
This was the subject of flame wars on the list-zshell (later assembly-85) mailing list of ticalc.org (there was also a group called "Nova Coders" that claimed shortly before this period they would release a new shell, which they hyped up extensively, although they ultimately only released a halfway-complete version months later than promised, and it impressed no one). Usgard easily defeated PhatOS and Rigel, the other new shells, probably mostly because of how many great programmers supported it (it also had some features the others didn't). Due to a large amount of user complaints, library support was removed, which also decreased the size of Usgard somewhat (libraries in Usgard were somewhat unfriendly to programmers for several reasons, especially the use of a specialized, very slow calling mechanism). Many previously existing programmers were converted to Usgard.
After a few months, the situation finally settled down. The current version of Usgard, 1.5, was released in October 1997. By that time, interest in the TI-85 had already declined somewhat, with some programmers having quit or switched to the TI-86 or TI-92. However, there was still enough activity for a fair number of new programs to be released for Usgard, and for many programs to be updated to make Usgard versions. Some new programs were also released for ZShell as well (which of course worked in Usgard).
No other major shell developments have occurred since then. Very few TI-85 programs were released at all since mid-1999, and Usgard is still the preferred shell due to the many past programs for it. Among the few more recent programs, some are actually for Rigel instead, since they were made for several calculators and the Rigel environment is more similar to that of other calculators. However this is still a small amount of support compared to that for Usgard.