AuroraUX Combines SunOS with Ada

AuroraUX Combines SunOS with Ada

[qunying]

Hi,

I just encountered this news from osnews.com:
http://www.osnews.com/story/21123/AuroraUX_Combines_SunOS_with_Ada

Hope you may found useful.  I will find some time to download and test
it.

Enjoy!

Re: AuroraUX Combines SunOS with Ada

[anon]

Nice idea, for those who wanted the Minux or the dead GNU HURD kernel to 
be converted to Ada. 

But to show the true power of what an Ada OS can do, the entire project from 
the ground up must be created in 100% Ada. Not just using Ada to rebuild an 
existing OS or to build a environmental shell like Windows on top of DOS 
was. 

One example of this power is to use the Ada task scheduler as the OS job 
scheduler, which would make each program running in this OS environment 
an Ada task instead of a single excutional routine.  Now, as for single 
excutional routines, they could still be used for OS boot up, installation and 
system maintenance where tasking is not allowed. The Ada task scheduler 
should also be updated to handle multiple cpus cores used in todays world.

The down side of using the Ada Task scheduler as the core job scheduler is 
that it could kill the idea of using mix languages. But is that a bad thing in 
the first Ada OS!  Because the problem in initially allowing mix languages is 
that others will use mix languages instead of Ada which will kill the Ada OS 
before it has time to prove itself.


In <6af3aae9-5f85-4bdc-82c2-dfad5d4deaed@d2g2000pra.googlegroups.com>, qunying <zhu.qunying@gmail.com> writes:
>Hi,
>
>I just encountered this news from osnews.com:
>http://www.osnews.com/story/21123/AuroraUX_Combines_SunOS_with_Ada
>
>Hope you may found useful.  I will find some time to download and test
>it.
>
>Enjoy!

Re: AuroraUX Combines SunOS with Ada

[Paul Zacharzewski]

An interesting project.
A "from the ground-up" approach has merit.
I like the idea of an "incremental" approach.
Sort of a "tin-woodsman" like approach.

Chop off the bits and pieces of the OS, replace them with Ada.
Until in the end only the kernel remains.

Then you rewrite the kernel, or end up with a Hurd.

Re: AuroraUX Combines SunOS with Ada

[Ivan Levashew]

anon wrote:
> 
> But to show the true power of what an Ada OS can do, the entire project from 
> the ground up must be created in 100% Ada. Not just using Ada to rebuild an 
> existing OS or to build a environmental shell like Windows on top of DOS 
> was. 
> 
There's absolutely no need to do 100% Ada environment. After all, it's 
not simple. How do you suppose to manage version inconsistencies? Ada is 
better suited for environments where every piece is fixed after 
compilation and thus the whole program can be observed by compiler. It 
is OK for embedded solutions. If you want to target dekstops, you need:
1) either binary platform (e. g. XPCOM, GLib, NSObject) that makes 
possible changing different pieces without rebuilding the whole program. 
Pure GNAT programs/libraries are even sensitive to compiler version.
2) or create an Ada virtual machine. Did you have BlueBottle or Inferno 
in mind?

There are little desktop/server areas where one can exploit the full 
power of Ada. First of all, it should be OK to recompile everything.
1. NAS distroes. Several NASes give ability to run custom software, and 
FreeNAS is the example of such software. It can be single solid program 
as well.
2. Ada CMS. It is also OK here to recompile everything. Recompiling 
doesn't differ much from Zend Optimizing and the like.

In other cases the best way would be to forget all that false proudness. 
100% pragmatic as opposed to 100% Ada. We need to do the same (or nearly 
the same) things as the others. If you look at GLib, Qt and NSObject 
frameworks, you can see the common details:
1. Loosy structures. Arrays and dictionaries, most commonly. There is 
GArray in GLib despite existence of arrays in C. Loosy structures enable 
structure-agnostic data processing.
2. Some kind of component model.

First of all, there is a field for improvements here. Code generators 
might create typed views on loosy structures. And the component model is 
even wider field for improvements. I don't think that any of the 
existing framework is the last word.

Dmitry Kazakov many times demanded multiple dispatch. AFAIK there is no 
component model with MI support yet.

