This is a `to do' list for Lovelace lesson contents.

** DO NOT ** just start working on a section; talk with me FIRST!
I'd hate to see three people independently creating the same lesson -
I'd much rather see three people independently creating different lessons!

Other reasons I want people to talk with me first:
 * I have to manually create links to each new lesson from the master
   outline. I want to know where I'll need to link to.
 * I want to enforce some minimum level of quality.

--- David A. Wheeler
    wheeler@ida.org

==========================================================================

= Weaknesses/Missing Sections in current lessons =

Lesson 3: (intentionally omitted comments &  pragmas)

Lesson 4: Subprogram Basics -
          assignment statements, expressions, procedure calls, function call.
          Should add stuff about named parameter lists (and why they're there),
          call-by-name vs. call-by-value vs. Ada-does "best thing".

Lesson 6: Types - improve subtypes vs. new types, ranges, enumeration,
          constrained/unconstrained, constants,
          arrays, improve records, access, tagged records
          (intentionally omit fixed, decimal, discriminants).
          (use ideas of ID'ing queues, etc. as basics?)
          The text for the `record' section is particularly poor;
          I'm getting tired!

Lesson 7: Abstract Data Types & OOP
        Describe OO in more detail (probably this should be a link
        to a separate course, since a significant fraction of Lovelace
        users _will_ understand OO concepts).
        Give more specifics, inc. BNF of tagged type definitions
        (currently the text only provides illustrations).
        Private extensions, hierarchy & inheritance,
        primitives & freezing.
        How to call parent (super); dispatch on >1 arg; "=" as exception;
        Multiple inheritance.

Lesson 8 : Character and Unbounded_String Types
        Mention Wide_.
        Perhaps package "Ustrings" should be a child package
        of Ada.Strings.Unbounded so that all of its operations would
        be included, but there are potential restrictions to that
        (GNAT requires -gnatg, for example).

Lesson 9 : Input/Output (Intentionally deferred:
             Streams, Direct_IO and Sequential_IO).

Lesson 10 : Exceptions

Lesson 11 : Generic Units

Lesson 12 : Access Types
          Doesn't discuss 'Storage stuff.
          I may move this lesson later once
          lessons are added on the forthcoming Ada 95 version of the Booch
          components; it might make sense to discuss Sets and such
          before talking about access types.  Some approaches to teaching
          Ada emphasize Lists or Sets and don't add stuff about
          access values until much later.

Lesson 13 : Tasks
         Note deadlock, livelock, & techniques to avoid them
         (prohibiting cycles, client/server thinking).
         Simple is often better [Howes].
         Discuss shared variables, pragma Volatile, pragma Atomic.

Lesson 14 : Ada-related information
        Understanding key Ada documents:
         Discuss key LRM terms that will help them understand it.
         Explain the hypertext "zoom" levels.
         Go through an example of looking something up in the LRM.
         AARM.
        Ada letters; GNAT;
        Anna; ASIS; AJPO; validation; Ada Mandate; who's who.
        SPARK. Buhr diagrams, Booch diagrams, ADARTS.

Lesson 15: Ada Structure
        This only begins to discuss design issues.  This should be
        significantly expanded, probably with examples and graphical
        descriptions.
        Add description of initialization and elaboration, maybe here.

Lesson 16 : Interfacing to Other Languages (esp. C)
        Give more examples, discuss potential conflicts
        (C++ new vs. C++ malloc vs. Ada new; tasking)

Lesson 17: Miscellaneous.

Lesson 17: Small
        Could add multi-playerness, graphics.  The problem is that
        these things are more platform-specific, and thus less portable.

= Lessons not done at all =

Lesson : Predefined Attributes: there could be more about them,
         but I've put in one section on them in lesson 17.

Lesson : More Input/Output (things requiring Generics & Strings)

Lesson : More types
         Mention pragma Pack, use of boolean array as a set.
         Character Map.
         mod type, discriminants, unconstrained types.

Lesson : Putting it all together (at this point we've gone through
         a lot of material; work through a sample Ada program so they
         can see how it works together. One approach is to ``dynamically''
         create a program. They'd be given options of how to extend
         a program fragment step by step. For each step they'd get
         feedback (good/bad choice). This could be implemented with the
         current lesson generator - each quiz asks
         how to extend the program fragment next).

         I've added program "Small", which doesn't quite live up to the
         "dynamic" description above but at least provides a sample
         Ada program to play with.

Lesson : More demo programs. Quadratic equation solver; loans;
         adventure game; cosmic conquest turn server

Lesson : Numerics & Random Number Generation (mention complex arithmetic)

Lesson : Representation Clauses

Lesson : Systems Programming

Lesson : Real-Time

Lesson : Information Systems

Lesson : Performance
         Storage pools.

Lesson : Multiple inheritance
         (Mix-ins, delegation)

Lesson : Misc.
         Renaming; package elaboration and elaboration order.


Lesson : Reuse.
         In particular discuss the Booch Ada 95 components or some other
         widely-used reusable set.


Lovelace has a "bottom up" approach instead of a top-down approach.

Currently the lessons give more of a ``whirlwind tour of features''
and less about good Ada style, etc.  Many of the lessons could
be extended with an additional section or so discussing
``how to use these features well'' - volunteers are welcome on this, too.


