I filed this issue (https://issues.dlang.org/show_bug.cgi?id=18517) about 8 months ago.  It provides a couple test cases that show that import order changes the semantics of D programs and the order in which modules are passed to the compiler also changes semantics.  This behavior has existed long enough that it's probably time for D to remove and/or qualify some of its claims.  Statements like:

https://dlang.org/spec/module.html

> The order in which ImportDeclarations occur has no significance.

> The order in which modules are imported does not affect the semantics.

The bugzilla issue above shows cases where these statements are demonstrated to be false, and I wouldn't characterize the issue as a bug, rather, a fundamental problem with the way D handles module imports.  The language definition as it exists does not allow import order to be invariant.  Note there are a number of ways to fix this issue (see PRs below) but note that they do require changes to the way D handles imports.

> The semantics of a module are not affected by what imports it.

The module name and or the namespace it exists in will change depending on how the module is imported.  It can change depending on if it was passed in on the command line, or loaded from an import by another module, and the path from which it was loaded can change depending on which module loaded it first.

Based on the response of my pull requests to fix these issues, its clear that these issues are low on the priority list. This is fine and maybe it's better that the maintainers focus on other things rather than this problem, however, I think it's been long enough that keeping these claims on the website and in the documentation is bordering on being deceptive and unethical.  Everyone will have an opinion on where you draw the line, but in my opinion, it's time to come clean.

I've included my pull requests related to these issues.  Feel free to look into them if you want more information.

Relevant Pull Requests:

Fix module/import order invariance: https://github.com/dlang/dmd/pull/7900
Interpret imports the same regardless of other modules passed on the command line: https://github.com/dlang/dmd/pull/7878
Add broken import order invariance tests: https://github.com/dlang/dmd/pull/8165
Deprecate import/module name mismatch (ALL CASES): https://github.com/dlang/dmd/pull/7778

On Monday, 29 October 2018 at 04:58:09 UTC, Jonathan Marler wrote:
> I filed this issue (https://issues.dlang.org/show_bug.cgi?id=18517) about 8 months ago.  It provides a couple test cases that show that import order changes the semantics of D programs and the order in which modules are passed to the compiler also changes semantics.  This behavior has existed long enough that it's probably time for D to remove and/or qualify some of its claims.  Statements like:
>
> https://dlang.org/spec/module.html
>
>> The order in which ImportDeclarations occur has no significance.
>
>> The order in which modules are imported does not affect the semantics.
>
> The bugzilla issue above shows cases where these statements are demonstrated to be false, and I wouldn't characterize the issue as a bug, rather, a fundamental problem with the way D handles module imports.  The language definition as it exists does not allow import order to be invariant.  Note there are a number of ways to fix this issue (see PRs below) but note that they do require changes to the way D handles imports.
>
>> The semantics of a module are not affected by what imports it.
>
> The module name and or the namespace it exists in will change depending on how the module is imported.  It can change depending on if it was passed in on the command line, or loaded from an import by another module, and the path from which it was loaded can change depending on which module loaded it first.
>
> Based on the response of my pull requests to fix these issues, its clear that these issues are low on the priority list. This is fine and maybe it's better that the maintainers focus on other things rather than this problem, however, I think it's been long enough that keeping these claims on the website and in the documentation is bordering on being deceptive and unethical.  Everyone will have an opinion on where you draw the line, but in my opinion, it's time to come clean.
>
> I've included my pull requests related to these issues.  Feel free to look into them if you want more information.
>
> Relevant Pull Requests:
>
> Fix module/import order invariance: https://github.com/dlang/dmd/pull/7900
> Interpret imports the same regardless of other modules passed on the command line: https://github.com/dlang/dmd/pull/7878
> Add broken import order invariance tests: https://github.com/dlang/dmd/pull/8165
> Deprecate import/module name mismatch (ALL CASES): https://github.com/dlang/dmd/pull/7778

Took a look at all four PRs, all of which were closed by you. I don't know why you linked all of them, since dmd/7900 seems to be the latest one with all the changes. Walter did review #7900 earlier this year, but you probably got frustrated when your subsequent ping was not answered.

A better approach would have been to find other dmd reviewers capable of understanding your pull and have them review it. I understand it can be frustrating to have your work just sit there, as I've had the same happen with my much smaller druntime pulls before, but you have to understand that reviewer time is stretched thin.

The fact that Walter took the time to review your pull suggests there is demand for it, nothing is stopping you and other reviewers from getting it in.

On Monday, 29 October 2018 at 06:12:06 UTC, Joakim wrote:
> On Monday, 29 October 2018 at 04:58:09 UTC, Jonathan Marler wrote:
>> I filed this issue (https://issues.dlang.org/show_bug.cgi?id=18517) about 8 months ago.  It provides a couple test cases that show that import order changes the semantics of D programs and the order in which modules are passed to the compiler also changes semantics.  This behavior has existed long enough that it's probably time for D to remove and/or qualify some of its claims.  Statements like:
>>
>> https://dlang.org/spec/module.html
>>
>>> The order in which ImportDeclarations occur has no significance.
>>
>>> The order in which modules are imported does not affect the semantics.
>>
>> The bugzilla issue above shows cases where these statements are demonstrated to be false, and I wouldn't characterize the issue as a bug, rather, a fundamental problem with the way D handles module imports.  The language definition as it exists does not allow import order to be invariant.  Note there are a number of ways to fix this issue (see PRs below) but note that they do require changes to the way D handles imports.
>>
>>> The semantics of a module are not affected by what imports it.
>>
>> The module name and or the namespace it exists in will change depending on how the module is imported.  It can change depending on if it was passed in on the command line, or loaded from an import by another module, and the path from which it was loaded can change depending on which module loaded it first.
>>
>> Based on the response of my pull requests to fix these issues, its clear that these issues are low on the priority list. This is fine and maybe it's better that the maintainers focus on other things rather than this problem, however, I think it's been long enough that keeping these claims on the website and in the documentation is bordering on being deceptive and unethical.  Everyone will have an opinion on where you draw the line, but in my opinion, it's time to come clean.
>>
>> I've included my pull requests related to these issues.  Feel free to look into them if you want more information.
>>
>> Relevant Pull Requests:
>>
>> Fix module/import order invariance: https://github.com/dlang/dmd/pull/7900
>> Interpret imports the same regardless of other modules passed on the command line: https://github.com/dlang/dmd/pull/7878
>> Add broken import order invariance tests: https://github.com/dlang/dmd/pull/8165
>> Deprecate import/module name mismatch (ALL CASES): https://github.com/dlang/dmd/pull/7778
>
> Took a look at all four PRs, all of which were closed by you. I don't know why you linked all of them, since dmd/7900 seems to be the latest one with all the changes. Walter did review #7900 earlier this year, but you probably got frustrated when your subsequent ping was not answered.
>
> A better approach would have been to find other dmd reviewers capable of understanding your pull and have them review it. I understand it can be frustrating to have your work just sit there, as I've had the same happen with my much smaller druntime pulls before, but you have to understand that reviewer time is stretched thin.
>
> The fact that Walter took the time to review your pull suggests there is demand for it, nothing is stopping you and other reviewers from getting it in.

In this case I believe I was told that Walter would need to approve it. Andrei said that him and Walter discussed this issue. They rejected my initial solutions and accepted this one that Andrei and I came up with, but the PR just sat there for months. But, I'm not posting this to say they need to change their priorities, that's their decision but to leave up these demonstrably false claims on the site, now with no plan for a solution is deceptive. Especially when its a fundamental problem with the language and not just an implementation bug. Though I'm not sure that Walter ever understood this, he doesnt engage much with me so Im not sure what he does or doesn't understand.

As for contributing, this is off th point but I feel I should address what you said. Though my experience has been frustrating, thats not the reason I stopped working on D. I can deal with frustration, but I can't fix apathy and disengagement. When you have dozens of pull requests, dozens of hours of work and go months with virtually no response, you realize how much time you're wasting. I had more branches ready to submit but never did because I didnt want to delay my current changes even longer. I just kept working more and more until realized that I had to stop. Even though I very much enjoyed the work I was doing, it felt almost unhealthy to continue. I still do alot of work, it's just that now I do it for organizations that can handle it and for myself. Maybe D will get better about this one day? I hope it does. The language will die of it doesnt. Based on forum activity, it feels like its stagnating but thats just a feeling...hopefully I'm wrong

On 10/29/18 12:58 AM, Jonathan Marler wrote:
> I filed this issue (https://issues.dlang.org/show_bug.cgi?id=18517) about 8 months ago.  It provides a couple test cases that show that import order changes the semantics of D programs and the order in which modules are passed to the compiler also changes semantics.  This behavior has existed long enough that it's probably time for D to remove and/or qualify some of its claims.  Statements like:
> 
> https://dlang.org/spec/module.html
> 
>> The order in which ImportDeclarations occur has no significance.
> 
>> The order in which modules are imported does not affect the semantics.
> 
> The bugzilla issue above shows cases where these statements are demonstrated to be false, and I wouldn't characterize the issue as a bug, rather, a fundamental problem with the way D handles module imports.  The language definition as it exists does not allow import order to be invariant.  Note there are a number of ways to fix this issue (see PRs below) but note that they do require changes to the way D handles imports.
> 
>> The semantics of a module are not affected by what imports it.
> 
> The module name and or the namespace it exists in will change depending on how the module is imported.  It can change depending on if it was passed in on the command line, or loaded from an import by another module, and the path from which it was loaded can change depending on which module loaded it first.

The honest thing is that these are bugs plain and simple. I would never expect or try to explain away the behavior your examples showed.

I changed the issue report from 'enhancement' to 'normal' appropriately.

-Steve

On Monday, 29 October 2018 at 07:17:17 UTC, Jonathan Marler wrote:
> On Monday, 29 October 2018 at 06:12:06 UTC, Joakim wrote:
>> [...]
>
> In this case I believe I was told that Walter would need to approve it. Andrei said that him and Walter discussed this issue. They rejected my initial solutions and accepted this one that Andrei and I came up with, but the PR just sat there for months. But, I'm not posting this to say they need to change their priorities, that's their decision but to leave up these demonstrably false claims on the site, now with no plan for a solution is deceptive. Especially when its a fundamental problem with the language and not just an implementation bug. Though I'm not sure that Walter ever understood this, he doesnt engage much with me so Im not sure what he does or doesn't understand.
>
> [...]

There was a change to the better started with the scholarship. The work done by the students is fantastic. Just have a look at the issues topic of the forum.

At first I also thought the activity is stagnating but I was wrong. It is just fragmented. You can now chose between the forum, discord, Slack and also reddit.

Kind regards
Andre

On Monday, 29 October 2018 at 18:33:39 UTC, Andre Pany wrote:
>
> There was a change to the better started with the scholarship. The work done by the students is fantastic. Just have a look at the issues topic of the forum.
>
> At first I also thought the activity is stagnating but I was wrong. It is just fragmented. You can now chose between the forum, discord, Slack and also reddit.

There is almost no activity on reddit and its fairly stagnant. So its fair to say the community is not split over at reddit.

The argument that D is split does not really apply because if we compare to Rust...

https://old.reddit.com/r/rust/

Very active forum, with first page posts being at maximum 24h hours old.

https://old.reddit.com/r/d_language/

D its posts on the same first page are reaching 2 month old postings.

Rust is just as split between the Rust forum ( very active ), Rust Reddit ( very active ), Rust discord, Rust Slack... so the argument that D is split does not exactly hold water Andre.

Jonathan:

About half a dozen active forums topics per day is normal activity for D. I have been dealing with D for over a year or 2 and can definitely confirm the activity is always like this. Most of the posters here are frequently the same core posters that have been with D for years, that you answering in the posts.

Same as on Reddit. You get new people from time to time posting things and the older guard answering questions. For the rest its kind of dead over at reddit.

D is more active then lets say 3 or 4 years ago but its not exactly a hotbed of activity.


If you think you have issues with order, take a look at bauss his post:

https://forum.dlang.org/post/gckkndggmigijnmrmgae@forum.dlang.org

And yes, people are again arguing about order of execution when the results need to be 01 but they get -10 on DMD. LDC actually evolves correctly to 01. Issues like this are painful for a language you expect to have the core down to a solid bedrock.

LDC 01
DMD -10
GDC -10

If you program between DMD for faster compilation and LDC for performance, this can result in hours or days of debugging / bug hunting.

And in all honesty, the issues that you reported and the above mentioned are only the tip of the mountain. Every few weeks topics comes up where people exec specific behavior and get something totally different.

I understand your frustration.