Ada Advocacy - WPG (Web Page Generation) scheme

Ada Advocacy - WPG (Web Page Generation) scheme

[Nick Roberts]

I've had an idea (not a blindingly original one) which might be a way to
help promote Ada. Dynamic web content is all the rage these days; there are
dozens of techniques used by millions of people to achieve it, including but
not limited to SSI, ASP, JSP, PHP, CGI, and many other acronyms.

How to get Ada into this picture?

I think one of the big attractions of schemes like ASP, JSP, and PHP (to
name but three) is that to use them you merely have to embed a few special
directives into an otherwise ordinary HTML file, and often the directives
are very simple.

So, it seems to me, an attractive scheme would be to allow Ada code to be
embedded into an HTML file. A special program would transform this file into
a complete Ada program (procedure Main is ...) in a .adb file. The Ada
program would be a complete CGI program: you upload it, and compile it into
your cgi-bin directory. It could 'with' a simple package providing support
for the CGI protocol (and HTTP/HTML web page generation); I'm aware of an
existing AdaCGI package that might suit this.

Since a TLA (three-letter acronym) seems to be obligatory for these things,
we might call it 'WPG' for Web Page Generation. The source file containing
the HTML with embedded Ada could then have the .wpg extension. Other
possibilities that occur to me are: DWP (Dynamic Web Pages); HRA (Hypertext
Response with Ada). The sillier the better, really.

The special program doing the translation (from WPG to Ada) - let's call it
the WPGT - would (naturally!) be written in Ada, and I think it should be
quite simple to write. Obviously I'm volunteering, if nobody else makes a
claim.

I propose the following embedding syntax.