On the other hand there seem to be just 2 platforms allowing both local 
and remote interoperation: COM and NSObject. XPCOM is only local 
(1-process), UNO and CORBA are only remote.

-- 
If you want to get to the top, you have to start at the bottom

Re: AuroraUX Combines SunOS with Ada

[Per Sandberg]

Well I do not understand this statement since adding extra pieces of 
code aka plug-ins is very simple to achieve with any language and with 
Ada you get the safety as a bonus.
And also separate runtime and compile time since in practice when 
talking GCC/GNAT you could assume the following.
* Any source language could be used produce dynamically loaded libraries.
* Dynamically loaded libraries could be loaded given that their 
prerequisites are fulfilled.
* Dynamically loaded libraries could be build if their prerequisites are 
fulfilled.
So with Ada usually the list of prerequisite is a "bit" more explicit 
then with traditional weak typed languages such as C/C++, but apart from 
that the languages are equal when it comes to dynamic loading etcetera.
So that means that the compiler will bite you instead of the system some 
time in the future.

/Per



Ivan Levashew wrote:
> anon wrote:
>>
>> But to show the true power of what an Ada OS can do, the entire 
>> project from the ground up must be created in 100% Ada. Not just using 
>> Ada to rebuild an existing OS or to build a environmental shell like 
>> Windows on top of DOS was.
> There's absolutely no need to do 100% Ada environment. After all, it's 
> not simple. How do you suppose to manage version inconsistencies? Ada is 
> better suited for environments where every piece is fixed after 
> compilation and thus the whole program can be observed by compiler. It 
> is OK for embedded solutions. If you want to target dekstops, you need:
> 1) either binary platform (e. g. XPCOM, GLib, NSObject) that makes 
> possible changing different pieces without rebuilding the whole program. 
> Pure GNAT programs/libraries are even sensitive to compiler version.
> 2) or create an Ada virtual machine. Did you have BlueBottle or Inferno 
> in mind?
> 
> There are little desktop/server areas where one can exploit the full 
> power of Ada. First of all, it should be OK to recompile everything.
> 1. NAS distroes. Several NASes give ability to run custom software, and 
> FreeNAS is the example of such software. It can be single solid program 
> as well.
> 2. Ada CMS. It is also OK here to recompile everything. Recompiling 
> doesn't differ much from Zend Optimizing and the like.
> 
> In other cases the best way would be to forget all that false proudness. 
> 100% pragmatic as opposed to 100% Ada. We need to do the same (or nearly 
> the same) things as the others. If you look at GLib, Qt and NSObject 
> frameworks, you can see the common details:
> 1. Loosy structures. Arrays and dictionaries, most commonly. There is 
> GArray in GLib despite existence of arrays in C. Loosy structures enable 
> structure-agnostic data processing.
> 2. Some kind of component model.
> 
> First of all, there is a field for improvements here. Code generators 
> might create typed views on loosy structures. And the component model is 
> even wider field for improvements. I don't think that any of the 
> existing framework is the last word.
> 
> Dmitry Kazakov many times demanded multiple dispatch. AFAIK there is no 
> component model with MI support yet.
> 
> On the other hand there seem to be just 2 platforms allowing both local 
> and remote interoperation: COM and NSObject. XPCOM is only local 
> (1-process), UNO and CORBA are only remote.
> 

Re: AuroraUX Combines SunOS with Ada

[Ivan Levashew]

Per Sandberg wrote:

> Well I do not understand this statement since adding extra pieces of
> code aka plug-ins is very simple to achieve with any language and
> with Ada you get the safety as a bonus.

Adding, but what about changing and removing in the long term? Adding/
removing methods. It can't be easily achieved in Ada.

Adding new method in XPCOM requires defining new interface in an
ideal world. In the real world, XPCOM interfaces are modified in
situ, and it might result in a crash. In practice crashes are rarely
due to interface mismatch, because developers avoid unfrozen interfaces.

Compare it to NSObject: in NSObject there are no such problems.
Adding a method to a class has no consequences for code that uses
changed classes. Introducing new API is very easy on Mac OS X,
Etoile, GNUStep and Cocotron. Calling a removed method issues an
error as opposed to crashing. There still problems with NSObject
component model. One can introduce/remove methods but can't do it
with fields without breaking dependent code. Public Objective-C
classes often have reserved fields. Either pointer-to-object or array
of char.

