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.