Re: Prototyping with Ada

[Stephen Leake <Stephe.Leake@nasa.gov>]

John McCabe <john@nospam.assen.demon.co.uk> writes:

> On Sun, 18 May 2008 10:04:17 +0200, Ludovic Brenta
> <ludovic@ludovic-brenta.org> wrote:
>
>>> For very prototyping simple projects, scripting languages are fast,
>>> but errors and inconsistencies creep in quickly.  The code tends not
>>> to last as long because of inflexibility (poor/missing structuring tools
>>> such as packages and generics in scripting).
>
>>I agree.  I would even go so far as to say there is no such thing as
>>software prototyping.  A prototype is something complex you make
>>before mass-producing some sort of physical good, because it is very
>>difficult to change the physical system after you've made it, should
>>you find any problems.  By definition, you know you're going to throw
>>the prototype away at some point.
>>
>>The opposite is true for software.  If you build a prototype, you can
>>always fix problems in it.  And once there are no more problems, the
>>prototpye is the "real" software, and you don't throw anything away.
>
> Ah, but this is one of the reasons there is so much poor quality
> software around! If you do it right, a prototype should give you an
> idea of how you are going to approach a solution, and should show up
> certain features or situations that you need to handle, or avoid in
> order to make that solution appropriate, reliable and acceptable.
>
> Thus you need to plan for the prototype to be thrown away, because
> then you start again taking into account the lessons you learned from
> the protoyping exercise.
>
> Of course, if there is some self-contained code that can be re-used,
> e.g. a particularly complicated algorithm in its own little "space",
> then it is reasonable to do so, as long as you make it more reliable
> and so on in the process.
>
> If you approach the whole thing from the point of view you describe,
> then you're just taking what may be poor quality code and making it a
> bit better, which doesn't necessarily make the code (or design!) good.

If you do refactoring right, you can incrementally improve the quality
of code.

I think there is a spectrum here; "gross refactoring" is simply
throwing away huge chunks of code and starting over for those; "fine
refactoring" is tinkering with a few lines here and there. Anything
inbetween is possible, and can be useful.

I prefer prototyping with Ada; the compiler finds bugs for me, and
with GNAT and Emacs on current hardware, the compile/edit/run cycle is
very fast.

I have to use Matlab for part of my current job, because another part
of the project uses it. The lack of software engineering in that
language is glaring, and my productivity (in something approximating
"implemented features per day") is much lower in Matlab than in Ada.
That's partly because I can't figure out how to run Matlab from the
command line under Emacs (on Windows), and the Matlab GUI is just not
as powerful as Emacs.

-- 
-- Stephe