Ada (pure Ada) doesn't address this problems at all. That's why
desktop OS based on Objective-C is possible and the one based on 100%
Ada isn't.

> but apart from that the languages are equal when it comes to dynamic
> loading etcetera.

GNAT libraries are sensitive to compiler version whereas G++ ones
aren't (the last ABI change was about 2.95 or so).


In Delphi, dynamically loaded libraries are also sensitive to compiler 
version. Closed source developers have to provide packages for every 
version of BDS.

It's bearable for standalone development environment, but not for OS as 
a whole.

-- 
If you want to get to the top, you have to start at the bottom

Re: AuroraUX Combines SunOS with Ada

[sjw]

What is 'loosy'? Apple's dictionary offers loony, loopy, loose, lossy,
lousy ...

Re: AuroraUX Combines SunOS with Ada

[Ivan Levashew]

sjw wrote:

> What is 'loosy'? Apple's dictionary offers loony, loopy, loose, lossy,
> lousy ...

I derived "loosy" from "loosely". Yes, it spells as "loose".

Anyway, it's not a term I've read somewhere. I observed the fact that 
everybody is doing virtually the same thing ad hoc, without naming this 
practice somehow.

-- 
If you want to get to the top, you have to start at the bottom

Re: AuroraUX Combines SunOS with Ada

[anon]

The idea of building an Ada OS by an "incremental" approach is an old school 
design that take too long and most of the developers will lose their focus over 
time or simply move to other projects. While the newer developers prefer to go
a different way with an OS. Aka a true Ada OS will never be written using an
"incremental" approach.

Why 100% Ada. A 100% Ada could prove the strengths of Ada and its 
weaknesses. Then the weaknesses could be fixed in the next specs. But 
without 100% Ada some of those weaknesses will be passed to the next 
specification and beyond. And that something that no Ada developer wants.

And for those who say that existing OS are good enought.  Each OS installation 
may be config differently, so each installation may boost some different Ada 
constructs while destorying others. Some of the projects that have been 
created by "Dmitry Kazakov" have demostated there is a need for an OS that 
boost the entire Ada constructs. Which in turn will shows its weaknesses so, 
the language of Ada can become the true powerhouse that Ada was design to be.

Also, as for "XPCOM, GLib, NSObject".  Those are old school! Should never be 
used in an Ada OS unless you want to cripple or destroy the OS. Only newer 
designed that comply with the Ada RM.  A lot of C project are created, 
violates the Ada RM, which gives one reason they should be no mix language
support in this OS.





In <_Edul.115295$2h5.72090@newsfe11.iad>, Paul Zacharzewski <gg@mail.oszi.org> writes:
>An interesting project.
>A "from the ground-up" approach has merit.
>I like the idea of an "incremental" approach.
>Sort of a "tin-woodsman" like approach.
>
>Chop off the bits and pieces of the OS, replace them with Ada.
>Until in the end only the kernel remains.
>
>Then you rewrite the kernel, or end up with a Hurd.

Re: AuroraUX Combines SunOS with Ada

[Rugxulo]

Hi,

On Mar 12, 6:53 pm, Ivan Levashew <octag...@bluebottle.com> wrote:
>
>
> GNAT libraries are sensitive to compiler version whereas G++ ones
> aren't (the last ABI change was about 2.95 or so).

This isn't true. They changed the ABI around 3.2 and again in 4.x.

Re: AuroraUX Combines SunOS with Ada

[Ivan Levashew]

anon wrote:
> 
> Why 100% Ada. A 100% Ada could prove the strengths of Ada and its 
> weaknesses.

So you insist on Ada virtual machine?

> Then the weaknesses could be fixed in the next specs.

Some weaknesses are indeniable blockers.

> But without 100% Ada some of those weaknesses will be passed to the next 
> specification and beyond.

That's OK. Every weakness is often strength from another side. There is
no silver bullet.