Ada code would be embedded between an opening bracket and a closing bracket,
forming an 'insertion' into the HTML file. There would be three sets of
brackets for this: one set would be used for an expression whose value is to
replace the insertion; another set would be used for Ada statements to be
executed at the point of the insertion (which is replaced by nothing); the
third set would be used for any declarations the expressions or statements
might need (also replaced by nothing). I propose the brackets be [= and =]
for the expressions [# and #] for the statements and [: and :] for the
declarations.

I also propose that [$ and $] brackets can be used to surround the name of a
macro file to be included (and then itself expanded), since this would be
easily done by the WPGT at the same time as the transformation, and is a
very handy facility.

So, for example, I might have a file "showtime.wpg" as follows:

~~~
[$pagehead.txt$]
<title>[=Film.Title=] - Showing Times</title>
[$pagetop.txt$]
<h2>Showing Times for the Film: <a
href="filminfo?num=[=Film.Ref=]">[=Film.Title=]</a></h2>
<table>
<tr> <th>date</th> <th>time</th> </tr>
[# for i in Film.Screenings.all'Range loop #]
<tr> <td>[=Film.Screenings(i).Date=]</td>
<td>[=Film.Screenings(i).Time=]</td> </tr>
[# end loop; #]
</table>
[$pagebtm.txt$]
</body>
</html>
~~~

The idea is that the WPGT would translate this into something like the
following program file "showtime.adb":

~~~
procedure Main is
begin
Put_Line("Content-type: text/html");
New_Line;
... stuff from pagehead.txt
New_Line;
Put("<title>");
Put(Film.Title);
Put(" - Showing Times</title>");
New_Line;
... stuff from pagetop.txt
New_Line;
Put("<h2>Showing Times for the Film: <a href=""filminfo?num=");
Put(Film.Ref);
Put(""">");
Put(Film.Title);
Put("</a></h2>");
New_Line;
Put("<table>");
New_Line;
Put("<tr> <th>date</th> <th>time</th> </tr>");
New_Line;
 for i in Film.Screenings.all'Range loop
New_Line;
Put("<tr> <td>");
Put(Film.Screenings(i).Date);
Put("</td> <td>");
Put(Film.Screenings(i).Time);
Put("</td> </tr>");
New_Line;
 end loop;
New_Line;
Put("</table>");
New_Line;
... stuff from pagebtm.txt
New_Line;
Put("</body>");
New_Line;
Put("</html>");
New_Line;
end;
~~~

One big selling point would be that your dynamic web pages are generated by
a native code compiled program; a bit more efficient than a script. Another
point is that you have the full facilities of Ada programming available to
you (utility packages, bindings, and so on).

Other possibilities include: allow the name of a package to be 'withed'
between [+ +] brackets; provide some handy translation-time values, e.g.
[?UPDATE?] to be replaced by the date and time the translation is executed.

Some issues I can see are:

(1) HTTP headers. You'll see my example program above generates one HTTP
header line. I get the impression that the headers a CGI program is supposed
to generate are not very well defined anywhere. I think AdaCGI has a
procedure to generate CGI headers; handy, but correct?

(2) Conversion of < > and & characters into escaped forms in fields. I think
AdaCGI has a function to do this; could it be done automatically?

(3) Access to databases. Most CGI programs and web scripts need to get their
information from a database, and some update databases too. I'm aware of a
project to produce a binding to PostgreSQL and MySQL; might this be what is
needed?

(4) Most hosting companies don't allow binary CGI programs, for "security
reasons" (i.e. their own stupidity). Of those which do, many refuse to
install GNAT (despite providing GCC C++). Outrageous. However, I know at
least one hosting company (Liquid Web, http://www.liquidweb.com/ ) who is
willing to install GNAT, so maybe this isn't a hopeless problem.

Comments?

If I do this, I would like to make it a project at BerliOS (
http://developer.berlios.de ). I've been a bit disappointed with the service
at SourceForge recently, but they have got new servers in recently. So, if I
do this project, where should I host it?

--
Nick Roberts
Jabber: debater@charente.de [ICQ: 159718630]

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Larry Kilgallen]

In article <blnaim$ebkh3$1@ID-25716.news.uni-berlin.de>, "Nick Roberts" <nickroberts@blueyonder.co.uk> writes:

> Since a TLA (three-letter acronym) seems to be obligatory for these things,
> we might call it 'WPG' for Web Page Generation.

I think a better acronym would have a vowel in the middle so it could be
pronounced.

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Stephane Richard]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 6855 bytes --]

"Nick Roberts" <nickroberts@blueyonder.co.uk> wrote in message
news:blnaim$ebkh3$1@ID-25716.news.uni-berlin.de...
> I've had an idea (not a blindingly original one) which might be a way to
> help promote Ada. Dynamic web content is all the rage these days; there
are
> dozens of techniques used by millions of people to achieve it, including
but
> not limited to SSI, ASP, JSP, PHP, CGI, and many other acronyms.
>
> How to get Ada into this picture?
>
> I think one of the big attractions of schemes like ASP, JSP, and PHP (to
> name but three) is that to use them you merely have to embed a few special
> directives into an otherwise ordinary HTML file, and often the directives
> are very simple.
>
> So, it seems to me, an attractive scheme would be to allow Ada code to be
> embedded into an HTML file. A special program would transform this file
into
> a complete Ada program (procedure Main is ...) in a .adb file. The Ada
> program would be a complete CGI program: you upload it, and compile it
into
> your cgi-bin directory. It could 'with' a simple package providing support
> for the CGI protocol (and HTTP/HTML web page generation); I'm aware of an
> existing AdaCGI package that might suit this.
>
> Since a TLA (three-letter acronym) seems to be obligatory for these
things,
> we might call it 'WPG' for Web Page Generation. The source file containing
> the HTML with embedded Ada could then have the .wpg extension. Other
> possibilities that occur to me are: DWP (Dynamic Web Pages); HRA
(Hypertext
> Response with Ada). The sillier the better, really.
>
> The special program doing the translation (from WPG to Ada) - let's call
it
> the WPGT - would (naturally!) be written in Ada, and I think it should be
> quite simple to write. Obviously I'm volunteering, if nobody else makes a
> claim.
>
> I propose the following embedding syntax.
>
> Ada code would be embedded between an opening bracket and a closing
bracket,
> forming an 'insertion' into the HTML file. There would be three sets of
> brackets for this: one set would be used for an expression whose value is
to
> replace the insertion; another set would be used for Ada statements to be
> executed at the point of the insertion (which is replaced by nothing); the
> third set would be used for any declarations the expressions or statements
> might need (also replaced by nothing). I propose the brackets be [= and =]
> for the expressions [# and #] for the statements and [: and :] for the
> declarations.
>
> I also propose that [$ and $] brackets can be used to surround the name of
a
> macro file to be included (and then itself expanded), since this would be
> easily done by the WPGT at the same time as the transformation, and is a
> very handy facility.
>
> So, for example, I might have a file "showtime.wpg" as follows:
>
> ~~~
> [$pagehead.txt$]
> <title>[=Film.Title=] - Showing Times</title>
> [$pagetop.txt$]
> <h2>Showing Times for the Film: <a
> href="filminfo?num=[=Film.Ref=]">[=Film.Title=]</a></h2>
> <table>
> <tr> <th>date</th> <th>time</th> </tr>
> [# for i in Film.Screenings.all'Range loop #]
> <tr> <td>[=Film.Screenings(i).Date=]</td>
> <td>[=Film.Screenings(i).Time=]</td> </tr>
> [# end loop; #]
> </table>
> [$pagebtm.txt$]
> </body>
> </html>
> ~~~
>
> The idea is that the WPGT would translate this into something like the
> following program file "showtime.adb":
>
> ~~~
> procedure Main is
> begin
> Put_Line("Content-type: text/html");
> New_Line;
> ... stuff from pagehead.txt
> New_Line;
> Put("<title>");
> Put(Film.Title);
> Put(" - Showing Times</title>");
> New_Line;
> ... stuff from pagetop.txt
> New_Line;
> Put("<h2>Showing Times for the Film: <a href=""filminfo?num=");
> Put(Film.Ref);
> Put(""">");
> Put(Film.Title);
> Put("</a></h2>");
> New_Line;
> Put("<table>");
> New_Line;
> Put("<tr> <th>date</th> <th>time</th> </tr>");
> New_Line;
>  for i in Film.Screenings.all'Range loop
> New_Line;
> Put("<tr> <td>");
> Put(Film.Screenings(i).Date);
> Put("</td> <td>");
> Put(Film.Screenings(i).Time);
> Put("</td> </tr>");
> New_Line;
>  end loop;
> New_Line;
> Put("</table>");
> New_Line;
> ... stuff from pagebtm.txt
> New_Line;
> Put("</body>");
> New_Line;
> Put("</html>");
> New_Line;
> end;
> ~~~
>
> One big selling point would be that your dynamic web pages are generated
by
> a native code compiled program; a bit more efficient than a script.
Another
> point is that you have the full facilities of Ada programming available to
> you (utility packages, bindings, and so on).
>
> Other possibilities include: allow the name of a package to be 'withed'
> between [+ +] brackets; provide some handy translation-time values, e.g.
> [?UPDATE?] to be replaced by the date and time the translation is
executed.
>
> Some issues I can see are:
>
> (1) HTTP headers. You'll see my example program above generates one HTTP
> header line. I get the impression that the headers a CGI program is
supposed
> to generate are not very well defined anywhere. I think AdaCGI has a
> procedure to generate CGI headers; handy, but correct?
>
> (2) Conversion of < > and & characters into escaped forms in fields. I
think
> AdaCGI has a function to do this; could it be done automatically?
>
> (3) Access to databases. Most CGI programs and web scripts need to get
their
> information from a database, and some update databases too. I'm aware of a
> project to produce a binding to PostgreSQL and MySQL; might this be what
is
> needed?
>
> (4) Most hosting companies don't allow binary CGI programs, for "security
> reasons" (i.e. their own stupidity). Of those which do, many refuse to
> install GNAT (despite providing GCC C++). Outrageous. However, I know at
> least one hosting company (Liquid Web, http://www.liquidweb.com/ ) who is
> willing to install GNAT, so maybe this isn't a hopeless problem.
>
> Comments?
>
> If I do this, I would like to make it a project at BerliOS (
> http://developer.berlios.de ). I've been a bit disappointed with the
service
> at SourceForge recently, but they have got new servers in recently. So, if
I
> do this project, where should I host it?
>
> --
> Nick Roberts
> Jabber: debater@charente.de [ICQ: 159718630]
>
>
Hey that sounds like it could make sense to me. Would we need to compile it
into an ada program after?  or perhaps all we need is an ada interpreter to
perform the actions and assign variables and such?  Ada can already compile
to Java bytecode maybe there's a way to use that for our purposes?  Dare I
say "AdaScript" or something like it?  With AWS as Server or executioner of
this AdaScript perhaps. make it all fit together?

Or are you talking about using Ada much like PHP as in make it usable with
Appache or other server technologies like that one and not confine it to Ada
Web Server usage only?

-- 
St�phane Richard
"Ada World" Webmaster
http://www.adaworld.com

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Wes Groleau]

If you want to embed Ada into HTML, instead of inventing
a new cryptic syntax, use the same syntax as for embedding
Javascript.

-- 
Wes Groleau
   "Grant me the serenity to accept those I cannot change;
    the courage to change the one I can;
    and the wisdom to know it's me."
                                -- unknown

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Nick Roberts]

"Wes Groleau" <groleau@freeshell.org> wrote in message
news:5qWdnWcBj-C38OKiU-KYuA@gbronline.com...

> If you want to embed Ada into HTML, instead of inventing
> a new cryptic syntax, use the same syntax as for embedding
> Javascript.

With respect, Wes, that would be a very silly idea, as such. If the author
wanted to include Javascript (or any other client-side script) in the web
page, they would have a torrid time if the delimiters for the script were
the same as the delimiters for the Ada code!

Better that the Ada code delimiters are completely different to those of any
client-side scripting language. However, I'm very happy to accept ideas for
an alternative syntax to what I suggested, provided it does not clash with
client-side scripting syntax (or any kind of syntax that could be required
in an HTML page). I forgot to mention an escaping mechanism with my
suggestion, but some escaping mechanism would be necessary.

--
Nick Roberts
Jabber: debater@charente.de [ICQ: 159718630]

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Nick Roberts]

"Stephane Richard" <stephane.richard@verizon.net> wrote in message
news:WOGfb.22559$kD3.8829@nwrdny03.gnilink.net...

> Hey that sounds like it could make sense to me.

Thank you!

> Would we need to compile it into an ada program after?

Yes, that is what I imagined. I think the most typical scenario is that the
generated Ada source files would be uploaded to the (web hosting) server
machine, and then compiled (probably with GNAT) there. The resulting
executable binaries would be put into the "cgi-bin" directory, so that they
would be executed (by the web server program) when the corresponding web
pages were rewuested.

> Dare I say "AdaScript" or something like it?

I want to get away from scripting, really, since there are any number of
existing scripting languages. I think it would be easier and better to
leverage GNAT and the power of a fully compiled language.

> With AWS as Server

AWS did come into my mind certainly. In that scenario, it would be possible
to compile the web page generator procedure right into the web server
(rather than have it run as a separate CGI program). This could be the
ultimate 'power solution' in some cases. (Hehe ;-)

> Or are you talking about using Ada much like PHP as in
> make it usable with Apache or other server technologies
> like that one and not confine it to Ada.

Yes, I was thinking of generating standard (in inverted commas) CGI
programs, for use with web server programs that support CGI (including
Apache). But not like PHP, which is interpreted. The programs generated
would be compiled to be native code binary programs.

> Web Server usage only?

One of the neat things about CGI programs is that you can easily run them
'standalone' to test them. Also, the
generated Ada procedures could be compiled into a bigger Ada program or
library, rather than being compiled into a self-contained program. This
bigger program could be a FastCGI program, or a complete web server (a la
AWS), or something completely different (dons wetsuit ;-)

--
Nick Roberts
Jabber: debater@charente.de [ICQ: 159718630]

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Nick Roberts]

"Larry Kilgallen" <Kilgallen@SpamCop.net> wrote in message
news:MB$RIBQbIxmj@eisner.encompasserve.org...

> I think a better acronym would have a vowel in the middle so
> it could be pronounced.

All the best acronyms have gone. PAD? Confusing, surely. DAP? Used (Advanced
Gameboy Editor 'polyester' files). WAD? Nope (used by the game Doom, believe
it or not). [Source: Wotsit]

DAW seems to be available! Dynamic Ada Web?

The only danger is somebody making some awful pun involving DAWs and
Windows.

:-)

--
Nick Roberts
Jabber: debater@charente.de [ICQ: 159718630]

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Larry Kilgallen]

