home *** CD-ROM | disk | FTP | other *** search
/ BURKS 2 / BURKS_AUG97.ISO / BURKS / LANGUAGE / ADA / LOVELACE / todoles.txt < prev    next >
Text File  |  1996-10-01  |  6KB  |  161 lines
  1. This is a `to do' list for Lovelace lesson contents.
  2.  
  3. ** DO NOT ** just start working on a section; talk with me FIRST!
  4. I'd hate to see three people independently creating the same lesson -
  5. I'd much rather see three people independently creating different lessons!
  6.  
  7. Other reasons I want people to talk with me first:
  8.  * I have to manually create links to each new lesson from the master
  9.    outline. I want to know where I'll need to link to.
  10.  * I want to enforce some minimum level of quality.
  11.  
  12. --- David A. Wheeler
  13.     wheeler@ida.org
  14.  
  15. ==========================================================================
  16.  
  17. = Weaknesses/Missing Sections in current lessons =
  18.  
  19. Lesson 3: (intentionally omitted comments &  pragmas)
  20.  
  21. Lesson 4: Subprogram Basics -
  22.           assignment statements, expressions, procedure calls, function call.
  23.           Should add stuff about named parameter lists (and why they're there),
  24.           call-by-name vs. call-by-value vs. Ada-does "best thing".
  25.  
  26. Lesson 6: Types - improve subtypes vs. new types, ranges, enumeration,
  27.           constrained/unconstrained, constants,
  28.           arrays, improve records, access, tagged records
  29.           (intentionally omit fixed, decimal, discriminants).
  30.           (use ideas of ID'ing queues, etc. as basics?)
  31.           The text for the `record' section is particularly poor;
  32.           I'm getting tired!
  33.  
  34. Lesson 7: Abstract Data Types & OOP
  35.         Describe OO in more detail (probably this should be a link
  36.         to a separate course, since a significant fraction of Lovelace
  37.         users _will_ understand OO concepts).
  38.         Give more specifics, inc. BNF of tagged type definitions
  39.         (currently the text only provides illustrations).
  40.         Private extensions, hierarchy & inheritance,
  41.         primitives & freezing.
  42.         How to call parent (super); dispatch on >1 arg; "=" as exception;
  43.         Multiple inheritance.
  44.  
  45. Lesson 8 : Character and Unbounded_String Types
  46.         Mention Wide_.
  47.         Perhaps package "Ustrings" should be a child package
  48.         of Ada.Strings.Unbounded so that all of its operations would
  49.         be included, but there are potential restrictions to that
  50.         (GNAT requires -gnatg, for example).
  51.  
  52. Lesson 9 : Input/Output (Intentionally deferred:
  53.              Streams, Direct_IO and Sequential_IO).
  54.  
  55. Lesson 10 : Exceptions
  56.  
  57. Lesson 11 : Generic Units
  58.  
  59. Lesson 12 : Access Types
  60.           Doesn't discuss 'Storage stuff.
  61.           I may move this lesson later once
  62.           lessons are added on the forthcoming Ada 95 version of the Booch
  63.           components; it might make sense to discuss Sets and such
  64.           before talking about access types.  Some approaches to teaching
  65.           Ada emphasize Lists or Sets and don't add stuff about
  66.           access values until much later.
  67.  
  68. Lesson 13 : Tasks
  69.          Note deadlock, livelock, & techniques to avoid them
  70.          (prohibiting cycles, client/server thinking).
  71.          Simple is often better [Howes].
  72.          Discuss shared variables, pragma Volatile, pragma Atomic.
  73.  
  74. Lesson 14 : Ada-related information
  75.         Understanding key Ada documents:
  76.          Discuss key LRM terms that will help them understand it.
  77.          Explain the hypertext "zoom" levels.
  78.          Go through an example of looking something up in the LRM.
  79.          AARM.
  80.         Ada letters; GNAT;
  81.         Anna; ASIS; AJPO; validation; Ada Mandate; who's who.
  82.         SPARK. Buhr diagrams, Booch diagrams, ADARTS.
  83.  
  84. Lesson 15: Ada Structure
  85.         This only begins to discuss design issues.  This should be
  86.         significantly expanded, probably with examples and graphical
  87.         descriptions.
  88.         Add description of initialization and elaboration, maybe here.
  89.  
  90. Lesson 16 : Interfacing to Other Languages (esp. C)
  91.         Give more examples, discuss potential conflicts
  92.         (C++ new vs. C++ malloc vs. Ada new; tasking)
  93.  
  94. Lesson 17: Miscellaneous.
  95.  
  96. Lesson 17: Small
  97.         Could add multi-playerness, graphics.  The problem is that
  98.         these things are more platform-specific, and thus less portable.
  99.  
  100. = Lessons not done at all =
  101.  
  102. Lesson : Predefined Attributes: there could be more about them,
  103.          but I've put in one section on them in lesson 17.
  104.  
  105. Lesson : More Input/Output (things requiring Generics & Strings)
  106.  
  107. Lesson : More types
  108.          Mention pragma Pack, use of boolean array as a set.
  109.          Character Map.
  110.          mod type, discriminants, unconstrained types.
  111.  
  112. Lesson : Putting it all together (at this point we've gone through
  113.          a lot of material; work through a sample Ada program so they
  114.          can see how it works together. One approach is to ``dynamically''
  115.          create a program. They'd be given options of how to extend
  116.          a program fragment step by step. For each step they'd get
  117.          feedback (good/bad choice). This could be implemented with the
  118.          current lesson generator - each quiz asks
  119.          how to extend the program fragment next).
  120.  
  121.          I've added program "Small", which doesn't quite live up to the
  122.          "dynamic" description above but at least provides a sample
  123.          Ada program to play with.
  124.  
  125. Lesson : More demo programs. Quadratic equation solver; loans;
  126.          adventure game; cosmic conquest turn server
  127.  
  128. Lesson : Numerics & Random Number Generation (mention complex arithmetic)
  129.  
  130. Lesson : Representation Clauses
  131.  
  132. Lesson : Systems Programming
  133.  
  134. Lesson : Real-Time
  135.  
  136. Lesson : Information Systems
  137.  
  138. Lesson : Performance
  139.          Storage pools.
  140.  
  141. Lesson : Multiple inheritance
  142.          (Mix-ins, delegation)
  143.  
  144. Lesson : Misc.
  145.          Renaming; package elaboration and elaboration order.
  146.  
  147.  
  148. Lesson : Reuse.
  149.          In particular discuss the Booch Ada 95 components or some other
  150.          widely-used reusable set.
  151.  
  152.  
  153. Lovelace has a "bottom up" approach instead of a top-down approach.
  154.  
  155. Currently the lessons give more of a ``whirlwind tour of features''
  156. and less about good Ada style, etc.  Many of the lessons could
  157. be extended with an additional section or so discussing
  158. ``how to use these features well'' - volunteers are welcome on this, too.
  159.  
  160.  
  161.