On Thursday, 18 February 2016 at 22:33:15 UTC, Iain Buclaw wrote:
> On 18 February 2016 at 22:23, Jonathan M Davis via Digitalmars-d < digitalmars-d@puremagic.com> wrote:
>
>>[...]
>
> Actually, I'm sure this is a great way to let bugs in.  There's no saying what could happen if you switch compiler and turn the optimisations throttle to full.  In 99% of cases, one would hope all is good.  But the bigger the codebase you're dealing with, the more you should really use both side by side when testing to ensure that no heisenbugs creep in.

Yep, that issue I reported a while ago with floating-point casts comes to mind.

On Thursday, 18 February 2016 at 20:18:14 UTC, David Nadlinger wrote:
> On Wednesday, 17 February 2016 at 22:57:20 UTC, Márcio Martins wrote:
>> […]
>
> On a completely unrelated note, you aren't by any chance the Márcio Martins who is giving a talk at ETH in a couple of days, are you?
>
>  — David

No, I'm not.

On Thu, 18 Feb 2016 22:41:46 +0000, Ola Fosheim Grøstad wrote:

> On Thursday, 18 February 2016 at 22:22:57 UTC, Chris Wright wrote:
>> With copyright, the fact that you created yours on your own is sufficient defense, assuming the courts agree. If by sheer coincidence you come up with code identical to what's in GCC, but you can show that you didn't take the code from GCC, you're in the clear.
> 
> And how are you going to show that? You can't, because it is widespread.

You testify it under oath, and you hope you look honest. You can show a lack of GCC source code on your home computer, possibly.

>> Patents, well, you're infringing even if you didn't refer to any other source. But if you did look at another source, especially if you looked in the patent database, you open yourself up to increased damages.
> 
> There are no damages for GCC.

There are damages for patent infringement. There are higher damages for willful infringement.

The patent doesn't have to be held by the FSF or a contributor to GCC. There might be a patent troll that sued a third party regarding GCC. And thanks to how software patents generally are, it'd probably be regarding something that most C/C++ compilers need to implement and the most obvious implementation for that feature.

If Walter had read the GCC source code from an infringing version after that case came to light, that's the sort of thing that can bring on triple damages. It depends on relative lawyer quality, of course, but it's much harder for the plaintiffs if there's no indication that you've accessed the GCC source code.

On Thursday, 18 February 2016 at 20:28:41 UTC, David Nadlinger wrote:
>
> You can use rdmd with ldmd2 just as well (and presumably gdmd too).
>

First I'm hearing of it.

On Thursday, 18 February 2016 at 23:42:11 UTC, Chris Wright wrote:
> You testify it under oath, and you hope you look honest. You can show a lack of GCC source code on your home computer, possibly.

If they actually have a strong case it will be highly unlikely that you have arrived at it independently. Of course, all you have to do is to remove the code and FSF will be happy. So if you let it go all the way to the court you can only blame yourself for being pedantic.

FSF will only sue over a strong case that carries political weight. A loss in court is a PR disaster for FSF.

> There are damages for patent infringement. There are higher damages for willful infringement.

Iff you use it as a means for production. There is nothing illegal about implementing patented techniques in source code (i.e. describing them) and distributing it.

> regarding GCC. And thanks to how software patents generally are, it'd probably be regarding something that most C/C++ compilers need to implement and the most obvious implementation for that feature.

If that is the case then there will be prior art that predates the patent.

> If Walter had read the GCC source code from an infringing version after that case came to light, that's the sort of thing that can bring on triple damages. It depends on relative lawyer quality, of course, but it's much harder for the plaintiffs if there's no indication that you've accessed the GCC source code.

It should help you, not hurt you, if you learnt about a technique from a widespread codebase from an organization that is known for avoiding patents. If anything that proves that you didn't pick it up from the filed patent and was in good faith?

If the case came to light (e.g. you knew about it) and you didn't vet your own codebase then you will be to blame no matter where you got it from? But FSF would make sure they remove patented techniques from GCC so that scenario would be very unlikely.

In other words, you are more likely to be hit by a bus when crossing the street. I find this kind of anxiety hysterical to be honest. The only thing I get out of this is that companies shouldn't admit to using open source codebases.

Of course, one reason for avoiding reading other people's source code is that you have a client that makes it a requirement.

On Fri, 19 Feb 2016 05:29:20 +0000, Ola Fosheim Grøstad wrote:

> On Thursday, 18 February 2016 at 23:42:11 UTC, Chris Wright wrote:
>> There are damages for patent infringement. There are higher damages for willful infringement.
> 
> Iff you use it as a means for production. There is nothing illegal about implementing patented techniques in source code (i.e. describing them) and distributing it.

That depends on where the patent was filed and where the lawsuit is being executed.

>> regarding GCC. And thanks to how software patents generally are, it'd probably be regarding something that most C/C++ compilers need to implement and the most obvious implementation for that feature.
> 
> If that is the case then there will be prior art that predates the patent.

Not if it's for a feature added to a C++ standard after the patent was filed. Not if it's for a feature that modern compilers consider standard but wasn't standard before the patent was created. Not if it's in a jurisdiction that uses first-to-file rather than first-to-invent.

On Thursday, 18 February 2016 at 21:39:45 UTC, Ola Fosheim Grøstad wrote:
> On Thursday, 18 February 2016 at 21:30:29 UTC, Jonathan M Davis wrote:
>> It's not a strawman. Walter has state previously that he's explicitly avoided looking at the source code for other compilers like gcc, because he doesn't want anyone to be able to accuse him of stealing code, copyright infringement, etc.
>
> Isn't this much more likely to happen if you don't look at the codebase for other compilers? How do you know if someone submitting code isn't just translating from GCC if you haven't looked at GCC?  If you have looked at GCC, then you can just choose a different implementation. :-)
>
> Anyway, the clean-virgin thing in programming is related to reverse engineering very small codebases where the implementation most likely is going to be very similar (like BIOS). So you have one team writing the spec and another team implementing the spec (with no communication between them).

Walter has stated previously that there have been cases of lawyers coming to him about him possibly violating someone else's copyright, and when he tells them that he's never even looked at the source code, that satisfies them. And when the GPL is involved, that' paranoia is probably a very good idea. With the BSD license, and the license that LLVM uses (which is very close to the BSD license), it's nowhere near the same level of issue, since it really only comes down to giving attribution. But we had problems with that at one point with Tango code (which is BSD-licensed), so the dmd and Phobos devs as a whole have avoided even looking at Tango so that we could always, legitimately say that we hadn't looked at it and therefore could not possibly have copied from it.

So, this can be a real problem, even if it's just an issue with someone thinking that you should be giving attribution when you're not. And while the LLVM license would definitely allow LLVM code to be mixed into dmd's backend as long as the appropriate attribution was given, I don't know if Symantec would be okay with that or not. The fact that Symantec owns the dmd backend just makes things weird all around.

Regardless, whether Walter is willing to look at LLVM/LDC or work on it at all is up to him. I doubt that he'll choose to based on what he's said previously, but he might. However, I think that it's quite safe to say that GCC/GDC are completely off the table for him, because that's GPL-licensed, and folks definitely get unhappy when they think that you might have copied GPL code, and it's _not_ as simple as giving attribution to be able to take GPL-licensed code and mix it into your own, since it's a copyleft license (and one of the most extreme of them at that).

- Jonathan M Davis

On Friday, 19 February 2016 at 09:06:28 UTC, Jonathan M Davis wrote:
> On Thursday, 18 February 2016 at 21:39:45 UTC, Ola Fosheim Grøstad wrote:
>> On Thursday, 18 February 2016 at 21:30:29 UTC, Jonathan M Davis wrote:
>>> It's not a strawman. Walter has state previously that he's explicitly avoided looking at the source code for other compilers like gcc, because he doesn't want anyone to be able to accuse him of stealing code, copyright infringement, etc.
>>
>> Isn't this much more likely to happen if you don't look at the codebase for other compilers? How do you know if someone submitting code isn't just translating from GCC if you haven't looked at GCC?  If you have looked at GCC, then you can just choose a different implementation. :-)
>>
>> Anyway, the clean-virgin thing in programming is related to reverse engineering very small codebases where the implementation most likely is going to be very similar (like BIOS). So you have one team writing the spec and another team implementing the spec (with no communication between them).
>
> Walter has stated previously that there have been cases of lawyers coming to him about him possibly violating someone else's copyright, and when he tells them that he's never even looked at the source code, that satisfies them. And when the GPL is involved, that' paranoia is probably a very good idea. With the BSD license, and the license that LLVM uses (which is very close to the BSD license), it's nowhere near the same level of issue, since it really only comes down to giving attribution. But we had problems with that at one point with Tango code (which is BSD-licensed), so the dmd and Phobos devs as a whole have avoided even looking at Tango so that we could always, legitimately say that we hadn't looked at it and therefore could not possibly have copied from it.
>
> So, this can be a real problem, even if it's just an issue with someone thinking that you should be giving attribution when you're not. And while the LLVM license would definitely allow LLVM code to be mixed into dmd's backend as long as the appropriate attribution was given, I don't know if Symantec would be okay with that or not. The fact that Symantec owns the dmd backend just makes things weird all around.
>
> Regardless, whether Walter is willing to look at LLVM/LDC or work on it at all is up to him. I doubt that he'll choose to based on what he's said previously, but he might. However, I think that it's quite safe to say that GCC/GDC are completely off the table for him, because that's GPL-licensed, and folks definitely get unhappy when they think that you might have copied GPL code, and it's _not_ as simple as giving attribution to be able to take GPL-licensed code and mix it into your own, since it's a copyleft license (and one of the most extreme of them at that).
>
> - Jonathan M Davis