In article <blo3bl$e7rdl$1@ID-25716.news.uni-berlin.de>, "Nick Roberts" <nickroberts@blueyonder.co.uk> writes:
> "Larry Kilgallen" <Kilgallen@SpamCop.net> wrote in message
> news:MB$RIBQbIxmj@eisner.encompasserve.org...
> 
>> I think a better acronym would have a vowel in the middle so
>> it could be pronounced.
> 
> All the best acronyms have gone. PAD? Confusing, surely. DAP? Used (Advanced
> Gameboy Editor 'polyester' files). WAD? Nope (used by the game Doom, believe
> it or not). [Source: Wotsit]
> 
> DAW seems to be available! Dynamic Ada Web?

That is good - it pushes the project concept (Dynamic/Web) and ties Ada
into it.

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Preben Randhol]

On 2003-10-04, Stephane Richard <stephane.richard@verizon.net> wrote:

[178 lines of quoted text delete, please please start removing
unnecessary text]

> Hey that sounds like it could make sense to me. Would we need to compile it
> into an ada program after?  or perhaps all we need is an ada interpreter to
> perform the actions and assign variables and such?  Ada can already compile
> to Java bytecode maybe there's a way to use that for our purposes? 

To use Java is not nice. The reason is that the page will take ages to
load because you have to fire up the JVM which also consumes a lot of
memory. If anything this must be server side engine like PHP. 

> Or are you talking about using Ada much like PHP as in make it usable with
> Appache or other server technologies like that one and not confine it to Ada
> Web Server usage only?

Don't know, but to get it widespread I think one would have to.

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Preben Randhol]

On 2003-10-05, Nick Roberts <nickroberts@blueyonder.co.uk> wrote:
> Yes, that is what I imagined. I think the most typical scenario is that the
> generated Ada source files would be uploaded to the (web hosting) server
> machine, and then compiled (probably with GNAT) there. The resulting
> executable binaries would be put into the "cgi-bin" directory, so that they
> would be executed (by the web server program) when the corresponding web
> pages were rewuested.

What would be the benifit? How dows it help making web pages?

> Yes, I was thinking of generating standard (in inverted commas) CGI
> programs, for use with web server programs that support CGI (including
> Apache). But not like PHP, which is interpreted. The programs generated
> would be compiled to be native code binary programs.

Why. Sounds like a lot of resources are wasted if you have to run a
program for every page you want to have.

Preben

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Pascal Obry]

"Nick Roberts" <nickroberts@blueyonder.co.uk> writes:

> I've had an idea (not a blindingly original one) which might be a way to
> help promote Ada. Dynamic web content is all the rage these days; there are
> dozens of techniques used by millions of people to achieve it, including but
> not limited to SSI, ASP, JSP, PHP, CGI, and many other acronyms.
> 
> How to get Ada into this picture?

By looking at AWS :)

> I think one of the big attractions of schemes like ASP, JSP, and PHP (to
> name but three) is that to use them you merely have to embed a few special
> directives into an otherwise ordinary HTML file, and often the directives
> are very simple.

Yep, but in many places you have scripts and this is plain wrong. Having
script into a Web page is mixing layout (HTML) and code. Both must really be
separated, one of the reason is that they are done by differents peoples.

> So, it seems to me, an attractive scheme would be to allow Ada code to be
> embedded into an HTML file.

No, I don't think this is right. Note that Java is moving on the opposite side
just because of this problem. A script in a page means bugs in Web document,
this is wrong. Look at the Java struts.

In AWS we have a Templates_Parser engine which can compile on-the-fly
templates file and interpret them. This is really quick and only some "tags"
needs to be added into the HTML (or whatever) document.

> A special program would transform this file into
> a complete Ada program (procedure Main is ...) in a .adb file. The Ada
> program would be a complete CGI program: you upload it, and compile it into
> your cgi-bin directory.

This is again the wrong way. CGI (Common Gateway Interface) is the old way to
develop Web apllications. A CGI have to be spawned, this is a new process on
the server side. This scheme has been dropped long time ago for the
Application Server framework (JSP, ASP, PHP...).

> It could 'with' a simple package providing support
> for the CGI protocol (and HTTP/HTML web page generation); I'm aware of an
> existing AdaCGI package that might suit this.

Which must be history now :)

> Since a TLA (three-letter acronym) seems to be obligatory for these things,

Good, lets go with AWS :)

> we might call it 'WPG' for Web Page Generation. The source file containing
> the HTML with embedded Ada could then have the .wpg extension. Other
> possibilities that occur to me are: DWP (Dynamic Web Pages); HRA (Hypertext
> Response with Ada). The sillier the better, really.
> 
> The special program doing the translation (from WPG to Ada) - let's call it
> the WPGT - would (naturally!) be written in Ada, and I think it should be
> quite simple to write. Obviously I'm volunteering, if nobody else makes a
> claim.

Ok, this is Templates_Parser (see AWS.Templates). BTW, AWS's templates engine
is very fast. Lot faster than JSP, PHP or ASP.

> I propose the following embedding syntax.

[example removed]

BTW, I found it quite unreadable.

