-- for languages that were designed to run without benefit of an independent OperatingSystem
The development environment of the language is the entire OperatingSystem
Also known as "PinkyAndTheBrainLanguages".
- the OberonLanguage
- the SmalltalkLanguage (quite recently SqueakSmalltalk does it again, but see SmalltalkSecurity)
- EmacsLisp -- (doesn't Emacs always need a host OS? Emacs is the OS.)
- the ForthLanguage -- has standard block read and write words (functions) instead of a file system. Often works as a tiny OS for microcontrollers which don't need many services. See ColorForth and ForthOs? ( http://ForthOs.org/ )
- PC versions of BasicLanguage in the late '70s & early '80s: MicroSoft's BASIC for the IBM-PC, Apple II BASIC, PET, Commodore 64, TRS-80, etc...
- the LispLanguage had LispMachines, which were a commercial success for a while
- the SchemeLanguage (MzScheme can run on bare hardware)
- JavaLanguage -- most versions live on top of an OS, but it wraps or implements every OS feature it supports.
- AdaLanguage (notoriously difficult to port because of strict definition of features, such as multithreading, which are traditionally the domain of the OS and implemented differently on many different systems)
- UcsdPascal really? what on? On several systems, including the AppleIi. See UcsdPascal for details. Once a system booted UCSD Pascal, it could read and write Pascal-formatted disks, which were mutually unintelligible to other OSes.
- ExBase (FoxPro, dBASE)
- RubyLanguage (just try irb).
However, the following languages are generally not thought of as LanguageIsAnOs
The main difference I see in the above 2 groups is:
Most of the first group allow you to
- type in a short function on the same command line that you would use to run a program
- immediately run it out of RAM.
The second group of languages require you to run programs by
- start a text editor
- type in the short function
- save the file to disk, give it a name
- compile it from the command line (using some compiler that's *not* built into the OS)
- run the executable from the command line.
Is that the difference that was intended, or do you mean something different by "LanguageIsAnOs
There's another view though. ALL languages, whether or not they were designed to run on bare hardware, should be considered and evaluated as operating systems. A language that makes up a bad operating system is simply a bad language. See LanguagesAreOperatingSystems
This metric for language quality seems to focus mostly on the scope of the language's API/features, rather than on the inherent qualities of the language itself. Simply abstracting everything under the sun doesn't necessarily make a language good--IMHO JavaLanguage has gotten a bit too big simply because SunMicrosystems has been trying to do exactly that. Does a programming language need (as part of the language standard itself) such things as multimedia rendering libraries, system administration/user management libraries, etc. to qualify as a "good" language? I think not. It certainly should be possible to
build such things in any language; however SeparationOfConcerns suggests that many such things should be left for other DomainExperts to build--rather than stuffing them in the language itself.
You will notice C/C++ added to the list above. This is not to suggest that these are necessarily good languages; the limitations and weaknesses of both are well-chronicled and I don't wish to repeat that FlameWar here. However--entire production-quality operating systems are implemented in these. It is true that users of such operating systems are not presented with a console (or a BrowserWindow?) where they can start entering C/C++ code (as the preferred method of accessing and mutating the underlying OS). But I say BigDeal?. One can certainly access all of the features of the OS through these languages (of course, additional APIs beyond the language standard library are needed--which makes portable C/C++ code more difficult to write) should one choose to do so. Most EndUsers aren't interested in programming anyway; and aren't likely to care what language(s) an OS is written in.
There seems to be a large amount of confusion between the needs of the EndUser (who wants to get work done; work which for most users involves no writing of code) and the needs of the developer (who wants to be able to write, test, and debug code as fast as possible). The LanguageAsAnOs? theory seems to be oriented towards developers
Finally, to round out my point, the list above also contains such things as Forth and various BASICs for 8-bit micros. While BASIC might well have been the default "shell" for your AppleTwo or CommodoreSixtyFour--all such dialects of BASIC were truly horrible languages, which I wouldn't want to inflict on anybody.
"Getting work done" almost always involves programming of some generality, or at least tasks which are highly programmable.
"Almost always" is far too strong. Many user tasks; such as playing games, writing letters, balancing a checkbook, producing presentations, downloading pictures off of the digital camera and publishing them on the Web, etc. involve little or no programming at all. At least not programming in the way I think of it.
But there is almost never any gentle introduction to programming. Emacs might be the exception that proves the rule.
Lots of other exceptions. Spreadsheets are a common one, it is often said that MicrosoftExcel is the world's most widely used FunctionalProgrammingLanguage (I will neither agree or disagree with that statement here). Production of document templates might also be considered programming of a sort--no knowledge of a programming language is needed here, either.
Instead of providing an environment with a gentle immersion to programming, you provide contempt for any mere "user" who demands to be able to perform those tasks without immersing themselves in a foreign programming language.
Not at all. I have the utmost respect, not contempt, for a user who wishes to learn programming. Many users, do not. A well-designed OperatingSystem should allow laypersons to effectively use the computer without knowing the guts of how it works.
Folks who drive cars would do well to know how to perform basic maintenance tasks, such as filling the gas tank, replacing a flat tire, or changing the oil. However, most drivers need not know how to rebuild an engine.
Imagine the nerve; a foreigner, a tourist
, who demands us he be able to get around a French city without learning the native language, history, and architectural principles! Why, if we allowed mere users to program, pretty soon we'd have casual
Whoever said anything about prohibiting users from programming (or about erecting knowledge BarriersToEntry?, to keep users away). I never did.
In many people's minds, there is a sharp dichotomy between "users" and "developers" but in reality there is only a continuum. I speak as a user since I am not a developer. -- RichardKulisz
Agree about the continuum. I am a competent developer (at least I, and my boss, thinks so); however when I'm in UserMode? I can be just as lazy as the next guy.
An ordinary driver can learn to maintain their car on an incremental basis. First they learn to replace tyres, then the oil, then the spark plugs, and so on. Everything in the car is Object-Oriented. And this isn't due to cars being made of physical objects since "organic" systems like biological cells, houses and cities are not at all OO. Moreover, the car presents a continuum of complexity to its users. There exists a legitimate and good reason to learn about cars at every step of the learning curve
. Additionally, the slope of the learning curve is not steep
initially, and only as you get into more complicated repairs do you start needing to know more and more about advanced shop techniques. The ultimate constraints to home auto repair are financial and not intellectual. Most people don't have the money to install a complete machine shop at home.
This is not the case with either Unix or C/C++. One either understands the system internals or one doesn't. Yes, you are able to "do many things" in Unix but that means nothing. To paraphrase: Ordinary people are amazed at how far computer science has come. People in the know are amazed how far it hasn't.
For instance, it isn't possible to inspect and toy with Unix system internals like you can with Smalltalk, even if you have sufficiently high privileges. (Don't lecture me about OS security.)
Similarly, one either understands C++ or one doesn't, I sure as hell don't.
Inserting text in the middle of an argument actually seems to be a common WikiParadigm?. Or at least that's been my experience.
(Unless you have someone who's as good a systems analyst as I am, and as confident in their own abilities as I am, none of the participants ever integrates the thread successfully as it evolves and nobody ever wants to integrate it after it's evolved into a huge daunting ThreadMess
. So unless you have me on the scene, it's pretty much an antipattern.)
See "Quote and respond" in HowToWriteAndEditThreadMode
Things to think about, though not exactly relevant:
[T]here is much to learn from Linux (and Linus), and I'm not referring to the technology which makes up Linux (which contains little that is new, after all).
Self was abandoned in favour of Java due to its lack of a C style syntax. WorseIsBetter
and compatibility all over again.
Making a system that replaces the entire OS is *much* simpler now that the GrandUnifiedBootloader
exists. But what about the hardware? Isn't it a major headache to have to be compatible with the bewildering array of PC hardware combinations? I hear that something called OsKit can help, but personally I'm designing my own hardware in my CopiousFreeTime ? madness!
This issue became obvious to me when a software tool based on top of Java had a daylight-savings bug in it (due to changes legislation). The time was right on the OS (Windows or Unix), but wrong in the Java engine. But the software tool that used Java was not tested on the Java version that had the fix, so I had to put in a fudge factor. Hopefully next year I can install the newer Java engine, or else someone will have to add another fudge factor.
This is something that occurred to me when I was using RubyLanguage
irb, too. In my brief fling with RubyLanguage
, my reflex was to install Ruby via Debian's package management system. Silly me! It turns out that Rubyists like to be on the cutting edge, while Debianistas (and package maintainers in general, to a lesser extent) like stable systems. If you want the latest, it's utter madness to try to install Ruby via package manager. Ruby not only has a package manager, but it can handle multiple versions of Ruby as well (in case you're stuck maintaining an old project, but you want to start a new one using the latest in cutting-edge technology).
This got me to thinking about how Ruby isn't the only system that has package management: PythonLanguage
, and HaskellLanguage
(I think) also have this, as well as many others. And it isn't a stretch to think about how, even when each of these languages reach out to the OS to do things, it's no different than the OS reaching out to the BIOS (or to the computer directly) to do its magic. And if you *really* think about it, each and every bit of code written to do something, is an extension of that language--so Unix is as much an extension of C as C may be a language running on Unix.
While it would be difficult to do, conceptually, there's nothing stopping us from taking a given language, creating a run-time prompt of some sort for it, and then putting it on a computer to run all by its lonesome. Thus, the line between OS and language is indeed a blurry one--at least, it's as blurry as you want (or need) it to be! --Alpheus
There's also the case of AppleScript
on classic Mac OS. In addition to being a language in which to script GUI apps, it and Script Editor could also be used as a CLI on this otherwise CLI-less operating system (not to mention MPW and Commando). There was also an app that provided a hotkey popup window thing that let you type in lines of AppleScript