Re: Why .ads as well as .adb?

[Brad Moore <bmoore.ada@gmail.com>]

On Friday, June 7, 2019 at 1:59:26 AM UTC-6, Maciej Sobczak wrote:
> > Of course, you are essentially saying that separate 
> > compilation is unnecessary and all of the source for a program should be in 
> > one giant file
> 
> Of course you are proving now that you did not understand the question posted earlier in this thread.
> 
> 1. There *are* languages that don't use separate spec files. Java and Python are well known examples, representing both compiled and scripted approaches.

I suspect that may be more to do with language limitations than anything else,
where the compiler needs to "see" all the code to generate the executable.
I think the same could be said of C++ templates, where the template header file contains all the code, so that the compiler can generate the executable when that source code is inserted into another source file via an #include preprocessor directive.

I am not a Java expert, but I note that Java didn't have modules until 2017 in Java 9, but by then Java coding styles were already cemented in through years of usage. Ada had compiled modules and separate compilation in the form of packages since the beginning.

Bolting on features to languages after the fact can be an improvement, but it helps a lot if the language was well designed from the start.

I think it is a big mistake of languages that encourage the specification and implementation to be in the same source file, and very surprised to see that anyone would be arguing for that.

The separation of specification and implementation ties into the "separation of concerns" attributed to Dijkstra way back in 1974.

When wanting to make use of a 3rd party package in Ada, I value being able to generally understand how to use that package by looking at the specification without having to look at the implementation. You generally only need to look at the public part of a package specification, as you can rely on anything past that as being implementation details.

Even with C++, one cannot stop reading when you see a private: keyword in a class definition, because there can be many public and private sections in a class. You have to keep reading the class specification until to hit the end of the class specification, in case you missed more public parts.

I think Ada does a better job of getting the programmer to separate specification from implementation.

This can become really valuable when programming in the large. For this reason, I think Python is not a good choice for developing a very large system.

I see it as a nice language for writing smaller programs, scripts, and glue-code, etc.

I suspect that when teaching programming languages, small examples are provided that demonstrate language features, and packages in Ada are often not needed. For example, if one looks at the Ada examples in the Rosetta code website, 

http://www.rosettacode.org 

You will often see examples that do not use packages. So Ada does seem to provide good capabilities write examples in a single file when that is needed.

When you work on a large system however, you quickly learn to appreciate the separation of specification and implementation however. 

> 
> 2. Programs written in those languages do *not* need to be written in one giant file. Actually, Java is frequently criticized (it was even in this thread) for forcing the programmer to use too many (!) files. Even though it does not have separate specs.

Maybe Ada offers a benefit here. In languages like Java, there is a tendency to want to put each class in a separate file. With Ada packages, it can make more sense to organize related types in the same package.

Brad