> One big selling point would be that your dynamic web pages are generated by
> a native code compiled program; a bit more efficient than a script. Another
> point is that you have the full facilities of Ada programming available to
> you (utility packages, bindings, and so on).

In AWS, the "scripts" are compiled into your main application.

> Other possibilities include: allow the name of a package to be 'withed'
> between [+ +] brackets; provide some handy translation-time values, e.g.
> [?UPDATE?] to be replaced by the date and time the translation is executed.
> 
> Some issues I can see are:
> 
> (1) HTTP headers. You'll see my example program above generates one HTTP
> header line. I get the impression that the headers a CGI program is supposed
> to generate are not very well defined anywhere. I think AdaCGI has a
> procedure to generate CGI headers; handy, but correct?

Supported in AWS.

> (2) Conversion of < > and & characters into escaped forms in fields. I think
> AdaCGI has a function to do this; could it be done automatically?

Supported in AWS.

> (3) Access to databases. Most CGI programs and web scripts need to get their
> information from a database, and some update databases too. I'm aware of a
> project to produce a binding to PostgreSQL and MySQL; might this be what is
> needed?

Supported in AWS, just use GNADE or whatever binding to ODBC, MySQL...

> (4) Most hosting companies don't allow binary CGI programs, for "security
> reasons" (i.e. their own stupidity). Of those which do, many refuse to
> install GNAT (despite providing GCC C++). Outrageous. However, I know at
> least one hosting company (Liquid Web, http://www.liquidweb.com/ ) who is
> willing to install GNAT, so maybe this isn't a hopeless problem.

This is a real problem. Not solved, you need to use PHP...

> Comments?

Please have a look at AWS before doing this. As I said most of the ideas here
are old-fashioned way to build Web applications.

Also note that a Web server is only a start. You'll need to support SOAP,
WSDL, SMTP, LDAP... to build real Web applications... All these standard are
supported by AWS.

Just in case : http://libre.act-europe.fr/aws

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Stephane Richard]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 971 bytes --]

"Larry Kilgallen" <Kilgallen@SpamCop.net> wrote in message
news:HQ2wM9kBgOwA@eisner.encompasserve.org...
> In article <blo3bl$e7rdl$1@ID-25716.news.uni-berlin.de>, "Nick Roberts"
<nickroberts@blueyonder.co.uk> writes:
> > "Larry Kilgallen" <Kilgallen@SpamCop.net> wrote in message
> > news:MB$RIBQbIxmj@eisner.encompasserve.org...
> >
> >> I think a better acronym would have a vowel in the middle so
> >> it could be pronounced.
> >
> > All the best acronyms have gone. PAD? Confusing, surely. DAP? Used
(Advanced
> > Gameboy Editor 'polyester' files). WAD? Nope (used by the game Doom,
believe
> > it or not). [Source: Wotsit]
> >
> > DAW seems to be available! Dynamic Ada Web?
>
> That is good - it pushes the project concept (Dynamic/Web) and ties Ada
> into it.

I have to agree with Larry here, it does have a good ring to it, and really
does push the concept...I second Larry's motion :-)

-- 
St�phane Richard
"Ada World" Webmaster
http://www.adaworld.com

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Pascal Obry]

"Nick Roberts" <nickroberts@blueyonder.co.uk> writes:

> > With AWS as Server
> 
> AWS did come into my mind certainly. In that scenario, it would be possible
> to compile the web page generator procedure right into the web server
> (rather than have it run as a separate CGI program). This could be the
> ultimate 'power solution' in some cases. (Hehe ;-)

Well AWS has alread it's templates engine. Please have a look. One important
point is that your template file must be compatible with the design tools
like DreamWeaver. And a designer is not a programmer, the "tags" or template
commands must be easy to use, scripting language are not in this category.

> > Web Server usage only?
> 
> One of the neat things about CGI programs is that you can easily run them
> 'standalone' to test them. Also, the

But it has many many drawbacks. CGI programs run as differents process, this
is not good for server with a lot of hits. Also there is security issues. I'm
not expert here, but there was many exploit with CGI oriented servers
(replacing CGI with some other programs, CGI were running as root on the early
days, if interpreted - PERL CGI - it was possible to send sequence of code
after a ';' line separator...).

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Preben Randhol]

On 2003-10-04, Nick Roberts <nickroberts@blueyonder.co.uk> wrote:
> Ada code would be embedded between an opening bracket and a closing bracket,
> forming an 'insertion' into the HTML file.

Interestingly this came up on freshmeat today:

http://yaws.hyber.org/

I think AWS is the way to go for your proposal. If you want it wide
spread you need to make apache able to use these pages.

Preben

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Simon Wright]

"Nick Roberts" <nickroberts@blueyonder.co.uk> writes:

> I've had an idea (not a blindingly original one) which might be a
> way to help promote Ada. Dynamic web content is all the rage these
> days; there are dozens of techniques used by millions of people to
> achieve it, including but not limited to SSI, ASP, JSP, PHP, CGI,
> and many other acronyms.

I was thinking of something like this, but in the context of embedded
servers. I already have an unpublished Embedded Web Server, in Ada of
course, but it only handles static content at the moment.

AWS in this context is far too capable! I need to run in -- well,
something a little larger than a toaster, a printer perhaps.

As for the syntax, I think it would be better to look at a more
XML-based syntax, which would have the advantage that you could view
the raw, unprocessed pages in any web browser. This is not an original
idea, but I forget where else you can find it .. anyway, something
like

  <ews:include with="Ada.Text_IO"/>
  <ews:if test="x &gt; 0"> some text </ews:if>

-S

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Georg Bauhaus]

Nick Roberts <nickroberts@blueyonder.co.uk> wrote:
: I think one of the big attractions of schemes like ASP, JSP, and PHP (to
: name but three) is that to use them you merely have to embed a few special
: directives into an otherwise ordinary HTML file, and often the directives
: are very simple.

It might be popular, it might even let you think of clever tricks,
but is it technically attractive? It does, in fact, reintroduce
the lack of model-view-controller separation. It is bound to
create a somewhat nightmarish code-in-view-mess.

As soon as there is more than one web-page involved in the same
"web application", maintenance and understandability can degrade so
fast that I am tempted to say, in O(exp(n)).

Please, don't.

There are much more mature, better, and cleaner methods of
creating dynamic views, and AWS has one of them ready for production
use.
(Addition: I have been and am doing this sort of "web visualization" for
years, as soon as you allow a conditional or assignment in a template, you
start burning money.)


-- Georg

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Nick Roberts]

"Pascal Obry" <p.obry@wanadoo.fr> wrote in message
news:u8yo06nn3.fsf@wanadoo.fr...

> Well AWS has alread it's templates engine. Please have a
> look. One important point is that your template file must
> be compatible with the design tools like DreamWeaver.
> And a designer is not a programmer, the "tags" or tem-
> plate commands must be easy to use, scripting language
> are not in this category.

I wholeheartedly agree with this notion.

> [re CGI]
> But it has many many drawbacks. CGI programs run as
> differents process, this is not good for server with a lot
> of hits.

True, but the interpretation of a template page for every single page
request is also inefficient (for a server with a lot of hits). On the other
hand, a CGI program can quite easily be converted to operate as a FastCGI
program (which essentially removes the inefficiency of running and
terminating the program for every page request).

