Stefan Glienke

I guess you are a bit naive in your assumption of what it takes to get from something like VSCode to a fully featured IDE like RAD Studio or Visual Studio... Because otherwise why is there still that thing called Visual Studio that MS is putting significant resources into it if they could slap a few extensions onto VSCode?

One of the reasons I never really got into MMX despite everyone telling me that it is a must have was its overloaded UI with all the toolbars and stuff after you installed it. Yes, you can turn off most of it but it would really pleasant if there was a simple option to switch between something like a "light" and "full" version easily (or even more different presets) - possiibly selectable during setup.

Recently I'm in desperate need of the facepalm reaction...

I would really appreciate the possibility to not having already read posts that I did subscribe or comment on to pop up again whenever there is a new comment. I know this is how forum software usually works however it gets very distracting if content that I decided is uninteresting to me keeps popping up again.

And these topics even keep popping up in terms of marking them bold on the overview when only comments by ignored people were written - very annoying. While G+ was certainly not perfect the way notifications worked was fine except the impossibility to get notified on topics without leaving some dummy comment.

No, I want an opt-in, not an opt-out.

Can you tell which classes it considers? For example I have the interface unit in a package and many different DLL projects that implement this interface but not all of them or even none is being opened in the IDE. Is there the possibility to tell the plugin to consider certain directories with sources in them?

That reminds me of googling for PosEx without adding Delphi to put it into context...

If this thread is only a small foreshadowing of how the community (or rather individuals) would react and respond to an open source project and how things are getting discussed I have to say that I would not want to be part of it. Yes, everyone is permitted to his own opinions but the how is important - and I can see in other communities like for example the C# compiler or .Net Core projects that developers don't want to deal with bs and toxic waste but communicate in a civilized manner. ... and that coming from me known as someone who can voice his opinions in a strong way garnished with cursing often enough ...

Nooo! You can't stop this before it complies to godwin's law 😉

It is: https://llvm.org/docs/ExceptionHandling.html

I was tempted yesterday to use it until I figured out how to get the same result (also codegen wise with as little jumps as possible) using loops in a kinda readable way. 😉

Yes, you can do - however using DI with interfaces has a unique benefit in Delphi - you don't need to care for who is responsible for cleaning up. Leaving aside circular references and assuming a topdown object graph you can simply pass down dependencies even to more than one consumer and stuff gets cleaned up properly in the end. Without that you need to track who is the one owning a dependency and responsible for destroying it - possible but more complicated. In GC languages however having only one implementation for an interface (which you might want to do in Delphi because of the aforementioned reason) is considered a code smell by some - see https://blog.ploeh.dk/2010/12/02/Interfacesarenotabstractions/

https://quality.embarcadero.com/issues/?jql=text ~ "inline variable" and affectedVersion in ("10.3 Rio"%2C "10.3 Rio Release 1") and status not in (Resolved%2C Closed)

IDE tooling does not work properly and some of it completely stops, Also inline variables of a managed type are not always properly initialized. As much as I like this feature syntax wise - I would stay away from it for now 😞

This was implemented 10.3 via inline variables. It however is not possible to declare the variable in the old way plus initialize it - you have to declare it inline: procedure DoSomething; begin var MyVar: Integer = 23; // end; You can even omit the type there and it will automatically be Integer: procedure DoSomething; begin var MyVar = 23; // end; See http://blog.marcocantu.com/blog/2018-october-inline-variables-delphi.html

Look for code that uses type inference - if that only happens with DUnitX config, then look for Assert.something calls

The problem is that historically Delphi did not know about interfaces and many of the concepts he describes and even though Delphi now knows about interfaces the RTL/VCL and most of other basic frameworks don't use them. So most of the RTL/VCL code is still inheriting from more or less not really abstract classes in some long inheritance chains (remember those posters that came with older versions of Delphi?) - now try to teach a Delphi developer that only knows this example different...

There is a bit more to it than simply following a mantra - here is some more food for thought: https://www.thoughtworks.com/insights/blog/composition-vs-inheritance-how-choose

I predict that any time in the future the publisher does not want to block until all subscribers have processed their events and thus you will need to do that asynchronously which requires a less naive approach to iterate the subscribers. I know from my multicast events that this can cause a major headache trying to keep performance (not locking all the time) and still being able to detach subscribers in the middle of handling a publish without running into an off by one.

That is why in my lists (inspired by the behavior of .NET) it causes an exception when the source changes during enumeration causing the enumerator to be possible invalid. I also have a Remove method where I can pass a delegate that determines what elements to remove. IME much more robust than handwriting loops and keeping track of such things.

TList<T>.GetEnumerator does not call DoGetEnumerator but directly creates its TEnumerator - so overriding it is pointless. Considering the design in TEnumerable<T>.GetEnumerator to use the virtual DoGetEnumerator I would call this a defect that TList<T> does not stick to this pattern but has its own GetEnumerator. Anyhow why make a new list class just to enumerate stuff in reverse order?

Except when the framework is very naively written and adds a lot of unnecessary overhead and indirections. And yes, unfortunately for some situations IOUtils and other RTL units do exactly that.

Not natively using [weak] attribute. You can only make a record with a [weak] IFoo field and put that into the array.

Common is to post below on forums like this and above on newsgroups where you reply via email.