I've always been torn between whether or not it's wise to have a single language like Object Pascal which is proficient at both application- and system-level programming, or if a split as with VB and VC++ was preferable. Now that so many people demand automatically-managed memory I think I'm moving towards the split approach: Rust (as a specific example) appears to succeed at doing both safely but the cost is having assignment semantics which are rather non-ALGOL.
This is quite an interesting question. I myself think that most of the time manual memory management just introduces unnecessary complexity, especially considering that in most cases, performance (which is the main counter point to automatic memory management) does not really play a role. I often brought this up, but there was this great analysis by Mozilla when they rewrote their CSS engine in Rust, where they analyzed all the bugreports regarding that code, and found that of the 34 bugs tagged as critical security issues, 32 where due to errors in manual memory management (dangling pointers, use after free, etc). So it is clearly very hard to get it right, something everyone seems to have problems with, and when you get it wrong it is a very serious issue.
And I think on some level most pascal developers agree with this, because I've never seen anyone complain that C-Style strings with manual memory management are better then the reference counted pascal strings (same for arrays). And it also shows that it is not that hard to make this work
And this is why I think pascal is an a very weird situation. It tries to be a high level language and a low level language at the same time. We have reference counted strings and arrays, but classes need manual memory management, which is especially weird if you think about that classes already try to go the Javaesque way of hinding the fact that they are pointers in the first place.
A language that manages to incorporate high level and low level concepts simultaniously is C++. For example automated reference counting is done fully on top of already existing language means, by utilizing their stack based classes:
auto ptr = std::make_shared<SomeType>(constructor_args);
ptr->somemethod(...);
What also makes this neat in C++ is that you can overload the dereferencing operator, so you can create classes that for the user behave exactly like a pointer, but internally do other stuff like reference counting.
If management operators would be working correctly this could also be implemented (even though we don't have a dereferencing operator).
Another thing I really like in C++ is the usage of references to hide pointers. Similar to var parameters in pascal functions, but with the difference that this can be appied to any type, parameters, variables and even function return values:
int &operator [](int index) { return self.items[index]; }
As this returns a reference, you can read and write to it, and also take the pointer. In pascal you would need a getter and setter for the indexed property, and this wouldn't allow you to get a pointer to the underlying memory, which would require another property. E.g. from the Tvector class emulating this behavior:
property Items[i : SizeUInt]: T read getValue write setValue; default;
property Mutable[i : SizeUInt]: PT read getMutable;
This hides pointers while also still allowing access to them in the rare cases you need them.
But this comes at the cost of complexity C++ is not an easy language to learn and just behind this one line:
auto ptr = std::make_shared<SomeType>(constructor_args);
is a lot of complex code that requires a rather advanced understanding of C++.
Other modern languages that have been designed from scratch with high level development in mind, usually don't go this low level route anymore at all. Even languages like Swift that are still compiled "on the metal" languages like Pascal, show how through language design you can combat some of the larger problems and causes of bugs in programming. I really like swift in that regard, even though I don't use that language like at all (I haven't had a mac in years) but it has some really neat new ideas (like optionals at the language level), while also sticking to what has been proven (e.g. static typing). This is the advantage of having to design a language from scratch, something that for "grown" languages like C++ or Pascal is not really possible. But still interesting to consider and I can only recommend for people interested in this sort of stuff to take a look at the language guide:
https://docs.swift.org/swift-book/LanguageGuide/TheBasics.htmlBut with respect to the original question, if it is good to have such an in-between language between very low level C like and high level languages like Swift, I think that this can work out. C++ shows that it is possible, but Pascal is not C++. I think generally Pascal is used in areas more associated with high level languages than C++ and I think the language should reflect this. Because at the moment Pascal targets the use cases usually associated with very High level languages (e.g. RAT GUI development) while still being very low level in use.