Adug meeting 21/2/22
There were about 6 of us in attendance at the shed last night.
With another few online.
There was a bit of a Soap box at the start, Brian asked about XML
verification in Delphi. He has one in C# that works quite well, and
would like one in Delphi (maybe).
Robert Horbury-Smith gave a presentation on Elevate Web Builder.
Current version is 3.
It seems good, build your forms and event handlers using very Object
Pascal like code, and Delphi Like form builder, and it gets turned into
Javascript, and HTML.
Has a client side dataset component.
Elevate has it’s own web server, but for secure production purposes
Robert recommended using the Mormot one. He spent a lot of time looking
at solutions, and Elevate with Mormot won out.
Mormot is free, open source, its downside is its learning curve…
Integration with Mormot, for Version 3 is coming, (so need to use V2 at
present) V3 has much better debugging.
Seems Reasonably priced.
There are a bunch of 3rd party addons (controls), books etc.
Erick Engelke, (He is very smart, so books may be less easy)
We had a short break.
John McDonald then gave a demo of Functional programming using Object
Pascal. (Using Lazarus/fpc, as his Delphi VM is currently unhappy)
Some advantages of functional programming are that things can be proved
to be correct much easier. And they can scale well. Good Multi Threaded.
There are no procedures, as to be of use a procedure needs to cause a
side effect.
No Side Effects, No Mutable variables.
Need to think about things quite differently to Object Oriented.
He showed how you could rewrite the Factorial and Fibonnaci functions in
a functional way such that there were no mutable variables used. It did
require recursion.
And then what was needed to make the recursion optimizable.
C# and Delphi don’t do Recursion optimization, but we found that with
the right switches FPC does do Tail Recursion optimization.
{$OPTIMIZATION TAILREC}
This was demonstrated with a large fibonnaci calculation where the
program would crash with a stack overflow, but then with the TAILREC
optimization it would complete. (Not accurately though, as the result was
well beyond an Int64’s range).
During the discussion while John was showing us the examples there was a
mention of Haskall, which reminded me how reading the code and
description for the quicksort algorithm in the Haskall intro (not
recently) gave me much better insight into how quicksort actually
worked.
https://wiki.haskell.org/Introduction#Quicksort_in_Haskell
Thank you to Robert and John for presenting at short notice
And to all the attendee’s
Roger
