From: Matthijs Kooijman <matthijs@stdin.nl>
Date: Mon, 2 Nov 2009 11:24:23 +0000 (+0100)
Subject: Update outline.
X-Git-Tag: final-thesis~179
X-Git-Url: https://git.stderr.nl/gitweb?p=matthijs%2Fmaster-project%2Freport.git;a=commitdiff_plain;h=72edba19e4b745b8aa064ebd4f105d01a6055d8b

Update outline.
---

diff --git a/Outline b/Outline
index 8b991c6..074f6a6 100644
--- a/Outline
+++ b/Outline
@@ -1,46 +1,52 @@
-Context
-  Other FHDLs (short, Christiaan has details)
-
-  Advantages of clash / why clash?
-
-  VHDL / Verilog / EDIF etc. Why VHDL?
+Introduction
+*       Goals
+*       Outline
 
+*Context
+*       Other FHDLs (short, Christiaan has details)
+*       Advantages of clash / why clash?
 
 Haskell as hardware
-        Simple function -> component interpretation (Model: Structure)
-        Model: State
-          Explicit vs implicit passing of state (e.g, delay)
-          Explicit vs implicit marking
-        Interpret: Polymorphism
-        Interpret: Higher order
+*       Simple function -> component interpretation (Model: Structure)
+*       Partial application
+*       Model: State
+*         Explicit vs implicit passing of state (e.g, delay)
+*         Explicit vs implicit marking
+*       Interpret: Polymorphism
+*       Interpret: Higher order
 	Need: Dependent types
+*       Recursion
 	Impossible things: Infinite recursion, higher order expressions,
-        recursive types.
+                           recursive types, ...
 
 Prototype
-        Choice of Haskell
-        Core - description of the language (appendix?)
-	Stages (-> Core, Normalization, -> VHDL)
-        Implementation issues
+*       Choice of Haskell
+        VHDL / Verilog / EDIF etc. Why VHDL?
+*	Stages (-> Core, Normalization, -> VHDL)
+.       Core - description of the language (appendix?)
+        Implementation issues -- Which?
+        State annotations
 
         Haskell language coverage / constraints
                 Recursion
                 Builtin types
                 Custom types (Sum types, product types)
                 Function types / higher order expressions
+                State type -> Anything representable
 
 Normalization
-	Normal form
-	Rules used
-	Completeness / conditions on input
-	Termination
+*	Normal form
+*	Rules used
+.	Properties / Proofs (termination, soundness, completeness, determinism)
 	Casts / Strictness / Casebinders not fully supported
 
 Future work
-	Boilerplate reduction (State distribution & pipelining)
-	Recursion
-        Multiple time domains (Events) -- Also, clock line optimization /
+.	Boilerplate reduction (State distribution & pipelining)
+*	Recursion
+*       Multiple time domains (Events) -- Also, clock line optimization /
                                        -- write enable
-	Multiple cycle descriptions
-        Higher order state
-        New language
+*	Multiple cycle descriptions
+*       Higher order state
+*       New language
+
+TODO: Define user / developer