Hello Ioan,


I agree

The behavior is:

1. a variable name defined as input of a function (argument of the function) is a local variable of the function (global for sub-levels of the function made by using line());
   Inside the function every time you use that name, the values passed as argument are used; doesn't matter if there is a variable with the same outside the function. In other words, declaring that name as input parameter you override (locally) any variable defined in the parent levels.
   
   examples
   
   
2. variables not defined as input of a function or hidden inside another variable, are searched from the parent(s) level
   
   f(A)=A+b+3 -> if available b is taken going up through the parent levels (the canvas if you don't have nested line()).
   
   
3. If inside the function you use the input as target of the changes, the input changes (call by reference)
   This may be really powerful; f.e. you can process several variables with a single function, using the result of the function for checks or to have more results.
   
   examples (pseudocode)

Edited by user 22 January 2016 21:34:26(UTC)  | Reason: Not specified

The primary purpose of encapsulation was to restrict user from
reverse engineer coding. So, a gear like Mathematica 4.0 as they
though they invented grafting wings on stones, their encapsulated
stuff can't be QA checked, neither it allows user to expand/adapt
the designed capsule. The pros will acert increase in speed.
No so sure of that: Mathematica 4.0 is steam engine vs TGV [Mathcad 11]

Smath is a continuous encapsulator,
of DATA, no matter the name of the
argument because they reflect.
DATA are not parametric. That's why
I can't reproduce De Casteljau svg
algorithm.

Jean

Untitled Encapsulation.sm (9kb) downloaded 36 time(s).

I agree, it is a good practice.



In general, they can (was the behavior of SMath < 0.90).

I think most of the confusion it's my fault; writing my answer I've focused my attention too much on the Ioan's proposal part "to introduce data only by the function parameters", mixing things in a bad way and loosing the point;

Things to point out:

1. The names of variables (including names of input arguments) are local;
   
   
2. "global" variables can be accessed from inside the function and modified locally without changes outside the function (Ioan's example: point 2; this is a pass-by-value under the hood, when an unknown for the line() workspace can be found in the parent levels);
   
   
3. the pass-by-reference feature triggers effects only if you assign values to an input variable (function's arguments) (as you have written, for most of the normal applications input parameters are untouched, this is matter of advanced uses like implicit functions);
   
   
4. it is possible to use the name of a global variable to define a local variable; since locally is no more an unknown, the function from that point doesn't search it in the parent level.

In general, pass-by-reference it keeps a bidirectional channel between the function workspace and the parent level(s); this is cheaper in speed and memory because you don't have to make 2 copies of the variable and the output of the function can be lighter; this is good also for the syntax too, because there are less assignments to make outside the function (this also improves the speed, having less assignments - that are basically copy & destroy actions - pass-by-values).

Note that before SMath 0.90 functions + lines were are all working with pass-by-values (and globals were available as it is now); this feature was introduced in SMath 0.90 to improve functionality like graphs animation, but allows also other stuff (look at the ChordMethod provided by Andrey in the link).

Pass by reference may be tricky but it is part of almost all the programming languages, and often is the default way to pass objects (in the .NET Framework f.e. strings, arrays, class types are passed by reference; numbers, booleans by value).

Edited by user 23 January 2016 23:26:51(UTC)  | Reason: Not specified