Re: [Caml-list] Re: exception safety / RAII ?

[Oliver Bandel <oliver@first.in-berlin.de>]

On Mon, Mar 07, 2005 at 05:10:52PM +0000, Jon Harrop wrote:
> On Monday 07 March 2005 14:37, Stefan Monnier wrote:
> > > I very rarely have problems with this.
> >
> > Very rarely having problems with something can't save it from being
> > a very bad practice.  Not explicitly closing your files is (in 99% of the
> > cases) just sloppy coding.
> 
> If we're talking about programs which are expected to run for an arbitrary 
> amount of time (servers, the top-level etc.) then yes.
> 
> However, many programs run for a short time and, in these cases, I believe 
> that OCaml guarantees to close your files at least upon program termination, 
> if not before. Therefore, I would say that implicitly deallocating external 
> resources is not sloppy coding in general.
> 
> > Kinda like letting a GC finalizer close 
> > your windows: when the effect is visible from outside the process it
> > shouldn't be done in a finalizer.
> 
> The term "visible" in this context is subjective.
[...]

If we say "visible from an outer environment", then it is clear,
that this is really unfunctional programming style.

What you are suggesting here?
... => It's how to write programs that introduce side-effects in a statistical
manner and hoping on some subjective likeliehoods that all works well
for all the time.

So, why are you using and promoting functional programming style
(which yields to more safeness in programs), when on the other
side you are layzy in programming?

That is, where the difference is between lazy evaluation of a
programming language and lazy programmer's habbits!

Some people rely on Perl's reference counting and are happy without
"use strict", and others rely on OCaml's Garbage Collector and
are happy with "-unsafe"-option....


But be sure: to write good and reliable software means to rely
on *nothing*!

You can write crap software in *every* language, if you want to...

...and crap begins, where the programmer is to lazy to write
good code.

Good code menas: good readable/understandable/good documented,
  but also reliable because of "knowing what's going on",
which means: prefer functional style, not imperative (and the reason is:
imperative code has side-effects you can not always oversee and which yields
to *stochastical* behaviour ---> that's the same problem, what you
are introducing, when relying on the Garbage Collector instead
of writing good code!).

The advantages of FP will be diminished by your style of programming!


It's like

let const = ref 1 (* no likeliehood here *)
let baviour_of_your_program = ..... (* something wired*)

  let _ = Random.self_init ();
          
    baviour_of_your_program  const (Random.float 10000.0)

Ciao,
   Oliver


P.S.: I tried Random.float max_float and it seems to be always between
       1.<something> * 10^307 ...  1.<something> * 10^308
      Is this a problem of initialization, or a problem of the Random-algorithm,
      or a kind of strange (?) behaviour of a random walk?