For a change he might enjoy being the one that doesn't look/work with the backend, if those legal issues are such a major worry for him.

I remember back when DMD was even closed licensed than today that it sat on a different repo, so people would not look at its code by accident. DMD had its use at the beginning when only Walter was running the show, and things needed to be coded fast, he knew his turf and that allowed him to implement stuff with ease, but today that argument has little value, see the whole Dwarf EH stuff he had to do...

There are plenty things to do in the language design, frontend and runtime, hes work would greatly improve those parts.

On Friday, 19 February 2016 at 09:06:28 UTC, Jonathan M Davis wrote:
> Walter has stated previously that there have been cases of lawyers coming to him about him possibly violating someone else's copyright, and when he tells them that he's never even looked at the source code, that satisfies them. And when the GPL is involved, that' paranoia is probably a very good idea.

If FSF lawyers contact you without solid reason then it is newsworthy and should make headlines.  So I sincerely doubt that anyone from FSF has done so.

Some lawyers are trying to make a living out of acting like manipulative bastards, randomly fishing for a case, hoping you will put something in writing that they can twist. Does not mean they have a leg to stand on, just don't admit anything to them in writing.


> you're not. And while the LLVM license would definitely allow LLVM code to be mixed into dmd's backend as long as the

Well, that would be silly anyway. IMO the better approach would be to create a high level typed IR and have a clean non-optimizing backend (or JIT). Then leave the optimized backend for LLVM.

Basically clean up the source code and introduce a clean separate layer between the templating system and codegen.

That way more people could work on it. Make it easy to work on one aspect of the compiler without understanding the whole.


> Regardless, whether Walter is willing to look at LLVM/LDC or work on it at all is up to him.

Sure. It is better to have a very simple backend for an experimental/reference compiler.

But DMDs backend isn't simpler to understand than LLVM.

If it was dead simple and made the compiler easier to understand, then it would be good to have it in.

Le 17/02/2016 23:57, Márcio Martins a écrit :
> I was reading the other thread "Speed kills" and was wondering if there
> is any practical reason why DMD is the official compiler?
>
> Currently, newcomers come expecting their algorithm from rosetta code to
> run faster in D than their current language, but then it seems like it's
> actually slower. What gives?
>
> Very often the typical answer from this community is generally "did you
> use LDC/GDC?".
>
> Wouldn't it be a better newcomer experience if the official compiler was
> either LDC or GDC?
> For us current users it really doesn't matter what is labelled official,
> we pick what serves us best, but for a newcomer, the word official
> surely carries a lot of weight, doesn't it?
>
>  From a marketing point of view, is it better for D as a language that
> first-timers try the bleeding-edge, latest language features with DMD,
> or that their expectations of efficient native code are not broken?
>
> Apologies if this has been discussed before...

Like you said it's only a marketing issue.

DMD will and can stay the reference, but IMO as you also evoke it the most important thing is certainly to have LDC/GDC more sync with DMD front-end version because new comers will feel comfortable to use an other compiler up to date that can also target more platforms.

I am exactly in this case, I prefer to use a compiler that make my code running on all platforms (android, iOS,...), but I don't want suffering of staying on an older front-end that will limit me by missing features or bugs.
So I am using DMD with some frustration lol.

And ldc/gdc need more love :
1. A direct link to download latest version (instead of a like to the project page)
2. An installer like for DMD that can download Visuald optionally
3. Be auto detected by building tools (dub, Visuald,...)

I know Visuald support ldc, but for dub I didn't find anything on how it find which compiler to use.