> Also there is security issues. I'm not expert here, but
> there was many exploit with CGI oriented servers
> (replacing CGI with some other programs, CGI were
> running as root on the early days, if interpreted - PERL
> CGI - it was possible to send sequence of code
> after a ';' line separator...).

There are no security risks associated with CGI itself. There are various
potential security risks associated with badly designed, badly implemented,
or inappropriately configured servers, and with any program executed in
response to a web page request (be it a CGI program or a server-side script)
which is badly designed, badly implemented, or inappropriately configured.

I have looked at the documentation for your templates parser, Pascal. For
anyone interested, the URL is:

   http://perso.wanadoo.fr/pascal.obry/archive/templates_parser.html

Overall, I like it a lot. I particularly like the way it separates the HTML
from the Ada.

However, what I particularly don't like is the way data is transmitted from
program to template. I think it's inefficient and inflexible. I'd like to
propose a different way for communication between the Ada program and the
template file, and a very much simpler syntax.

Suppose everything is put inside a package named DAW (argue about this name
if you wish!). I propose a spec something like this:

package DAW is
   type Parameter_String is access constant String;
   type Parameter_List is array (Positive range <>) of Parameter_String;
   type Macro_Interpreter is function (Parameters: in Parameter_List) return
String;
   type Condition_Interpreter is function (Parameters: in Parameter_List)