Every strength can be roughly classified as either synthesis or analysis
strength. The reality is so that S and A ones are mutually exclusive.
You can't catch both at the same time (although you can easily miss both
at the same time :)). Linear equations are easy to solve and analyze,
but they are linear. You can't easily solve arbitrary equations.
Analysis requires restricting synthesis and vice versa.

In IT world, demands are diverse and in order to fullfill them,
information systems are layered, with synthetic properties increasing
and analytic properties decreasing on each layer.

Ada has several restricted profiles and restricting tools (AdaControl,
SPARK) that give it opportunity to reside into inner(analytical) layers,
but building a cool OS also requires synthetic properties not present in
Ada. 100% Ada makes no sense.

> created by "Dmitry Kazakov" have

Usenet is not bash. Disaster won't happen if you omit quotes around
names here.

> Also, as for "XPCOM, GLib, NSObject".  Those are old school!

Given the same circumstances and the same goals, people are likely to
produce the same solutions.

What is new school then? "100% Ada" says nothing about the approach it
is gonna be implemented.

> A lot of C project are created, violates the Ada RM, which gives one
> reason they should be no mix language support in this OS.

Let C go alone. What about Free Pascal, Cyclone, Limbo etc. developers?
Do you want to shut the door for them? Why?

-- 
If you want to get to the top, you have to start at the bottom

Re: AuroraUX Combines SunOS with Ada

[anon]

No virtual machine! All VM are only as good as the host OS.  And if a problem 
exist in the host OS then those errors will be magnified in the VM. And a true 
Ada OS would never work in a VM environment, the Ada OS must be the 
"New Law Giver". The only VM that would be allowed is for processor sizing 
programs, such as 16, 32, 64, 128 and may be even 256 bit programs.

Now, the main reason the same weakness exist in future version of a language
is from the maintainer believing the error is in the host OS instead of the 
language. And in some cases a maintainer may have a limited focus to fix 
such weakness.

As for picking on C, that because most OS and system developers, today use 
C. But other languages like Pascal were also used to create a 100% language 
OS. TI created the DX10 OS using 100% Pascal back in the 1980s for the 
TI-990 mini and micro computers. The DX10 was used throughout the life of 
that TI-990 series.  One of the funnier problems was that any Pascal program 
running under the DX10 system, dominated (non-preemptive) the system 
resources over other non-Pascal programs. Compile a student Pascal program 
and shutdown all other non-Pascal code.
                       
And if you do a little studying you will see that almost every language 
including COBOL has been used for a 100% language version OS.  Should Ada 
be denied the respect to try to prove itself for using 100% language OS? 
The answer is "NO"!

And in ever case, where a single language like Pascal, C, JAVA or etc. was 
used to create an OS they have failed.  One reason might be due to the nature 
of the language itself.  Like Pascal was created for an educational language 
to teach programming, it was never intended to be use for anything else. C 
was created in 1972 for a general purpose language for the 3 year old AT&T 
"unix".  It was never created to be used as a system language, even though 
most programmers today still use C for their system language. And other 
languages like COBOL and FORTRAN were never meant to be use to create 
an OS but there are OSs based on those languages. And in each case, some 
of the errors that are embedded in the OS can be linked to some of weakness 
in the language they were written in.  

One weakness of these language based OS is the needs to operate in a safe 
mission critical matter.  The only language that has that attribute built-in is 
"Ada". So, why 100% Ada, well injecting other languages like C, or Pascal 
could prevent the OS from being a true safe mission critical OS. And just 
converting programs or projects to Ada mean that the safe mission critical 
design can not be guarantee either because it might be the API that is not 
secure.

So, now why are you so against using 100% Ada to building an OS.

Just Food for thought!

Everybody knows that the new "Windows 7" will not be prefect. But are the 
errors embedded so that Microsoft can come out with the next OS version in 3 
years. Or has Microsoft been too cheap in hiring it labor force (programmers 
and testers) to create the new "Windows 7". Or will you find some of the 
fault in the languages that Microsoft used in building "Windows 7".  Only 
time will tell us! Plus, the first reason is illegal.


