M3 Learning Workflow

[dukester]

In order to easily fiddle with code snippets, I've created the following:

~/programming/modula3/code/sandbox
cat m3makefile 
import ("libm3")
implementation ("mySandbox")
program ("sandbox")

~/programming/modula3/code/sandbox
cat mySandbox.m3 
MODULE mySandbox EXPORTS Main; 
 IMPORT IO;
% playing with variable declarations
VAR v1, v2, v3 : INTEGER := 5;
 BEGIN
    IO.Put("v1 is ");IO.PutInt(v1);IO.Put("\n");
 END mySandbox.
% got warning that v2 and v3 were not used

I then simply run cm3' in the sandbox directory. All I ever need to edit is mySandbox.m3' file. Seems to works ok. Any suggestions / warnings etc? TIA ..

[mikanystrom-intel]

That will work fine.

But keep in mind that, well, the reason the language is called "Modula" is that it is based on, well, "modules".

What I am trying to say is that the way modules interact is one of the key concepts of the language. And to explore that you need more than one of them.

(By the way, I'm using the word "module" in a more general Modula sense here:

what we call a MODULE is an "implementation module" (that's where the m3makefile "implementation" terminology comes from)

what we call an INTERFACE is an "interface module")

[mikanystrom-intel]

yes it's quite a different approach from using a REPL. The upside is that you get type checking, and if you use the type system effectively, you can rule out a lot of bugs from compiling in a separate step.

I actually tend to use a combination of Modula-3 and Scheme in my projects. The Scheme interpreter I use is in the CM3 distribution, but that code may not work 100% at the moment. I need to fix it ... (update it to match what I use privately).

[dukester]

How does that work? Using Scheme and M-3 together?

[mikanystrom-intel]

I think I started documenting it at some point, but the docs aren't really there yet.

It's based on the way Peter Norvig's JScheme works in Java. Basically there's a mapping of every base type of Modula-3 to Scheme, with an emphasis on simple functionality, and an obvious mapping of Scheme types to Modula-3---since the Scheme interpreter is written in Modula-3, the Scheme types are just the types used internally in the implementation.

Then we use m3tk to generate stubs and "surrogates" the way the Network Objects system works.

http://birrell.org/andrew/papers/115-NetworkObjects-SOSP.pdf

The upshot is that with very few exceptions you can create Modula-3 objects and call Modula-3 procedures and methods from the Scheme REPL. In a more-or-less natural way.

Example... define some junk in m3:

INTERFACE Blackbody;

PROCEDURE PlanckRadiance(T, nu : LONGREAL) : LONGREAL;
  (* spectral radiance in watts per square meter per steradian per hertz at 
     given temperature in kelvin and frequency in hertz *)

END Blackbody.
MODULE Blackbody;
IMPORT Math;

CONST
  h = 6.62607015d-34; (* Planck's constant / [m^2 kg / s] *)
  k =   1.380649d-23; (* Boltzmann's constant / [m^2 kg / s / K] *)
  c =  299792458.0d0; (* speed of light / [m/s] *)
  
PROCEDURE PlanckRadiance(T, nu : LONGREAL) : LONGREAL =
  BEGIN
    (* Planck's Law *)
    WITH t1 = 2.0d0 * nu * nu / c / c,
         ex = Math.exp(h * nu / k / T),
         t2 = h * nu / (ex - 1.0d0) DO
      RETURN t1 * t2
    END
  END PlanckRadiance;

BEGIN END Blackbody.

now call it from Scheme:

(define (make-Bnu T)
  ;; B_nu(T) 
  ;; blackbody radiance per frequency
  (lambda(nu)(Blackbody.PlanckRadiance T nu)))

(define (make-Bl T)
  ;; blackbody radiance per wavelength
  (lambda(l)
    (let ((nu (/ c l)))
      (/ (Blackbody.PlanckRadiance T nu) (/  c (* nu nu))))))

[mikanystrom-intel]

https://github.com/modula3/cm3/tree/master/m3-scheme

[dukester]

Awesome! All the hard work is done in M-3 and then you get to play using Scheme. Maybe down the road, God willing, I'll give it a shot. FTTB, it's strictly M-3 basics for me. My bit of Oberon-2 is helping.