Code generation in CASE-tools: results

Code generation in CASE-tools: results

Post by Philipp T. Schneid » Tue, 04 Jul 1995 04:00:00



Some weeks ago, I asked in this forum, if you use the code-generation
facility from your CASE-tools. A only got few answers, so I suppose that
either nobody is using code generation... or the people that use it, don't read
this news-group.

This are the results of my query:

  Tool                  Comments
----------------------------------------------------------------------------
Rational Rose   |  (Wilfried Heinickel) They use this CASE-tool in a large
                |  project, and started with reverse engineering. The code
                |  generation covers almost 98%.
----------------------------------------------------------------------------
Westmount I-CASE        | (Hans Stoop, Cadre Technologies) This was the only
ObjectTeam for OMT      | response of a CASE tool vendor, that uses his tool
                        | to build his own tool. The main reasons they use
                        | the tool are:
                        | - It is the only means to manage the software
                        |   development teams that are working on such a
                        |   complex software system.
                        | - Quality of code. A lot of code is generated what
                        |   result in better code, less testing time,
                        |   concentrating on the real difficult parts.
-----------------------------------------------------------------------------
Software through        | (Rich Briggs) Not a perfect tool, but stable enough
Pictures                | to generate code.
                        |
Paradigm Plus           | Crashed a lot in the tested version, but is said
                        | to be much more stable now.
-----------------------------------------------------------------------------

I am not surprised, that I got so few answers, because I really think that
there is no CASE-tool around, that supports a round-trip engineering. The
problems with the tools are:

        - They are not stable enough!! If you generate your code with
          your CASE-tool, the CASE-tool manages your code. You can't wait
          for the next, "better" version and you can't switch to another
          tool, because every tool has it's own, proprietary repository.
        - The big advantage if you use a CASE-tool it not that you could
          generate the code automaticly, but the documentation of your
          code. With that documentation it is easy to write the code by hand.

It would be nice to have a good CASE-tool. We use Rational Rose and are
quit happy with it and tried really hard to use it for round trip
engineering. We decided to use it for forward-only generation, because it
was always a big adventure to take back your code, and look if the tool
really generated what it was supposed to do. We where always looking for
workarounds on how to generate this special C++ construct....

                Philipp
--
Interkantonales Technikum Rapperswil            (__)
Philipp Schneider, Rechenzentrum                (oo) Hey, I'm from Switzerland.
Oberseestr.10, CH-8640 Rapperswil        /-------\/   The country of milk and

 
 
 

Code generation in CASE-tools: results

Post by Michael T » Tue, 04 Jul 1995 04:00:00



Quote:

>        - They are not stable enough!! If you generate your code with
>          your CASE-tool, the CASE-tool manages your code. You can't wait
>          for the next, "better" version and you can't switch to another
>          tool, because every tool has it's own, proprietary repository.
>        - The big advantage if you use a CASE-tool it not that you could
>          generate the code automaticly, but the documentation of your
>          code. With that documentation it is easy to write the code by hand.

We use Texas Instruments' IEF as our I-CASE.  The result is very encouraging.  
IEF is based on the Information Engineering Methodology.  It is a full life cycle
CASE tool - one which supports Planning, Analysis, Design and Construction(Code
generation).  

It generates the database as well.  IEF supports multiple platform,
such as MVS/COBOL/CICS/DB2, OS2/DBM/COBOL, OS2/C++/DB2/2 etc...  It generates
Client/Server application with ease.  The "code" (action diagram in TI terms) are
like COBOL pseduo code.  It is very easy to do.

Sorry, I am not a salesman from TI.  I worked for Telecom in Australia.  We have
been using the tool for the last few years.  We are quite happy about it.  Of
course, there are other catch.  For example, code generated from IEF is not necessary
as good as hand coded one when comparing code efficiency.  Nonetheless, I will give
it a score of 8.5 out of 10 overall.

I do not know the biggest advantage I see form a CASE tool is the documentation.
Certainly, it is nice and handy to have all the "system objects" in one repository.
I find the best part of an integrated CASE tool is "code reuse", "impact analysis",
"syntax error free source code", "technology independent development" etc...

Best Regards,
Michael Tse
Telecom Australia
Manager - Model Management



 
 
 

Code generation in CASE-tools: results