return Boolean;
   type Table_Control_Action is (Open_Table, Close_Table, Skip_Cursor);
   type Table_Controller is procedure (
         Action: in Table_Control_Action;
         Parameters: in Parameter_List;
         End_of_Data: out Boolean );
   type Interpreter_Set is private;
   procedure Add_Macro (
         Set: in out Interpreter_Set;
         Name: in String;
         Interpreter: in Macro_Interpreter );
   procedure Add_Condition (
         Set: in out Interpreter_Set;
         Name: in String;
         Interpreter: in Condition_Interpreter );
   procedure Add_Table (
         Set: in out Interpreter_Set;
         Name: in String;
         Controller: in Table_Controller );
   function Evaluate_Macro (Interpreters: in Interpreter_Set; Value: in
String) return String;
   function Evaluate_Condition (Interpreters: in Interpreter_Set; Value: in
String) return Boolean;
   procedure Parse_Template (
         Name: in String;
         Output: in Ada.Text_IO.File_Type;
         Interpreters: in Interpreter_Set;
         Left_Delimiter: in String := "@_";
         Right_Delimiter: in String := "_@";
         Command_Prefix: in String := "@@";
         Escape_Sequence: in String := "@\" );
end DAW;

For example, with the template file 'demo1.txt':

<P>Name @_NAME_@

the following Ada program 'demo1.adb':

with Ada.Text_IO;
with DAW;
procedure Demo1 is
   Translations : DAW.Interpreter_Set;
   function My_Name (Parameters: in Parameter_List) return String is
   begin return "Ada"; end;
begin
   Add_Macro( Translations, "NAME", My_Name'Access );
   Parse_Template( "demo1.txt", Ada.Text_IO.Current_Output, Translations );
end Demo;

would print out :

<P>Name Ada

In the template file, a macro can have parameters, in the familiar
(abc,pqr,xyz) format, after its name. The Ada program can therefore add any
function it wishes. For example, with the template file 'demo2.txt':

<P>My age is @_SUB(AGE,5)_@

the Ada program 'demo2.adb':

with Ada.Text_IO;
with DAW;
procedure Demo2 is
   Tr: DAW.Interpreter_Set;
   function My_Age (P: in Parameter_List) return String is
   begin return "38"; end;
   function My_Sub (P: in Parameter_List) return String is
   begin return Integer'Value(Tr,Evaluate_Macro(P(1)))-Integer'Value(P(2));
end;
begin
   Add_Macro( Tr, "AGE", My_Age'Access );
   Add_Macro( Tr, "SUB", My_Sub'Access );
   Parse_Template( "demo2.t", Ada.Text_IO.Current_Output, Tr );
end Demo;

would print out :

<P>My age is 33

Certainly DAW could provide a complete set of default utility parametised
macros. Any of these could be overridden if required.

Conditional sections could be supported by a very much simpler form of IF
command, which only took a condition name (which could be parametised):

@@IF condition_name
   ...
@@ELSE
   ...
@@END_IF

This would invoke the condition with the given name, and select which
section to (process and) output based on the result (True or False).
Incidentally, I suggest all commands are line-oriented (a line starting with
the command prefix is a command running to the end of the line); just a
little bit easier and neater, I think.

Within a TABLE command, the table would be passed as a parameter of a macro
to access a field of the table. Inside nested tables, the name of each table
would be passed as a separate parameter. A table controller procedure would
control iteration through the rows of the table, and indicate termination.

@@TABLE A
   @@TABLE B
      ... @_PROD_NAME(A,B,FULL)_@ ...
   @@END_TABLE
@@END_TABLE

This would cause table A to be opened, for each of its rows, table B to be
opened, and for each of its rows the text inside to be repeated. Within this
text, the example macro shown would cause a call to the macro interpreter
corresponding to "PROD_NAME", which might be My_Prod_Name, with the
parameter list ("A","B","FULL").

The advantage of this technique is that typically only a row-set has to
buffered in memory, rather than all the values in the whole table. This fits
the typical way in which data is pulled from a database table (row by row),
and could be a lot more efficient for larger tables.

I think @@INCLUDE could be kept, and @@SECTION, and maybe a few other
things, but I think this scheme would provide the complete funcitonality
required in a somewhat simpler form. No doubt there will be lots of other
details and things I haven't thought of.

In general, I prefer more a bit more work to be done in the Ada program, and
a little less in the template language.

What do you think, Pascal?

--
Nick Roberts
Jabber: debater@charente.de [ICQ: 159718630]

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Stephane Richard]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 7855 bytes --]


"Nick Roberts" <nickroberts@blueyonder.co.uk> wrote in message
news:blqbag$f1m8d$1@ID-25716.news.uni-berlin.de...
> "Pascal Obry" <p.obry@wanadoo.fr> wrote in message
> news:u8yo06nn3.fsf@wanadoo.fr...
>
> > Well AWS has alread it's templates engine. Please have a
> > look. One important point is that your template file must
> > be compatible with the design tools like DreamWeaver.
> > And a designer is not a programmer, the "tags" or tem-
> > plate commands must be easy to use, scripting language
> > are not in this category.
>
> I wholeheartedly agree with this notion.
>
> > [re CGI]
> > But it has many many drawbacks. CGI programs run as
> > differents process, this is not good for server with a lot
> > of hits.
>
> True, but the interpretation of a template page for every single page
> request is also inefficient (for a server with a lot of hits). On the
other
> hand, a CGI program can quite easily be converted to operate as a FastCGI
> program (which essentially removes the inefficiency of running and
> terminating the program for every page request).
>
> > Also there is security issues. I'm not expert here, but
> > there was many exploit with CGI oriented servers
> > (replacing CGI with some other programs, CGI were
> > running as root on the early days, if interpreted - PERL
> > CGI - it was possible to send sequence of code
> > after a ';' line separator...).
>
> There are no security risks associated with CGI itself. There are various
> potential security risks associated with badly designed, badly
implemented,
> or inappropriately configured servers, and with any program executed in
> response to a web page request (be it a CGI program or a server-side
script)
> which is badly designed, badly implemented, or inappropriately configured.
>
> I have looked at the documentation for your templates parser, Pascal. For
> anyone interested, the URL is:
>
>    http://perso.wanadoo.fr/pascal.obry/archive/templates_parser.html
>
> Overall, I like it a lot. I particularly like the way it separates the
HTML
> from the Ada.
>
> However, what I particularly don't like is the way data is transmitted
from
> program to template. I think it's inefficient and inflexible. I'd like to
> propose a different way for communication between the Ada program and the
> template file, and a very much simpler syntax.
>
> Suppose everything is put inside a package named DAW (argue about this
name
> if you wish!). I propose a spec something like this:
>
> package DAW is
>    type Parameter_String is access constant String;
>    type Parameter_List is array (Positive range <>) of Parameter_String;
>    type Macro_Interpreter is function (Parameters: in Parameter_List)
return
> String;
>    type Condition_Interpreter is function (Parameters: in Parameter_List)
> return Boolean;
>    type Table_Control_Action is (Open_Table, Close_Table, Skip_Cursor);
>    type Table_Controller is procedure (
>          Action: in Table_Control_Action;
>          Parameters: in Parameter_List;
>          End_of_Data: out Boolean );
>    type Interpreter_Set is private;
>    procedure Add_Macro (
>          Set: in out Interpreter_Set;
>          Name: in String;
>          Interpreter: in Macro_Interpreter );
>    procedure Add_Condition (
>          Set: in out Interpreter_Set;
>          Name: in String;
>          Interpreter: in Condition_Interpreter );
>    procedure Add_Table (
>          Set: in out Interpreter_Set;
>          Name: in String;
>          Controller: in Table_Controller );
>    function Evaluate_Macro (Interpreters: in Interpreter_Set; Value: in
> String) return String;
>    function Evaluate_Condition (Interpreters: in Interpreter_Set; Value:
in
> String) return Boolean;
>    procedure Parse_Template (
>          Name: in String;
>          Output: in Ada.Text_IO.File_Type;
>          Interpreters: in Interpreter_Set;
>          Left_Delimiter: in String := "@_";
>          Right_Delimiter: in String := "_@";
>          Command_Prefix: in String := "@@";
>          Escape_Sequence: in String := "@\" );
> end DAW;
>
> For example, with the template file 'demo1.txt':
>
> <P>Name @_NAME_@
>
> the following Ada program 'demo1.adb':
>
> with Ada.Text_IO;
> with DAW;
> procedure Demo1 is
>    Translations : DAW.Interpreter_Set;
>    function My_Name (Parameters: in Parameter_List) return String is
>    begin return "Ada"; end;
> begin
>    Add_Macro( Translations, "NAME", My_Name'Access );
>    Parse_Template( "demo1.txt", Ada.Text_IO.Current_Output,
Translations );
> end Demo;
>
> would print out :
>
> <P>Name Ada
>
> In the template file, a macro can have parameters, in the familiar
> (abc,pqr,xyz) format, after its name. The Ada program can therefore add
any
> function it wishes. For example, with the template file 'demo2.txt':
>
> <P>My age is @_SUB(AGE,5)_@
>
> the Ada program 'demo2.adb':
>
> with Ada.Text_IO;
> with DAW;
> procedure Demo2 is
>    Tr: DAW.Interpreter_Set;
>    function My_Age (P: in Parameter_List) return String is
>    begin return "38"; end;
>    function My_Sub (P: in Parameter_List) return String is
>    begin return
Integer'Value(Tr,Evaluate_Macro(P(1)))-Integer'Value(P(2));
> end;
> begin
>    Add_Macro( Tr, "AGE", My_Age'Access );
>    Add_Macro( Tr, "SUB", My_Sub'Access );
>    Parse_Template( "demo2.t", Ada.Text_IO.Current_Output, Tr );
> end Demo;
>
> would print out :
>
> <P>My age is 33
>
> Certainly DAW could provide a complete set of default utility parametised
> macros. Any of these could be overridden if required.
>
> Conditional sections could be supported by a very much simpler form of IF
> command, which only took a condition name (which could be parametised):
>
> @@IF condition_name
>    ...
> @@ELSE
>    ...
> @@END_IF
>
> This would invoke the condition with the given name, and select which
> section to (process and) output based on the result (True or False).
> Incidentally, I suggest all commands are line-oriented (a line starting
with
> the command prefix is a command running to the end of the line); just a
> little bit easier and neater, I think.
>
> Within a TABLE command, the table would be passed as a parameter of a
macro
> to access a field of the table. Inside nested tables, the name of each
table
> would be passed as a separate parameter. A table controller procedure
would
> control iteration through the rows of the table, and indicate termination.
>
> @@TABLE A
>    @@TABLE B
>       ... @_PROD_NAME(A,B,FULL)_@ ...
>    @@END_TABLE
> @@END_TABLE
>
> This would cause table A to be opened, for each of its rows, table B to be
> opened, and for each of its rows the text inside to be repeated. Within
this
> text, the example macro shown would cause a call to the macro interpreter
> corresponding to "PROD_NAME", which might be My_Prod_Name, with the
> parameter list ("A","B","FULL").
>
> The advantage of this technique is that typically only a row-set has to
> buffered in memory, rather than all the values in the whole table. This
fits
> the typical way in which data is pulled from a database table (row by
row),
> and could be a lot more efficient for larger tables.
>
> I think @@INCLUDE could be kept, and @@SECTION, and maybe a few other
> things, but I think this scheme would provide the complete funcitonality
> required in a somewhat simpler form. No doubt there will be lots of other
> details and things I haven't thought of.
>
> In general, I prefer more a bit more work to be done in the Ada program,
and
> a little less in the template language.
>
> What do you think, Pascal?
>
> --
> Nick Roberts
> Jabber: debater@charente.de [ICQ: 159718630]
>
>

Have you benchmarked running FastCGI and AWS ?  Running or generating
somewhat the same HTML contents?  You might be surprised with the results
you find :-).

-- 
St�phane Richard
"Ada World" Webmaster
http://www.adaworld.com

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Wes Groleau]

Nick Roberts wrote:
> With respect, Wes, that would be a very silly idea, as such. If the author
> wanted to include Javascript (or any other client-side script) in the web
> page, they would have a torrid time if the delimiters for the script were
> the same as the delimiters for the Ada code!

When you encounter

   <script language="Ada">

you are not parsing Ada code--no confusion there.

And it should be easy enough to recognize that

   </SCRIPT>

is also not Ada code.

And I don't think distinguishing

   <script language="Ada">
from
   <script language="JavaScript">

is particularly difficult.


-- 
Wes Groleau
-----------
Curmudgeon's Complaints on Courtesy:
http://www.onlinenetiquette.com/courtesy1.html
(Not necessarily my opinion, but worth reading)

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Wes Groleau]

Nick Roberts wrote:
> Yes, that is what I imagined. I think the most typical scenario is that the
> generated Ada source files would be uploaded to the (web hosting) server
> machine, and then compiled (probably with GNAT) there. The resulting
> executable binaries would be put into the "cgi-bin" directory, so that they
> would be executed (by the web server program) when the corresponding web
> pages were rewuested.

I'm not sure I understand.  Are you saying
that some variant of Ada would be embedded
in a web page, then the browser would send it
back to the server it came from to be compiled
into a CGI program and executed?

-- 
Wes Groleau
When all you have is a perl, everything looks like a string.

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Nick Roberts]

"Wes Groleau" <groleau@freeshell.org> wrote in message
news:PEednfVB_pKyXR2iU-KYgg@gbronline.com...

> I'm not sure I understand.  Are you saying
> that some variant of Ada would be embedded
> in a web page, then the browser would send it
> back to the server it came from to be compiled
> into a CGI program and executed?

I was describing an authoring process, not a browsing process. What I was
suggesting was that the author of a web page would: write/edit the text file
containing mixed HTML and Ada code; upload it to the web hosting server
machine; run the translator to convert the mixed HTML and Ada code text file
into a pure Ada program source text file; compile the Ada program (probably
with GNAT) to get a binary executable CGI program; put the CGI program into
the cgi-bin directory.

The corresponding browsing process would be: the user starts at the web site
home page, which will probably be a normal HTML web page; the user follows a
link in this which invokes the CGI program (the URL might be something like
"http://www.mystuff.com/shop/stocklist.cgi?item=23401", where the name of
the CGI program is "stocklist.cgi"); the CGI program is executed by the web
server, and generates a dynamic web page, which it outputs on its standard
output; the web server pipes this back to the client's browser, which
displays it.

Having said all of that, I've now revised my suggestion in line with the AWS
template parser, written by Pascal Obry.

--
Nick Roberts
Jabber: debater@charente.de [ICQ: 159718630]

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[David Trudgett]

> 
>>Since a TLA (three-letter acronym) seems to be obligatory for these things,
> 
> Good, lets go with AWS :)

...but what can we think of for OM?  (AWeSOMe)


David

--

What I don't know is not as much of a problem
as what I am sure I know that just ain't so.

     -- Mark Twain

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Dmitriy Anisimkov]

