Cale Gibbard wrote:

How about a compiler switch for beginners (maybe with an included
script that adds it to the command line) that turns off a bunch of the
more complex issues involved, and uses a beginner's version of the
Prelude?
Well, right now, the complex issues are turned off by having separate types
and separate functions, which works pretty well. Would such a switch
resolve overloading silently to "beginners' types"? If so, some code would
compile with the switch, but not without it--which is pretty scary. You'd
need to check when compiling each module whether it was "beginners"
or not.

Is explaining
Functor really that hard? It's just container types with a way to
apply a function to all of their elements. :)

Also, it seems that classes are one of the first things one has to
teach now anyway, as they're bound to come up in error messages in any
actual programs you try to write. When teaching my friend, I taught
the basics of classes along with types in the first and second lesson
(including how to define them) and presented various values and
functions as examples.
Something tells me your friend wasn't an undergraduate of only moderate
ability, with no programming experience of any kind. Honestly, the difference between a singleton list and its element is a big deal at this stage--words like "container types" would go right over almost all students' heads. You're right that classes must be mentioned early, but there's no need for more than a very basic understanding. I tell my students always to write type signatures at the start, so the error messages they see say things like "No instance Num Bool".
I just tell them that means booleans aren't numbers--they don't need to even
see a class or instance definition to understand that.

   I don't think it should be necessary to completely rule out useful
   features because they might be difficult to newcomers. There should
   always be ways to turn things off, and construct a simpler language
   for new users. Dr. Scheme seems to take this approach, and has a
   pretty fine gradation of languages for leading users from their first
   steps into the finer points of Scheme.

It would be interesting to see a "Dr. Scheme" like approach to Haskell.
But there is a risk with that approach--namely, that students get the
impression (correctly) that they are learning a toy language which isn't
usable for real applications. That is a big-time motivation killer.
(I'm not criticizing Dr Scheme here, but rather how I imagine a flag
of the sort we're discussing might work with Haskell). It's important
that there is a smooth route to infinity and beyond, so one can show
students cool stuff like wxHaskell without discontinuities along the way.
Otherwise they're just glad to finish their Haskell course, and move
on to a real programming language like Java.

Separate syntax for easy and more difficult concepts--separating
comprehensions from do--does provide a very smooth progression for
beginners.

John

_______________________________________________
Haskell-Cafe mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/haskell-cafe

Reply via email to