[fpc-pascal] Fwd: What to do to get new users

[Nikolay Nikolov]

On 10/21/24 5:37 AM, Hairy Pixels via fpc-pascal wrote:
>
> then isn’t Pascal’s requirement to predeclare uninitialized variables 
> the worst possible design? In C you can at least declare a variable 
> with its assignment in one step but with Pascal by design you can 
> always read uninitialized memory with the exception of arguments.
>
> Many bugs I’ve caused because I didn’t set the “result” of a function 
> for example. I wish they could make that an option to always set the 
> default value.
Free Pascal produces warning for uninitialized values and has an option 
to treat warnings as error. My advice is to compile your programs with -Sew
> FPC does nothing to help you manage memory so I would expect more leaks.

It's not nothing. There's:

0) built-in leak detection with the -gh compiler option

1) ansistrings, widestrings and dynarrays

2) record types (as opposed to class), which can live on the stack and 
have a pass-by-value semantics. FPC trunk supports advanced records, so 
you get C++-style copy constructors.

3) the object type also has pass-by-value semantics

4) interfaces are COM-like and reference counted by default. Every 
interface inherits from IUnknown and the compiler automatically inserts 
calls to AddRef() and Release() when a variable enters or leaves scope, 
or when assigning values, or when passing them as parameters. If your 
class is only accessed through interfaces, you can just do:

type

   TMyReferenceCountedClass = class(TInterfacedObject, 
IMyFirstInterface, IMySecondInterface, ...)

> Being able to declare classes on the stack and destroy automatically 
> automates away a big category of memory leaks right there.

You can't with classes, but you can with records, objects and static 
arrays, which are usually more appropriate in these cases.

When using classes, the proper way to use them is to design them with 
some sort of ownership relations between them. For example ClassA 
contains a ClassB, so ClassA is responsible for creating ClassB and 
destroying ClassB, when ClassA is destroyed. That's how 99% of the class 
memory management system works, and it's so easy. The fact that the 
ownerships are explicit, and easily seen (and not hidden like in C++'s 
RAII style) makes thinking about this and debugging it easy. Out of the 
languages that require manual memory management, I've written C, C++, 
Rust and Object Pascal. Object Pascal is the easiest of them all. C 
comes second, but it has some horrible flaws, like the char* strings, 
which are very difficult to use correctly and very bug-prone.

Nikolay
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.freepascal.org/pipermail/fpc-pascal/attachments/20241021/e3861ac0/attachment-0001.htm>