News for hackers. Stuff that matters.
Re:Programming Algorithms in Lisp: Data Structures by vseloved on Wednesday August 07, 2019 @04:13AM (#20632818)
The point of the article is not to talk about low-level specifics of some language, apart, from, maybe, Lisp sometimes. But, surely, not C++ (although, if you could provide a link with a good and accessible explanation of the differences of the 2 styles I'd add it as a reference for further reading). Stil, I don't see that fundamental difference that you mention. If the differences originate from the points that you listed in the original comments can you, please, make the link more explicit? I understand pass-by-reference as being a slightly higher-level and safer C++ alternative to C's direct pointer-based style. But, surely, I may be missing something. But, it seems that the people who answered the SO question I linked are also missing it. For example, here's a quote: "Basically, references and pointers are not very different from an implementation point of view, the main (and very important) difference is in the philosophy: a reference is the object itself, just with a different name."
Re:Programming Algorithms in Lisp: Data Structures by pjmlp on Wednesday August 07, 2019 @04:45AM (#20632954)
Here is pass by reference and pass by pointer in Pascal.

    type

    Point = record
        x, y : integer
    end;

    procedure ByPointer(p : ^Point);
    begin
        p^.x := 12
    end;

    procedure ByReference(var p : Point);
    begin
        p.x := 12;
        p.y := 33
    end;

    procedure example
    var
      p : Point
    begin
       p.x := 23;
       p.y := 28;
       WriteLn('The point is ', p.x, ' ', p.y);

       ByPointer(@p)
       WriteLn('The point is ', p.x, ' ', p.y);

       p.x := 23;
       p.y := 28;
       WriteLn('The point is ', p.x, ' ', p.y);

       ByReference(p)
       WriteLn('The point is ', p.x, ' ', p.y);
    end;

Actually the concept is already exposed in Algol, a couple of years before C was even an idea.
Re:Programming Algorithms in Lisp: Data Structures by vseloved on Wednesday August 07, 2019 @04:55AM (#20632991)
good point, so, here, it is exactly syntax sugar as, unlike in C++, nothing else except syntax is different from the pointer-based version. Not to mention that, in the article, I was mentioning the general concept that has one (and single) variant, in C and Java, and 2 in Pascal or C++
Re:Programming Algorithms in Lisp: Data Structures by pjmlp on Wednesday August 07, 2019 @07:19AM (#20633668)
Actually it is more than syntax sugar.

I should have provided a better example, this is impossible to do languages like Java and in C requires explicit double indirection to fake how reference types work.

    type
        Point = record
            x, y : integer
        end;


    procedure ByPointer(p : ^Point)
    begin
        New(p);
        p.x := 12
    end;

    procedure ByReference(var p : ^Point)
    begin
        if p <> nil then
           Dispose(p)
        end;
        New(p);
        p^.x := 12;
        p^.y := 33
    end;

    procedure example
    var
      p : ^Point
    begin
       New(p);
       p^.x := 23;
       p^.y := 28;
       WriteLn('The point is ', p^.x, ' ', p^.y, ' at ', p);

       ByPointer(p)
       WriteLn('The point is ', p^.x, ' ', p^.y, ' at ', p);

       p^.x := 23;
       p^.y := 28;
       WriteLn('The point is ', p^.x, ' ', p^.y, ' at ', p);

       ByReference(p);
       WriteLn('The point is ', p^.x, ' ', p^.y, ' at ', p);  (* here p will point to the one allocated in ByReference *)
       Dispose(p);
    end;
Re:Programming Algorithms in Lisp: Data Structures by jstimpfle on Wednesday August 07, 2019 @08:43AM (#20634145)
> Actually it is more than syntax sugar.

Where? I see only syntax sugar. The catchy phrase from the Google C++ style guide is stuck in my head: references have value syntax but pointer semantics. And that's it (and that's why I think references are mostly a bad idea).

> C requires explicit double indirection

Your 2nd example is no different, it's still just "indirection" (value syntax but pointer semantics!). If what you are indirecting is itself a pointer type (as in your 2nd example), then yes, there technically is a "double indirection", but that's besides the point.

> impossible to do in languages like Java

actually, "in every memory safe language there is". You can do this in Pascal because Pascal is really just C-style systems programming. With a few features like references and ARC that pretend otherwise but quickly fall flat on their head.

Re:Programming Algorithms in Lisp: Data Structures by pjmlp on Wednesday August 07, 2019 @10:36AM (#20635052)
Ok I might have to give in with the syntax sugar part, but safety?

Here is my example in C#. So now C# is unsafe?

    class Point
    {
        public int x, y;
    }


    static class CSharpIsUnsafe {
        static void ByPointer(Point p)
        {
            p = new Point();
            p.x = 12;
        }

        static void ByReference(ref Point p)
        {
            p = new Point();
            p.x = 12;
            p.y = 33;
        }
        
        public static void Main(string[] args)
        {
           p = new Point();
           p.x = 23;
           p.y = 28;
           Console.WriteLn($"The point is {p.x} {p.y}");
           

           ByPointer(p)
           Console.WriteLn($"The point is {p.x} {p.y}");

           p.x = 23;
           p.y = 28;
           Console.WriteLn($"The point is {p.x} {p.y}");

           ByReference(ref p);
           Console.WriteLn($"The point is {p.x} {p.y}");
        }
    }
Re:Programming Algorithms in Lisp: Data Structures by jstimpfle on Wednesday August 07, 2019 @03:48PM (#20638180)
I guess it might very well be safe. I don't know C# very well, but I'd assume that ref is sort of a proxy that

1) under the hood stores an (object) reference to the lowest structural ancestor that is GC'ed, as well as an offset from that object to the ref'ed property.

2) is itself GC'ed

Escape analysis might in some cases optimize out the GC'ing of the ref, but that of course doesn't work if the ref does escape.

Something like that, but in any case it's something very different than the Pascal/C++ examples we've talked about.

Re:Programming Algorithms in Lisp: Data Structures by pjmlp on Wednesday August 07, 2019 @05:11PM (#20639127)
The generated code is similar as how a C++ compiler would do it.

Easy to check with VS Assembly visualizer or WinDbg alongside SOS.dll.

D, Ada, CLU, Mesa, Mesa/Cedar, Algol, PL/I, PL/S, PL.8, Delphi, Dylan, .NET, Swift, Oberon, Oberon-2, Component Pascal, Active Oberon, QuickBasic, Turbo Basic are just a couple of examples of languages allowing for pass by value and pass by reference, some of them also quite safe.

And then there is also call by name introduced alongside Algol.

Re:Programming Algorithms in Lisp: Data Structures by vseloved on Wednesday August 07, 2019 @04:24AM (#20632870)
And here's another quote from this very much upvoted answer (https://stackoverflow.com/a/596750/977052): "A reference can be thought of as a constant pointer (not to be confused with a pointer to a constant value!) with automatic indirection, ie the compiler will apply the * operator for you."