Reliable enough means can not stop. Or if it does stop games over. Without too much detail we disable interupts on some of our processors so we can get quasi real time performance for the lone process on the processor. They must stay running for a long long long time or die gracefully. If they crash we lose the cpu the process is running on till a reboot so that isn't an option.

One of ada's really cool features is to allow you to rep-spec any record (struct in c). This allows you allign the data structure to match input messages from various bits of hardware (ie the status byte starts at byte 4, bit3 and is 8 bits long). This is harder in perl, although it probably could be done. .

Stongly Typed. When we compile the compiler checks all the assignment to make sure they're legal and legit and won't cause problems. Its not an end all but it helps a lot. We also contrain types. For example an integer to between 10 and 20. If the variable ever gets out of this range during run time an exception is thrown and handled by other parts of our code. Its excessive but it has to be. especially when you sending data out that might turn a motor etc. That way external hardware is never getting data out of range.

Ada coding is slow and the support is poor. We have to write some of our own libraries or bind to C. Perl has a much more robust user base and libraries. Perl is great for a lot of things and can be coded to be pretty reliable. For somethings there are better solutions.

Stongly Typed. When we compile the compiler checks all the assignment to make sure they're legal and legit and won't cause problems. Its not an end all but it helps a lot. We also contrain types. For example an integer to between 10 and 20. If the variable ever gets out of this range during run time an exception is thrown and handled by other parts of our code.

I suspect that you are right and that Perl is not the tool for the job you have to do. I'm not going to disagree with that at all. I'm a big fan of using the right tool for the job.

But have you ever had look at Attribute::Types? It's what I'd use to achieve some of what you've specified above.

Attribute::Types allow you to write code like the following:

use Attribute::Types;

my $count : INTEGER;        # Can only store an integer
my $restr : INTEGER(10..20) # Can only store an integer 
                            # between 10 and 20.
my $some  : Type(&somesub); # Can only store values for 
                            # which somesub() returns true.
[download]

All of this checking is done at run-time which makes things a little bit harder than other strongly typed languages, but it does give you this functionality if you wish.

Hope this helps,

jarich

Ah, I take your meaning now, and I think I agree with you. For the type of applications you describe, perl probably isn't the best choice.

Your language isn't just strongly typed, it's hyper-typed. You've got the same strength that Oracle provides for you with CHECK constraints.

Now, you can provide the same capabilities re: integers between 10 and 20, either with Attribute::Types (as sporty says) or with overload. There are ways. You can even write source filters, if you need to.

------
We are the carpenters and bricklayers of the Information Age.

Then there are Damian modules.... *sigh* ... that's not about being less-lazy -- that's about being on some really good drugs -- you know, there is no spoon. - flyingmoose