Pascal Obry wrote:
> Yep, but in many places you have scripts and this is plain wrong. Having
> script into a Web page is mixing layout (HTML) and code. Both must really be
> separated, one of the reason is that they are done by differents peoples.

Pascal,

Don't template_parser mixing code and HTML ?
template_parser have own code inside of HTML too.
We have to mix languages anyway, becouse dynamic data
provided by non-HTML languages.

Sure, the languages should be mixed very carrifully,
but it is a Web Design Issue.

If we are making dynamic pages inside of AWS callback,
we have mix language Ada and HTML (make HTML output in Ada language).

if we are making dynamic pages from template parser, we have to mix
template parser language

@@TABLE@@
@@IF@@
@@ELSIF@@
@_DATA_@

and HTML.

Template_Parser internal language is far from Ada functionality.
So why don't have Ada inside of HTML ?
It is not possible to have DB access from template parser now.
If we would have Ada inside of HTML, we would have ready to use
DB access from dynamic HTML pages.

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[chris]

Nick Roberts wrote:

> There are no security risks associated with CGI itself. There are various
> potential security risks associated with badly designed, badly implemented,
> or inappropriately configured servers, and with any program executed in
> response to a web page request (be it a CGI program or a server-side script)
> which is badly designed, badly implemented, or inappropriately configured.

Perhaps, but CGI has a reputation for being old and a lot of trouble and 
has largely been replaced by DSLs like PHP and ASP.

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Pascal Obry]

Dmitriy Anisimkov <anisimkov@yahoo.com> writes:

> Pascal Obry wrote:
> > Yep, but in many places you have scripts and this is plain wrong. Having
> > script into a Web page is mixing layout (HTML) and code. Both must really be
> > separated, one of the reason is that they are done by differents peoples.
> 
> Pascal,
> 
> Don't template_parser mixing code and HTML ?
> template_parser have own code inside of HTML too.

No code, just simple tags. There is no loop, no variables, no assignement...

> We have to mix languages anyway, becouse dynamic data
> provided by non-HTML languages.

Of course, but the link must be as light as possible.

> Template_Parser internal language is far from Ada functionality.
> So why don't have Ada inside of HTML ?

Because it's a pain to debug. You end-up having code in hundred of pages...

> It is not possible to have DB access from template parser now.

Right, but this is done in the code (Ada) and mapped by the template engine.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Pascal Obry]

"Nick Roberts" <nickroberts@blueyonder.co.uk> writes:

> I wholeheartedly agree with this notion.

Good to hear.

> 
> I have looked at the documentation for your templates parser, Pascal. For
> anyone interested, the URL is:
> 
>    http://perso.wanadoo.fr/pascal.obry/archive/templates_parser.html
> 
> Overall, I like it a lot. I particularly like the way it separates the HTML
> from the Ada.

Thanks.

> For example, with the template file 'demo1.txt':
> 
> <P>Name @_NAME_@
> 
> the following Ada program 'demo1.adb':
> 
> with Ada.Text_IO;
> with DAW;
> procedure Demo1 is
>    Translations : DAW.Interpreter_Set;
>    function My_Name (Parameters: in Parameter_List) return String is
>    begin return "Ada"; end;
> begin
>    Add_Macro( Translations, "NAME", My_Name'Access );
>    Parse_Template( "demo1.txt", Ada.Text_IO.Current_Output, Translations );
> end Demo;

This is equivalent to Templates_Parser:

   Assoc ("NAME", My_Name);

or in this simple case:

   Assoc ("NAME", "Ada");

It is just as easy to write. But here you have a Parameter_List, so it is
certainly more flexible.

> 
> Within a TABLE command, the table would be passed as a parameter of a macro
> to access a field of the table. Inside nested tables, the name of each table
> would be passed as a separate parameter. A table controller procedure would
> control iteration through the rows of the table, and indicate termination.
> 
> @@TABLE A
>    @@TABLE B
>       ... @_PROD_NAME(A,B,FULL)_@ ...
>    @@END_TABLE
> @@END_TABLE

I don't undertstand this one. How A and B are declared for example ?

> In general, I prefer more a bit more work to be done in the Ada program, and
> a little less in the template language.
> 
> What do you think, Pascal?

I think that all this is good. But I do not think that it will prove so
much easier to use. You said it, more work to be done in the Ada program, but
it can turns out to be lot more work if you have to declare a procedure for
each single tag to map on the HTML file.

I have already built pages with something like 50 tags in it.

I'd like to hear from AWS Templates users as I'm certainly biased :)

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Wiljan Derks]

"Pascal Obry" <p.obry@wanadoo.fr> wrote in message
news:un0ce5nvb.fsf@wanadoo.fr...
>
> I'd like to hear from AWS Templates users as I'm certainly biased :)
>
I have tried using the AWS templates in the past.
I think they miss flexibility, and do not allow one to program in the
dynamic web page.
Having developped several web applications and found this is something of
real importance.
Using @@ as escape characters (borrowed from the aws template handler) I
have build my own
template handler that allows one to embed full scripting language into the
web pages similar to ASP or PHP.
The template handler supports writing procedures, functions and control
loops and its syntax is Ada alike.
The variables used are objects that can contain anythings (a string, a
number or a float).
The template handler also supports COM objects.
Basically my applications are build around AWS and allow the template
handler to perfrom
callbacks into my application.
This splits the code in basic Ada code that perfroms the basic operation,
specific to the application.
The code to format the pages dynamically resides in the html files.

