Re: S-expression I/O in Ada

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

On 08/08/2010 06:11 AM, Natacha Kerensikova wrote:
>
> Well actually the requirements were presented in the beginning: I've
> got a S-expression configuration file, a directory of static files, a
> directory of S-expression templates and a directory of S-expression
> data to populate the templates. And I want to respond to HTTP request
> with either a static file or an expanded template. Now I might
> misunderstanding the word "requirements", but what I actually consider
> as requirements is the above without any "S-expression" occurrence,
> the rest being implementation choices. "S-expression" might be part of
> the requirements to use existing data, but then again another format
> can be chosen provided a converted from S-expression is also coded.

Most of what you presented seem more like implementation decisions 
(S-expressions for the configuration information, S-expressions for the page 
templates) than requirements. Even discussion of files and directories might be 
premature, depending on the higher level requirements. A web server that can be 
used in an embedded system as the external interface as well as as a stand-alone 
system would need a more abstract view of permanent storage, for example.

Of course, sometimes implementation decisions are made by others and become part 
of one's requirements, but I wouldn't expect that in a personal project. And the 
existence of an existing library can be an important factor when masking such 
decisions.

I wasn't saying that implementing an S-expression library, or deciding to use it 
at a low level in your project, was a bad thing. I was viewing this project as a 
separate thing from your S-expression library.

> Thanks for the pointer, however I'm already afraid learning only Ada
> is too much for me (I've tried with C++ and it's a language much too
> complex to fit in my head (especially the STL), and I hope Ada is
> simple enough), learning both Ada and AWS at the same time will
> probably be way too much. However I haven't decided yet whether I will
> actually begin with this project, I might try to code something
> simpler before that (which will also need S-expressions, hence my
> beginning with that library). In that case, I might be confident
> enough in my Ada before starting the web project, and then go for AWS.

I think something like AWS would help you learn Ada. You need to look at 
existing code as well as write your own. Starting with the library has good and 
bad points. It's a fairly small, contained project, which is good. On the other 
hand, the first things you write in Ada are probably not going to be great. In a 
few months you'll probably look at the library and want to make significant 
changes to it.

Ada is simpler than C++. It's also fairly well designed, so most features are 
orthogonal, which simplifies learning the language.

> Actually, that's very similar to what I thought too. It's just that
> I've already thought so much about this project that I'm further down
> the road, and I tried to fit everything in the one-dimension of a
> text.

I'm glad to hear that. Perhaps I simply misinterpreted your presentation.

> That's actually a pretty strange thing I've never encountered yet in
> other coders I know, I first spend a lot of time thinking before
> writing the first line of code (or that particular case, before even
> managing to install the compiler). I also spend much less time
> debugging, though I can't tell whether they are related or whether one
> of them is more efficient than the other.

Excellent. The whole point of Ada is thinking before coding, so you'll probably 
find that Ada supports your way of doing things. It's a common experience that 
if you did think first, by the time you get your code to compile, it works 
correctly. Ada people don't do a lot of debugging; I can't remember the last 
time I used a debugger. When we do have problems, they tend to be logic errors 
rather than typos.

> Unless I'm very misunderstanding and/or vary naive, I've got the
> feeling our approaches are not that different, and differ mostly in
> the order of implementation, which indeed doesn't change that much in
> the final result.

You may well be right, in which case you'll likely find Ada to be a good fit for 
your way of approaching things.

-- 
Jeff Carter
"I wave my private parts at your aunties."
Monty Python & the Holy Grail
13

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