[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]


> CONCURRENCY, State Models & Java Programs.
> Magee & Kramer ... April 1999 ... ISBN 0-471-98710-7 ... etc.

I have seen a copy of this (and Barry had one floating around).

It looks very interesting and good, but I've only had a very light skim
through so far.  Their FSP (Finite State Processes) are *very* CSP-like,
both syntactically and semantically, and their design approach:

  o build FSP model;
  o use tool (in attached CD-ROM) to animate and (limited) validate;
  o transform down to Java threads (at the level of sync/wait/notify).

looks very sound.  The book has lots of good-looking examples (that
seem well-worth borrowing ;-).

Problems - maybe ... ???

  o the ordinary Java designer/programmer will not want to write
    all those FSP (CSP) equations and reason at that level??
  o the resulting code should not be maintained at that level,
    but must be maintained alongside the FSP formalisms.

I guess it may boil down to Dijskstra's line that only mathematicians
should be allowed to get involved with programming.  If so, then the
above approach will work.  If not, then maybe the above approach should
still be enforced for `critcal' applications (or sub-systems).  That's
what we would recommend in any case for occam-built systems.

The neat thing about occam is that it enables the *ordinary* programmer
on the Clapham omnibus to engage successfully in complex design and
implementation.  You don't need to be fluent in CSP to get its advantages
... you just need to use something that has its simple formalisms and
compositional semantics built-in.  And OO just doesn't hack it ...