Works really great !!

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Martin Dowie]

"Wiljan Derks" <Wiljan.Derks@zonnet.nl> wrote in message
news:Fwigb.6263$732.884366@zonnet-reader-1...
> > I'd like to hear from AWS Templates users as I'm certainly biased :)
> >
> I have tried using the AWS templates in the past.
> I think they miss flexibility, and do not allow one to program in the
> dynamic web page.
> Having developped several web applications and found this is something of
> real importance.
> Using @@ as escape characters (borrowed from the aws template handler) I
> have build my own
> template handler that allows one to embed full scripting language into the
> web pages similar to ASP or PHP.

Have you/are you going to publish this?

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Georg Bauhaus]

Dmitriy Anisimkov <anisimkov@yahoo.com> wrote:
: So why don't have Ada inside of HTML ?

One reason is that it might be an obstacle to separate production
of HTML and program source code.

1/ Chances are that you cannot validate templates against a DTD
or some other Schema, because of conditionals in places where HTML
doesn't allow character content.

2/ Design people work with tools to produce pages
conforming to some coroporate style guide. These tools are somewhat
sensitive to "corrupted" data. But placeholders, or conditionals,
in templates might, in some cases, lead to data corruption in
the HTML sense.


-- Georg

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Pascal Obry]

"Wiljan Derks" <Wiljan.Derks@zonnet.nl> writes:

> Having developped several web applications and found this is something of
> real importance.
> Using @@ as escape characters (borrowed from the aws template handler) I
> have build my own
> template handler that allows one to embed full scripting language into the
> web pages similar to ASP or PHP.
> The template handler supports writing procedures, functions and control
> loops and its syntax is Ada alike.

This is exactly what I have tried to avoid, so there is no surprise that
AWS/Tempaltes does not support this :)

Not flexible is a bit generic to me, what would be nice is to be able to
identify where a script would have helped in a real application. Maybe I can
add something to AWS/Templates to work around that. As you certainly knows
I've build many Web applications using AWS/Templates and I have never felt
restricted...

Thanks for your feedbacks.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Jean-Pierre Rosen]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 970 bytes --]


"Pascal Obry" <p.obry@wanadoo.fr> a �crit dans le message de news:ufzi555h8.fsf@wanadoo.fr...
> Not flexible is a bit generic to me, what would be nice is to be able to
> identify where a script would have helped in a real application. Maybe I can
> add something to AWS/Templates to work around that. As you certainly knows
> I've build many Web applications using AWS/Templates and I have never felt
> restricted...
>
Time for a plug:
I will be presenting a paper at SIGAda 2003 about a typical AWS/mySQL/GtkAda application
(and the design patterns that were used). So if you are interested REGISTER EARLY AND SAVE ! :-)

In the whole application, there is NO script. And this includes quite sophisticated GUI. Note that nothing
prevents you from including Javascript in your templates. I just didn't need it.

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Visit Adalog's web site at http://www.adalog.fr

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Jacob Sparre Andersen]

Wes Groleau wrote:

> If you want to embed Ada into HTML, instead of inventing
> a new cryptic syntax, use the same syntax as for embedding
> Javascript.

Since it (as I read it) is different from Javascript in two important 
ways, I wouldn't use that syntax:

  1) WPG is intended for server-side use, whereas Javascript is intended
     for client-side use.

  2) Even though the code doesn't look like it, it is actually more an
     attempt at embedding HTML code in Ada programs in an easy way, than
     the other way around.

Altogether I find the PHP inspired (by the looks) syntax very sensible.

My main worry about the idea is to run the programs through the CGI 
protocol.  Starting a separate program every time a page is requested is 
not very efficient.  I think it has to be made into something that can 
be loaded as a module in Apache (and in AWS of course).

Jacob
-- 
"People are not intrinsically greedy. They are only
  cyclically greedy."

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Wiljan Derks]

I did not yet publish it. I proposed to Pascal to add it to AWS.

"Martin Dowie" <martin.dowie@btopenworld.com> wrote in message
news:blsgos$4c9$1@sparta.btinternet.com...
>
> Have you/are you going to publish this?
>
>

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Wiljan Derks]

"Pascal Obry" <p.obry@wanadoo.fr> wrote in message
news:ufzi555h8.fsf@wanadoo.fr...
>
> Not flexible is a bit generic to me, what would be nice is to be able to
> identify where a script would have helped in a real application. Maybe I
can
> add something to AWS/Templates to work around that. As you certainly knows
> I've build many Web applications using AWS/Templates and I have never felt
> restricted...
>
I think this is more then a matter of taste. For example, I generate in my
web application
navigation trees similar to the explorer directory structure.
Such an output is difficult to generate using the AWS templates.
On the other hand it is simple to generate this when I have procedures that
reside in the template.
These can just iterate the tree structure and while doing that generate the
proper html.

Besides this, this makes the coupling of the html much more loose from the
ada code.
So in general the code is easier to understand although not all code resides
in the ada program,
but also partly in the template.

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Pascal Obry]

"Wiljan Derks" <Wiljan.Derks@zonnet.nl> writes:

> I did not yet publish it. I proposed to Pascal to add it to AWS.

Right, long time ago. It never gets added because it is an external library
that you can use with AWS, no need for it to be tightly integrated if I
remember correctly. Do you plan to publish it at some point ?

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Wiljan Derks]

"Pascal Obry" <p.obry@wanadoo.fr> wrote in message
news:uhe2ipaj9.fsf@wanadoo.fr...
> Right, long time ago. It never gets added because it is an external
library
> that you can use with AWS, no need for it to be tightly integrated if I
> remember correctly. Do you plan to publish it at some point ?

No real problem if someone is really interested.
Note that the package depends on gnatcom and aws.

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Preben Randhol]

On 2003-10-09, Wiljan Derks <Wiljan.Derks@zonnet.nl> wrote:
>
> "Pascal Obry" <p.obry@wanadoo.fr> wrote in message
> news:uhe2ipaj9.fsf@wanadoo.fr...
>> Right, long time ago. It never gets added because it is an external
> library
>> that you can use with AWS, no need for it to be tightly integrated if I
>> remember correctly. Do you plan to publish it at some point ?
>
> No real problem if someone is really interested.
> Note that the package depends on gnatcom and aws.

I don't know your library, but would it be possible to get a version
that is not dependant on gnatcom too? I mean to just compile it without
COM support as it would not be needed on platforms other than Windows.

Preben

Re: Ada Advocacy - WPG (Web Page Generation) scheme

[Wiljan Derks]

"Preben Randhol" <randhol+valid_for_reply_from_news@pvv.org> wrote in
message
news:slrnbocon0.gq.randhol+valid_for_reply_from_news@kiuk0152.chembio.ntnu.no...
> I don't know your library, but would it be possible to get a version
> that is not dependant on gnatcom too? I mean to just compile it without
> COM support as it would not be needed on platforms other than Windows.
I do not have a versin without COM support.
I expect that it is easy to remove the COM support however.
What is your exact email address so I can mail you a copy ?