Am 16.12.2012 10:21, schrieb Walter Bright:
> On 12/16/2012 12:57 AM, Iain Buclaw wrote:
>> It likely is in bugzilla, but with thousands of open tickets, things get
>> forgotten and suffer the same 'will never get fixed' rigmarole.
>
> On the other hand, not putting it in bugzilla will *guarantee* it is
> forgotten and never fixed.
>
> And actually, several people regularly go through bugzilla removing
> dups, fixing what they can, resolving things that were corrected by
> other fixes, and drawing attention to others.
>
> Very, very few get marked as "will not fix".
>
> Nobody goes through the newsgroup doing this.
>
> Bugzilla has its problems, but I've not seen a better way to do this.
>

Jira? :)

> On Sat, 2012-12-15 at 16:55 +0000, Russel Winder wrote:
>> A quick straw poll.  Do people prefer to have all sources compiled in a
>> single compiler call, or (more like C++) separate compilation of each object followed by a link call.

Separate compilation imposes continuous re-processing of files.
D is a modern language with a proper module system so it's easy to figure out dependencies. imo everything should be passed to the compiler which then should create a dependency graph and begin compilation with the sinks, using as much internal parallelism as possible, as opposed to the crappy makefile-level concurrency C++ uses.

On 12/16/2012 01:13 PM, Blub wrote:
>> On Sat, 2012-12-15 at 16:55 +0000, Russel Winder wrote:
>>> A quick straw poll.  Do people prefer to have all sources compiled in a
>>> single compiler call, or (more like C++) separate compilation of each
>>> object followed by a link call.
>
> Separate compilation imposes continuous re-processing of files.
> D is a modern language with a proper module system so it's easy to
> figure out dependencies. imo everything should be passed to the compiler
> which then should create a dependency graph and begin compilation with
> the sinks, using as much internal parallelism as possible, as opposed to
> the crappy makefile-level concurrency C++ uses.

D is a modern language with a proper module system and a turing-complete type system, so figuring out dependencies is an undecidable problem. What you say still applies though.

Am 16.12.2012 13:13, schrieb Blub:
>> On Sat, 2012-12-15 at 16:55 +0000, Russel Winder wrote:
>>> A quick straw poll.  Do people prefer to have all sources compiled in a
>>> single compiler call, or (more like C++) separate compilation of each
>>> object followed by a link call.
>
> Separate compilation imposes continuous re-processing of files.

Since when?

The main idea about modules is exactly to only process files when they are compiled, once.

Don't mix modules with C and C++ translation units.

--
Paulo

On Sunday, 16 December 2012 at 11:01:40 UTC, David Nadlinger wrote:

> Funny things also happen if you try to be clever by batching modules needing recompilation together (when doing incremental compilation):
>
> http://d.puremagic.com/issues/show_bug.cgi?id=8769

Don't know if this is the same problem but this three year old thread shows some problem doing incremental complication:

http://forum.dlang.org/thread/h8ddc5$1h67$1@digitalmars.com?page=1

The problem is that DMD doesn't output template instantiations to all object files, which will cause linker errors, making incremental compilation harder to implement.

Walter doesn't seem to want to implement a flag that output the template instantiations to all object files.

--
/Jacob Carlborg

On Sun, Dec 16, 2012 at 02:22:04PM +0100, Paulo Pinto wrote:
> Am 16.12.2012 13:13, schrieb Blub:
> >>On Sat, 2012-12-15 at 16:55 +0000, Russel Winder wrote:
> >>>A quick straw poll.  Do people prefer to have all sources compiled in a single compiler call, or (more like C++) separate compilation of each object followed by a link call.
> >
> >Separate compilation imposes continuous re-processing of files.
> 
> Since when?
> 
> The main idea about modules is exactly to only process files when they are compiled, once.
> 
> Don't mix modules with C and C++ translation units.
[...]

Importing the same file from many different places requires the compiler to reparse it each time, if those places are compiled during separate compiler runs.


T

-- 
He who does not appreciate the beauty of language is not worthy to bemoan its flaws.

Am 16.12.2012 16:50, schrieb H. S. Teoh:
> On Sun, Dec 16, 2012 at 02:22:04PM +0100, Paulo Pinto wrote:
>> Am 16.12.2012 13:13, schrieb Blub:
>>>> On Sat, 2012-12-15 at 16:55 +0000, Russel Winder wrote:
>>>>> A quick straw poll.  Do people prefer to have all sources compiled
>>>>> in a single compiler call, or (more like C++) separate compilation
>>>>> of each object followed by a link call.
>>>
>>> Separate compilation imposes continuous re-processing of files.
>>
>> Since when?
>>
>> The main idea about modules is exactly to only process files when
>> they are compiled, once.
>>
>> Don't mix modules with C and C++ translation units.
> [...]
>
> Importing the same file from many different places requires the compiler
> to reparse it each time, if those places are compiled during separate
> compiler runs.
>
>
> T
>

If modules are used correctly, a .di should be created with the public interface and everything else is already in binary format, thus the compiler is not really parsing everything all the time.

Actually, having a strong background in languages with modules, I don't
like having just .d files being given all the time to the compiler, as I
know there are better ways.

--
Paulo

On 12/16/2012 5:36 AM, Jacob Carlborg wrote:
> Walter doesn't seem to want to implement a flag that output the template
> instantiations to all object files.

No "seem" about it!

I think it is a bad solution to the issue.

On 2012-34-16 22:12, Walter Bright <newshound2@digitalmars.com> wrote:

> On 12/16/2012 5:36 AM, Jacob Carlborg wrote:
>> Walter doesn't seem to want to implement a flag that output the template
>> instantiations to all object files.
>
> No "seem" about it!
>
> I think it is a bad solution to the issue.

What's a good solution to the issue, then? Leave it as is?

-- 
Simen

On 12/16/12, Paulo Pinto <pjmlp@progtools.org> wrote:
> If modules are used correctly, a .di should be created with the public interface and everything else is already in binary format, thus the compiler is not really parsing everything all the time.

A lot of D code tends to be templated code, .di files don't help you in that case.