Post by Colin James III (The Rt Rev' » Wed, 05 Jul 1995 04:00:00



deletions:

Quote:>We use Texas Instruments' IEF as our I-CASE.  The result is very encouraging.  
>IEF is based on the Information Engineering Methodology.  It is a full life cycle
>CASE tool - one which supports Planning, Analysis, Design and Construction(Code
>generation).  
>It generates the database as well.  IEF supports multiple platform,
>such as MVS/COBOL/CICS/DB2, OS2/DBM/COBOL, OS2/C++/DB2/2 etc...  It generates
>Client/Server application with ease.  The "code" (action diagram in TI terms) are
>like COBOL pseduo code.  It is very easy to do.

But does IEF support reversability.  In other words, if you change the
output p-code or COBOL pseudo code does IEF force the user to change
the specification documents at successively hight levels to reflect
and document that change ?

~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~

CEC Services, 2080 Kipling St, Lakewood, CO  80215-1502   U S A
Voice: 303.231.9437;  Facs: .231.9438;  ISDN: .462.1107 & .1448
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~

 
 
 

Code generation in CASE-tools: results

Post by Johannes Erns » Thu, 06 Jul 1995 04:00:00


Quote:>Certainly, it is nice and handy to have all the "system objects" in one
repository.
>I find the best part of an integrated CASE tool is "code reuse", "impact analysis",
>"syntax error free source code", "technology independent development" etc...

So what would you guys want to have in additional (or less?) features
in CASE-tools?
Would there be a better support for the user if one could combine
different components from different toolsets?

Johannes.

 
 
 

Code generation in CASE-tools: results

Post by Hans Sto » Fri, 07 Jul 1995 04:00:00



Quote:

> Some weeks ago, I asked in this forum, if you use the code-generation
> facility from your CASE-tools. A only got few answers, so I suppose that
> either nobody is using code generation... or the people that use it, don't read
> this news-group.

> I am not surprised, that I got so few answers, because I really think that
> there is no CASE-tool around, that supports a round-trip engineering. The
> problems with the tools are:

>    - They are not stable enough!! If you generate your code with
>           your CASE-tool, the CASE-tool manages your code. You can't wait
>      for the next, "better" version and you can't switch to another
>      tool, because every tool has it's own, proprietary repository.

I do not agree. This may be true for the new players on the market.
It is certainly not true for the ObjectTeam for OMT (formerly Westmount I-CASE
OMT). The data is stored in a commercial available RDBMS. The source
code can be exported to the file system and therefore be under control
of yourself or your favorite tool.

Quote:>    - The big advantage if you use a CASE-tool it not that you could
>      generate the code automaticly, but the documentation of your
>      code. With that documentation it is easy to write the code by hand.

The cumbersome work should be done with the case tool:
      - generating the class definitions
      - generating the needed include statements
      - generating standard methods
      - generating the function skeleton
And nothing of the manual added may dissapear when you are
regenerating the code.
----------------/\-------------------------------------------------------------

              /\/\/\    dedICASEd for OMT
  Product     \/\/Cadre Technologies                      Phone : +31 15 141212
      Manager  \/\/        Delft, The Netherlands         Fax   : +31 15 157341
----------------\/-------------------------------------------------------------

--
----------------/\-------------------------------------------------------------

              /\/\/\    dedICASEd for OMT
  Product     \/\/Cadre Technologies                      Phone : +31 15 141212

 
 
 

Code generation in CASE-tools: results

Post by Philipp T. Schneid » Tue, 11 Jul 1995 04:00:00



>>        - The big advantage if you use a CASE-tool it not that you could
>>          generate the code automaticly, but the documentation of your
>>          code. With that documentation it is easy to write the code by hand.
>The cumbersome work should be done with the case tool:
>      - generating the class definitions
>      - generating the needed include statements
>      - generating standard methods
>      - generating the function skeleton
>And nothing of the manual added may dissapear when you are
>regenerating the code.

It's true that a CASE tool should generate automaticly the cumbersome work. But
I haven't yet found a tool that generates all the C++ statements you need
in real life:
        -pointer to functions
        -templates
        -functions in Classes (not memberfunctions)
        -enums
        -macros
        -...

Some tools generate more things, others generate less... But no tool generates
every C++ statement. Maybe you can work in 90% of your project without some
C++ goodies, but one day you will have use to some aweful C++ library that
forces you to write your code in some special way.
If your code-generator doesn't support that construct, you will have to
find some ugly workaround...

Philipp

--
Interkantonales Technikum Rapperswil            (__)
Philipp Schneider, Rechenzentrum                (oo) Hey, I'm from Switzerland.
Oberseestr.10, CH-8640 Rapperswil        /-------\/   The country of milk and

 
 
 

Code generation in CASE-tools: results

Post by Dave Whipp x33 » Tue, 11 Jul 1995 04:00:00



   Some weeks ago, I asked in this forum, if you use the code-generation [...]
   I am not surprised, that I got so few answers, because I really think that
   there is no CASE-tool around, that supports a round-trip engineering. The
   problems with the tools are:

           - They are not stable enough!! If you generate your code with
             your CASE-tool, the CASE-tool manages your code. You can't wait
             for the next, "better" version and you can't switch to another
             tool, because every tool has it's own, proprietary repository.
           - The big advantage if you use a CASE-tool it not that you could
             generate the code automaticly, but the documentation of your
             code. With that documentation it is easy to write the code by hand.

It is my belief that code generation is possible as long as it is used as part
of a methodology that supports it, such as Shlaer-Mellor. A methodology such as
Booch that has no well defined development process is not as well suited to
automation.

Shlaer Mellor formalises the notion of code generation as mappings
between application, architectural and implementation domains. As part
of the method these may be analysed on a per project basis (with
obvious re-use potential).  Thus SM need not suffer from the 'Need the
next release' or 'need to customise' barriers because both of these
aspects are under the control of the project. Is is likely that a
project may develop several code generators for a single application
to allow implementation on different platforms or with differnet
levels of instrumentation. The problem is finding a tool that supports
this aspect of SM.

CASE tools that I have seen come with a fairly basic architecture
(that produces working code) but provide only a procedural interface
to allow you to develop your own architectures. I know of one vendor
who has looked at the problem of automating the production of project
specific code generators. I'm looking forward to the forthcoming SM
book that covers recursive design in detail. There are hopes that a
standard for SM domain interchange will be produced.

Final comment (I've made it before): You shouldn't worry about mapping
code changes back to the design and analysis. Code should be produced
by the code generator, not by hacking. If you want to modify the code
then the analysis model(s) should be changed (possibly the anaysis of
the code generator!) and the application code should then be
regenerated. Asking for the case tool to track hacks in the code is
like asking an advanced optimising compiler to track hacks in the
object code it produces.
--

Not speaking for:   -------------------------------------------------------
 G.E.C. Plessey     Due to transcription and transmission errors, the views
 Semiconductors     expressed here may not reflect even  my  own  opinions!

 
 
 

Code generation in CASE-tools: results

Post by Stephen W. Liddl » Wed, 12 Jul 1995 04:00:00


I pretty much agree with what you've said, but I'll go
even further.  I don't think we should have to worry
about generating code at all.  We ought to be able to
deal with our systems in terms of analysis and design
models, and let the development environment manage the
execution details.

By analogy, assembly language is much less important
now than it was 20 years ago.  Likewise, I think that
in another 20 years, we'll have a different concept of
what "code" is.  Of course, we have a long way to go
before we get a system efficient (and stable) enough
to hide the code entirely.

--
Steve Liddle

 
 
 

Code generation in CASE-tools: results

Post by Jean11 » Mon, 17 Jul 1995 04:00:00



experiences in using code generators:

(snip lots of interesting comments)

Quote:>    - They are not stable enough!! If you generate your code with
>          your CASE-tool, the CASE-tool manages your code. You can't wait
>      for the next, "better" version and you can't switch to another
>      tool, because every tool has it's own, proprietary repository.
>    - The big advantage if you use a CASE-tool it not that you could
>      generate the code automaticly, but the documentation of your
>      code. With that documentation it is easy to write the code by

hand.

Completely agree.

The organization I used to work for tried very hard to use code generators
for large applications.  We found the following:

 - generators do very well if and only if your application specifically
meets ALL the design assumptions made by the tool vendor.  That is, you
must use the exact relational data base, the exact platform, the exact GUI
generators, etc., etc.

- the CASE tools have an implied methodology, which is more or less
rigidly enforced by the tool.  If your application doesn't completely fit
the methodology, you will have to fake it out (tough and not always worth
the trouble).  For example, we had one
project that involved combining information engineering with image capture
and feature extraction.  No one tool supported all  things well.

- because of consistency enforcement, some tools don't permit stepwise
refinement; they don't let you enter incomplete or inconsistent
information.  That's good from a consistency perspective, but difficult
when you are trying to sketch out a possible design for a new feature.

- many tool vendors are assuming that a small number of developers are
working on a particular application at a given time (one tool vendor told
us they expected six developers on a given application). Since our
applications were large, we had fifty or more developers trying to work on
the same model.  Often they were locked out -- not because of license
contention, but because the tool locked up objects that were touched by
other objects that were checked out.  So when a significant object was
checked out, very few people could continue working until it was checked
back in.

- the generated code must meet your performance requirements without
modification.

The minute you start to have to modify the generated code, you buy
yourself a pile of trouble.  We ran into the following scenario because we
had to use a different data base tool:

   - modify the generated code at the time that it is unit tested so that
we could test with the right data base and so that the
     modifications could be made while the design was fresh in the
developer's mind

                - this meant that if the code did not pass unit test, it
had to be re-generated, modified again, etc.
                - this also meant that the code would have to be checked
in at that point to our source code management
                   system and managed as if it were hand-coded
                - the design implicit in the code generator would have to
be either maintained in parallel to the changes
                  made in the modified code or the design would have to be
abandoned as obsolete.  The developers got
                  to the point where they felt like they were solving
problems twice (once in the code and then a different
                  solution to make the CASE tool design documentation
right).  In part this had to do with the fact that
                  part of the application had a very different paradigm
than the one anticipated in the CASE tool.

  -  modify the generated code in one big batch just before a major
release.  Have a couple of days dedicated to making
     all the changes to hook to the data base, improve performance, etc.

                - this meant that all other bug fixes, etc. were on hold
                - it also meant that the developers would have to try to
read the generated code (very ugly, hard to follow)
                  and remember the correct data base connections they had
in mind when they first coded it
                - the released code will not be the same as the unit
tested code, so the unit test results would be
                   invalid.

By the time they added up all the data base calls that would be modified,
the performance changes, etc.  It wasn't worth it.

Jean Stanford  
Hestia Systems   Requirements Elicitation / Software CM / Software Team
Formation

 
 
 

1. Announcement: Freeware CASE tool with C++ code generation.

ClassBuilder is a CASE tool running on Win95/98/NT, targeted at the C++
developer. It lets you create, manipulate and navigate classes, class
relations, class members and class methods at a high level of abstraction
trough a graphical user interface. Its main focus is to keep the design and
implementation consistent with each other. This is done by generating the
code and documentation from the same repository. This code generation
includes the code for associations/aggregations between classes. It is not
made to impress managers, but to help C++ developers to do their job, so no
features useful for nothing. Its rich feature list includes:

- Class diagram editing (UML), with placement optimisation of classes on
drawing.
- Code generation to implement associations/aggregations, with navigation
methods and iterators.
- Generation of Find methods on one to many associations/aggregations and
Get/Set methods on members.
- Wizards to insert iteration loops and navigation paths into the code of
methods.
- Code synchronisation with compile environment, changes made outside
ClassBuilder are noticed and read back.
- When used together with MFC, code can be generated to serialise the data
structure.
- Drag and drop support for: Adding a member to a class, adding arguments,
changing the order of arguments, etc.
- Documentation generation in RTF and HTML, so the documentation is always
in phase with the code.
- Changes made in the generated RTF documentation can be read back into
ClassBuilder. So you can use your favourite editor to alter the
documentation and get the changes back into the repository!

This freeware tool can be downloaded at the following sites:
http://homestead.dejanews.com/user.Xvenemaj/files/ClassBuilder.htm
&
http://members.tripod.lycos.nl/JimmyVenema/ClassBuilder/ClassBuilder.htm

Jimmy Venema

2. How to set and get selected documents in a view via LotusScript ??

3. TFX

4. Good OO CASE tool with C++ code generation

5. Debugger

6. ADV: EventStudio 1.5: Sequence Diagram/Use Case Generation Tool

7. DIFFICULT Question - HELP!!

8. Objecteering 4.2.2.a : UML CASE TOOL JAVA & C++ Generation => 1 month FREE !

9. Proceedings of the Workshop on the Next Generation of CASE Tools (NGCT)

10. Call for papers 4th European workshop on the Next Generation of CASE Tools (NGCT-93)

11. Call for papers 4th European workshop on the Next Generation of CASE Tools