In <gph7gh$dmm$1@octagram.motzarella.org>, Ivan Levashew <octagram@bluebottle.com> writes:
>anon wrote:
>> 
>> Why 100% Ada. A 100% Ada could prove the strengths of Ada and its 
>> weaknesses.
>
>So you insist on Ada virtual machine?
>
>> Then the weaknesses could be fixed in the next specs.
>
>Some weaknesses are indeniable blockers.
>
>> But without 100% Ada some of those weaknesses will be passed to the next 
>> specification and beyond.
>
>That's OK. Every weakness is often strength from another side. There is
>no silver bullet.
>
>Every strength can be roughly classified as either synthesis or analysis
>strength. The reality is so that S and A ones are mutually exclusive.
>You can't catch both at the same time (although you can easily miss both
>at the same time :)). Linear equations are easy to solve and analyze,
>but they are linear. You can't easily solve arbitrary equations.
>Analysis requires restricting synthesis and vice versa.
>
>In IT world, demands are diverse and in order to fullfill them,
>information systems are layered, with synthetic properties increasing
>and analytic properties decreasing on each layer.
>
>Ada has several restricted profiles and restricting tools (AdaControl,
>SPARK) that give it opportunity to reside into inner(analytical) layers,
>but building a cool OS also requires synthetic properties not present in
>Ada. 100% Ada makes no sense.
>
>> created by "Dmitry Kazakov" have
>
>Usenet is not bash. Disaster won't happen if you omit quotes around
>names here.
>
>> Also, as for "XPCOM, GLib, NSObject".  Those are old school!
>
>Given the same circumstances and the same goals, people are likely to
>produce the same solutions.
>
>What is new school then? "100% Ada" says nothing about the approach it
>is gonna be implemented.
>
>> A lot of C project are created, violates the Ada RM, which gives one
>> reason they should be no mix language support in this OS.
>
>Let C go alone. What about Free Pascal, Cyclone, Limbo etc. developers?
>Do you want to shut the door for them? Why?
>
>-- 
>If you want to get to the top, you have to start at the bottom

Re: AuroraUX Combines SunOS with Ada

[Ivan Levashew]

anon wrote:

> No virtual machine! All VM are only as good as the host OS.  And if a problem 
> exist in the host OS then those errors will be magnified in the VM. And a true 
> Ada OS would never work in a VM environment, the Ada OS must be the 
> "New Law Giver". The only VM that would be allowed is for processor sizing 
> programs, such as 16, 32, 64, 128 and may be even 256 bit programs.

OK, let it be not VM but a compiler that can recompile every dependent 
package on demand. Is it a viable solution?

>                        
> And if you do a little studying you will see that almost every language 
> including COBOL has been used for a 100% language version OS.  Should Ada 
> be denied the respect to try to prove itself for using 100% language OS? 
> The answer is "NO"!
> 
Do you mean desktop OS? Desktop OS needs several freedoms that Ada won't 
provide for free.

> One weakness of these language based OS is the needs to operate in a safe 
> mission critical matter.  The only language that has that attribute built-in is 
> "Ada". So, why 100% Ada, well injecting other languages like C, or Pascal 
> could prevent the OS from being a true safe mission critical OS. And just 
> converting programs or projects to Ada mean that the safe mission critical 
> design can not be guarantee either because it might be the API that is not 
> secure.
> 
There are MaRTE and PaRTiKle for mission critical tasks.

> So, now why are you so against using 100% Ada to building an OS.

Did you noticed there is no 100% C++ desktop OS despite C++ fans all around.

> 
> Everybody knows that the new "Windows 7" will not be prefect. But are the 
> errors embedded so that Microsoft can come out with the next OS version in 3 
> years. Or has Microsoft been too cheap in hiring it labor force (programmers 
> and testers) to create the new "Windows 7". Or will you find some of the 
> fault in the languages that Microsoft used in building "Windows 7".  Only 
> time will tell us! Plus, the first reason is illegal.
> 
Microsoft is a mere seller. Consumer governs the world. If consumer 
never minds paying for C++ programs (and is proud of paying for C++ 
programs), consumer is the one to blame.

-- 
If you want to get to the top, you have to start at the bottom

Re: AuroraUX Combines SunOS with Ada

[Paul Zacharzewski]

anon wrote:

