Here we go again, sigh.
Is there something wrong about acknowledging that there are nice features in other languages that would be nice to have in FPC provided they could be implemented in a Pascal-ish way ?
Yes. It rarely needs to something useful. It is just parroting other languages bulletlists based on short examples with only a terribly generic "will make language more popular" as so called advantage, without any feel of what is needed or what it is good for, and without investigating any actual needs. Borrowing from GCed languages is especially pointless.
And, more importantly, a project like FPC or lazarus is about so much more than language features. New language features is a tiny corner of the development effort.
FPC has "imported" a number of features from C, which I think is a good thing.
Not so much, most came via Kylix. And even the ones that were local had a specific purpose, and were not implemented as a result of a post like this.
Oxygene is a cobbled together amalgam of features styled to like fashionable. If it were so great, you would be on the Oxygene site using it, not here.
First of all, developer should let their Ego aside for a moment and look rationally on it.
As I said in my post, I did go back to FPC+Lazarus because FPC+Lazarus has:
1) Mostly stable compiler
2) Large library
3) Trillions of plattforms with relative low amount of work to adabt code for the plattforms
4) Stable and actualyl pretty good Debugger as I learned
5) A stable sytanx
those are all points which led me back to it, so this is not a hate against FPC, its just taking things others did to evolve.
Kind of what our mother nature does constantly.
and those points which were taken, were taken because me and other user of Oxygene saw the same so far and of course my own code experience showed me that those features lead to more robust, clean and semantic code and not as you said, that I just say for fun that its better for FPC without any experiencing those.
Butt here some small stuff I dont like of FPC syntax currently with the reason of course.
1) Generics: why introduce a "generic/specialize" keyword, its actually unneseccarry to introduce because what we see as generic is the syntax: "TType<T>" and what we see as specialize is the syntax: "var field: TType<String>"
2) why the need of doing: "procedure ASMCODE; assembler" asm {asm code here..} end;
//why the extra assembler need? the "asm" should be sufficient here, shouldnt it?
3)why even the need of: procedure/function instead like method(or if u dont wanna have this OOP implication, because method is more used for OOP description) then use for instance: "routine Dowork;" or "routine getStuff: TStuff";
4) why doing this for extensions: "TExtension = Type helper for record(TRecord)" instead of: "TExtension = extension of(TMyRecord)" would actually do the same because the extensiontype is based on the type it extens obviously
This is IMO not soooo cleanly designed as I think.