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