> Everybody knows that the new "Windows 7" will not be prefect. But are the 
> errors embedded so that Microsoft can come out with the next OS version in 3 
> years. Or has Microsoft been too cheap in hiring it labor force (programmers 
> and testers) to create the new "Windows 7". Or will you find some of the 
> fault in the languages that Microsoft used in building "Windows 7".  Only 
> time will tell us! Plus, the first reason is illegal.
> 

I don't know if I understand why the first reason would be illegal. If I
were a MS shareholder, I would like knowing that a just released product 
would be good enough for everyone to buy, but could be improved enough
so that 3 years down the road, everyone will be excited about W8. Errors
are not intentional, but temporarily ignoring them can be a good
strategy to make your customers await your next product release.

That's why I doubt any company would profit much in creating a 100%
Ada OS. (outside of embedded, or mission critical software)

It would be like going to an auto mechanic and the mechanic tells you "I
just fixed your car. It will never rust, the engine is not due for a
check-up for another 1 million KM and now it's much safer, it is almost
uncrashable."

It is better for an Ada based desktop/server OS to have the ability to
run code written in other languages. Otherwise you would have to
re-write software which is not essential to the running of the OS but is
essential to the OS being useful (Firefox as an example).

But starting from scratch and writing everything in 100% Ada is far more
difficult than using an existing project and replacing elements until a
100% Ada OS is achieved. Unix has been developed since the early 70's.
The BSD's have been around since the 80's. Linux has been around since
the 90's. Time-tested designs would help the developer to not re-invent
the wheel while also having to re-write it. I think developing from
scratch would be far more labor-intensive and error-prone.

Re: AuroraUX Combines SunOS with Ada

[Colin Paul Gloster]

Dear all,

It may be tempting to try AuroraUX because of the involvement of
Ada. However, I have noted that it uses the ZFS filesystem format,
which unless ZFS was improved recently, is a bad filesystem
format. (ZFS was supposed to be better than UFS, which I have heard is
also supposed to be bad.)

Before the AuroraUX OpenSolaris distribution became available, I tried
many OpenSolaris distributions. Initially some seemed to exhibit
potential for being good, but a ZFS problem eventually manifested
itself and as a result of this I do not plan to risk my time on
OpenSolaris (whether as AuroraUX or not) in the near future.

You can read more details in my post "Re: ZFS pool question" in the
newsgroups comp.unix.solaris and alt.solaris.x86 from December 2008.

Yours faithfully,
C. P. G.

Re: AuroraUX Combines SunOS with Ada

[Ivan Levashew]

Ivan Levashew wrote:

> First of all, there is a field for improvements here. Code generators 
> might create typed views on loosy structures. And the component model is 
> even wider field for improvements. I don't think that any of the 
> existing framework is the last word.
> 
> Dmitry Kazakov many times demanded multiple dispatch. AFAIK there is no 
> component model with MI support yet.
> 

I have just found that:

http://en.wikipedia.org/wiki/System_Object_Model

> SOM is also much more robust in terms of fully supporting a wide 
> variety of OO languages. Whereas basic COM essentially defines a 
> cut-down version of C++ to program to, SOM supports almost all common
> features and even some more esoteric ones. For instance SOM supports
> multiple inheritance, metaclasses and dynamic dispatching. Some of 
> these features are not found in most languages, which had led most 
> SOM/COM-like systems to be simpler at the cost of supporting fewer 
> languages. The full flexibility of multi-language support was 
> important to IBM, however, as they had a major effort underway to
> support both Smalltalk (single inheritance, dynamic dispatch) with
> C++ (multiple inheritance, fixed dispatch).
> 
> The most notable difference between SOM and COM is support for 
> inheritance � COM does not have any. It might seem odd that Microsoft
> produced an object library system that could not support one of the 
> most fundamental concepts of OO programming; the main reason for this
> is that it is difficult to know where a base class exists in a system
> where libraries are loaded in a potentially random order. COM demands
> that the programmer specify the exact base class at compile time,
> making it impossible to insert other derived classes in the middle
> (at least in other COM libraries).

Sounds awesome. Really awesome.

I have heard that OS/2 was superior but didn't imagine that it was 
superior to that extent.

-- 
If you want to get to the top, you have to start at the bottom