Hacker News Reader

Comment by wambotron | Hacker News Reader

What is about community strength? If he's creating applications and enjoys doing it, why does it matter who else is using the same language? Worst case scenario, he can translate libraries from other languages into Object Pascal, but realistically it has a decent-sized community.

I don't see the modernity point, either. Object Pascal has modern features.

View on HN

Re modernity: is is true that Delphi/Object Pascal has no automatic memory management support, and it is up to the programmer to add lots of "try" blocks and manually code up destructors to release the resources?

For example, this tutorial (from 2017) recommends doing "try .. finally: f.Release" block. https://www.thoughtco.com/communicating-between-forms-409254...

This tutorial, which is also from 2017, says that that you need to either explicitly add each member to an owned list, or to explicitly free every class member in destructor: http://newpascal.org/assets/modern_pascal_introduction.html#...

Is this a recommended best practice? I hope not -- most (all?) of the modern languages either have GC, or offer automatic refcounted pointers, and Object Pascal claims to be modern.

Correct. It compiles to binaries without any runtime environment, so you have to manage memory. Apple did something with objective-c (forgot what it was called) that automatically frees your memory based on your code, but it actually inserts the free memory calls. That's the only language that does that AFAIK. Very clever though, memory management can be a pain if you aren't used to it.

The good thing about managing your memory is you don't have memory bloat and you don't have jitters when the GC decides to fire.

I know the disadvantages of GC; what I am asking about is "smart pointer", like C++'s std::shared_ptr, or Rust's Rc. It is used like this:

In the class definition:

    std::shared_ptr<BigStruct> big_struct;

In the constructor (or anywhere else in the program):

    big_struct = std:::make_shared<BigStruct>(arg1, arg2)

and that's it. When there are no more users of the pointer (for example, when the container object disappears), it will get destroyed automatically. There is no magic -- this is a simple reference counting pointer, and the compiler will automatically add the release call to the object destructor, on function exits, or in any other place when the variable is no longer accessible.

I found these things extremely helpful in the modern languages without GC. They are obviously not perfect -- if you have a complex structure with a loop it will never get destroyed -- but they eliminate 99% of all possible memory leaks with a very little effort. And the good news, they have almost no overhead. They are also fully thread-safe, so they become extremely helpful if you have a multi-threaded application and you want to pass the data between the threads.

This is the simplest of things that modern non-GC languages, and this is one of the big reasons why I no longer do C, just C++. There are more advanced features, of course, but I don't think you can call a language "modern" if it does not even have the smart pointers.

I don't believe it does. Last time I was using it, we had to free memory manually. This was probably 2008 or so. They may have added it since.

You can use interfaces as class wrappers if you want referenced-counted class instances in Delphi. All arrays and strings are automatically reference-counted, and records (structs) are values that can be passed around without allocating memory (Delphi supports variable parameters, or pass-by-reference, but without requiring pointers or address-of notation).

As a Delphi application developer, you will most likely not be manually allocating/freeing memory a lot. Delphi's visual component library has a component ownership model. For example, any components/controls that you drop on a form are automatically "owned" by the form and are created/destroyed for you.

It matters because it affects how many third party libraries are available and the number of other people that can understand and work on your code.

Object Pascal may have modern features, but that doesn't mean it is a modern language - nobody is going to start learning it now. Only people that have known it for years already will use it.

Object Pascal is very similar to C# in many ways. It isn't like a developer that has used Java or C# would have a hard time learning and understanding how to use it.

Re: modern languages: a language having modern features isn't a modern language, rather how popular it is at this moment is the most important aspect ? How did that work out for Python ? And where does PHP land using this criteria ? Is PHP better than Object Pascal because more people write PHP code ?

It _is_ a modern language, and people do start learning it when they get jobs that use it. It's just syntax, and it's a really good tool for certain jobs. You should give it a go with Lazarus IDE and see if you still feel that way.

Reply on news.ycombinator.com