Re: S-expression I/O in Ada

[Jeffrey Carter <spam.jrcarter.not@spam.not.acm.org>]

On 08/07/2010 10:01 AM, Natacha Kerensikova wrote:
>
> Let's get everything straight: I'm amateur. I'm coding for fun. Well,
> I'll so be coding for a living too, but then I won't have a say in the
> language chosen. I like coding in C, and I don't care how efficient it
> is. There is not waste of time in a leisure activity. I'd rather have
> fun with C rather than doing the same thing 10x faster without fun.
> The only thing bothering me in C is that I often end up using
> dangerous construct. For example, *(struct foo **)((char *)whatever +
> bar.offset). While I'm perfectly fine with that, because I'm confident
> in what I'm doing, but I can understand it looks sloppy from the
> outside. My main motivation to learn Ada is publicize the concerns for
> robustness and correctness that might not be obvious from my C code. I
> was hoping to do Ada whatever I used to be doing in C: network
> programming, DS homebrew, etc.
>
> Am I misguided? Should I stop now?

One can do anything you can do in C in Ada. Better, since creating buffer 
overflow and signed-integer overflow vulnerabilities takes effort in Ada, while 
they're the default in C. (Virtually every "important security update" I see for 
Linux is a buffer overflow or signed-integer overflow vulnerability. I doubt if 
people are creating these on purpose. My conclusion is that it is impossible in 
practice to use C without creating these errors.)

> Ok, so let's have a look at the grand picture. My main objective right
> now is to code a webserver in Ada. Yes, that's reinventing the wheel,
> but it does wonders for learning.
>
> Here is how I intended to do it, admittedly exactly like I would do it
> in C, could you please tell me how far I am from the Ada approach?

It's hard to comment meaningfully, since you mostly describe your intended 
implementation, not your requirements.

I'd use Ada Web Server (AWS), and perhaps you should try that, too. Using a 
significant, existing, high-level Ada application framework like that might help 
introduce you to how some experienced Ada people thought this kind of thing 
should be approached.

A "web server" can be a variety of things, from a simple page server that serves 
static files to a highly-dynamic system generating everything on the fly. It 
appears that you intend something that serves static files and expanded page 
templates.

Initially, I'd observe that the system talks to the network and to the permanent 
storage that stores the configuration information, static pages, and so on. So 
my initial decomposition would identify interface modules for communicating with 
these. (This is an "edges-in" approach.)

At a higher level, there is something that responds to incoming requests to 
serve the appropriate responses. There's something this uses to obtain the 
configuration from the permanent storage. This could make use of something that 
can serve a static page and something that can serve an expanded page template. 
There's also clearly a place for something that expands a page template.

I'm doing this off the top of my head, so I won't be surprised if I've missed 
something or otherwise screwed up.

This identifies the major high-level modules in the system. I could now define 
the package specifications for them and have the compiler check that they are 
syntactically correct and semantically consistent. Then I could pick one and 
design its implementation. It's likely at some point tasking would be involved, 
allowing the processing of multiple requests at once, so this would all have to 
be done keeping concurrency in mind.

At some point I'd get to a low enough level to start thinking about 
representations, which seems to be where you begin your thinking about the problem.

> As I'm more comfortable using components already coded and tested, I
> would code them from the lowest to the highest level:

In Ada, one can create package specifications, then create other units that make 
use of those specifications before they are implemented. This is an important 
concept in Ada called the separation of specification and body. Sometimes it is 
useful to create stub bodies for such packages, which can then be used to test 
the units that make use of these packages. Thus it is often possible to 
implement and test higher-level modules before lower-level modules that they use 
have been implemented. This may not be especially useful on a single-person 
project, but can be quite valuable in projects with more than one developer. 
This often seems to be a foreign concept to those used to C.

While your approach seems quite different to mine, many aspects of the final 
result seem to be similar. This probably bodes well for you being able to use 
Ada effectively.

-- 
Jeff Carter
"I blow my nose on you."
Monty Python & the Holy Grail
03

--- news://freenews.netfront.net/ - complaints: news@netfront.net ---