Re: Ada Popularity: Comparison of Ada/Charles with C++ STL (and Perl)

[slatyb@yahoo.com (K)]

Georg Bauhaus <sb463ba@l1-hrz.uni-duisburg.de> wrote in message news:<cjjib1$kdq$1@a1-hrz.uni-duisburg.de>...
> Kevin Cline <kevin.cline@gmail.com> wrote:
> :   Not much of a savings over simply writing
> : separate create, read, and update functions for the record type.
> 
> Why are you so keen on savings?

Because it makes an enormous difference in the cost of developing and
maintaining code.  It's much easier to write and maintain a table like
this:

   dbmap<Order> order_map;

   order_map.insert("ORDER.NUMBER", &Order::number)
             .insert("ORDER.CUSTOMER", &Order::customer_number)
             .insert("ORDER.ACCEPTED", &Order::acceptance_date)
             .insert("ORDER.PROMISED", &Order::promised_ship_date)
             ...

   and then be able to write:

   Order order;
   order_map.read(dbreader, order);
   order.promised_ship_date = ship_date(order.line_items);
   order_map.update(dbconnection, order);


than to maintain code like this:

   read_order(DatabaseReader& reader, Order& order)
   {
     order.number = reader["ORDER.NUMBER"];
     order.customer_number = reader["ORDER.CUSTOMER"];
     order.acceptance_date = parse<Date>(reader["ORDER.ACCEPTED"]);
     ...
   }

   update_order(DatabaseConnection& connection, Order& order)
   {
     writer["ORDER.NUMBER"] = order.number;
     writer["ORDER.CUSTOMER"] = ...;
   }

   create_order(...)
   {
      // more of the same
   }

Maybe you're happy keeping three copies of essentially the same code
carefully synchronized.  I'm not.  I prefer to squeeze out as much
redundancy as possible  so that changes need be made in only one
place.  That is one of the key practices that separates expert
programmers from average programmers.  The average programmer gets a
requirement to add two new fields to a record, and has to carefully
update three separate functions.  Except that once in a while he
misses one and the functions are out of sync, and an hour is lost
tracking the problem.

The expert simply has to add two members to the record definition,
then add two entries to the map, with almost no way to go wrong.

Basically, if you know what code is going to say without reading it,
then the code is redundant, and should be rewritten to eliminate the
redundancy.  I have found this to be easier in C++ than in Ada. 
Admittedly, C++ template programming could be easier.  Most
programmers would be incapable of writing
the dbmap class and the associated infrastructure.  But once written,
all programmers would be able to use the dbmap class.

In a reflective language this sort of mapping is relatively simple and
should be within the abilities of most developers.