Re: [Caml-list] use of ";;" when teaching Ocaml

[Philippe Wang <mail@philippewang.info>]

On Tue, Jun 23, 2015 at 3:27 PM, Alan Schmitt
<alan.schmitt@polytechnique.org> wrote:
> Hello,
>
> Thanks to everyone for your answers, this has given me much food for
> thought.
>
> On 2015-06-23 01:41, Philippe Wang <mail@philippewang.info> writes:
>
>> In my opinion, it's a lot more relevant to use a very limited and very
>> simple subset of OCaml when teaching to beginners. And this subset
>> does not involve expressions at top-level because it's not worth the
>> trouble.
>
> I like this approach because it amounts to saying "one always starts
> a phrase with 'let' or 'type'" (and later in the year there can be
> 'open', 'module', 'include'). I sure can live without top-level
> expressions.
>
> On the other hand, I also like the idea of terminating phrases, simply
> because explaining when it terminates is not trivial otherwise, as
> a 'let' may not be the beginning of a phrase.

Well, a computer is (by definition) stupid, and languages made by
humans are like human: none is perfect! :)
So... there's the global `let` and the local `let...in`, it sucks a
little but everyone is free to propose a new language (yeah, that's
what i used to tell student who would complain about design)  :)


>> Also, using the interactive top-level loop is, in my opinion, not good
>> for beginners. It should only be presented to those who already
>> understand very well the "core" of OCaml. The most frequent issue with
>> the top-level loop is that it gets in the way of the notion of
>> compiling a program, and it might give the false impression that OCaml
>> can be interpreted.
>
> I am curious about this. My goal is to teach the language, and I find
> that a REPL backed with a file works great to do this (using tuareg or
> ocaml-top). What do you use to make sure students have a fast
> compile/debug cycle?

Well, it depends a lot on the skills of the students: for beginners, I
believe it doesn't help a lot to have the REPL. The one very annoying
thing that goes with REPLs is understanding the difference between the
result of a program and what is printed on stdout (or even stderr).
For instance, lots of students would mix "42;;" and "print_int 42;;"
and you would need to spend quite sometime explaining this and
repeating they are not the same at all, and spend quite some energy
containing the bomb that wants to detonate inside of you when they
keep repeating that mistake!

But, if you have some experimented programmers, or some extremely
smart beginners, you may have fun with this kind of things because
there actually are so many of them in OCaml, like a gigantic gold
mine. (I have to admit, I kind of like it. But when I want efficiency,
I don't go there.)

So, fast compile/debug cycle? Well, my suggestion is to use a Makefile
and invoke make as often as possible (meaning as soon ). If the
program is small enough, I won't even use make, I will directly call
ocamlc. (Not ocamlopt, because ocamlc is faster at compiling than
ocamlopt.) Well, then when the program becomes "big" enough, I will
use a Makefile.
The errors messages of ocamlc/ocamlopt are not worse than ocaml
REPL's, sometimes they are even better. Also, it will avoid the
awkward situation where your program works fine with ocaml but won't
compile with ocamlc/ocamlopt, because there's a weirdo that has weak
types... ;-)
Note that it's possible to use `ocaml program.ml`, so you don't have
to do something like `ocamlc program.ml && ./a.out`.

Also, it's not bad to tell your students to declare all their
functions before implementing them. Use for instance
let koala food = failwith "koala not implemented yet", especially when
they have mutually recursive functions: this way they may compile
their programs before they have (wrongly-)implemented everything, and
look for errors, instead of having to have a giant mess to deal
with...

Cheers,
Philippe Wang