www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - So what exactly is coming with extended C++ support?

reply "Szymon Gatner" <noemail gmail.com> writes:
Hi,

recently there is much talk about extending C++ interop in D but 
it is unclear to me what that means. Functions and virtual class 
methods are already callable. What else is planned in the near 
future? Exceptions? Support for C++ templates? (that seems 
difficult no?).

Is VS support planned (I think I saw Andrei only asking about GCC 
support for exceptions/stack unwining)? Atm it does not really 
work (even building x64 exe with D lib linked).

 From the PoV of small game developer relying its livelihood on 
C++ I must say that this is great thing. If I had better support 
for 2 things now: C++ interop so we could just start writing new 
code in D and ARM/iOS then we would just move immediately.

In short, I am very happy (but only if you remember about VC 
users!) to hear about this direction. Some people here seem to 
think that this is not relevant effort but clearly they don't 
have existing C++ code to maintain and deal with.
Sep 29 2014
next sibling parent reply Jacob Carlborg <doob me.com> writes:
On 29/09/14 12:00, Szymon Gatner wrote:
 Hi,

 recently there is much talk about extending C++ interop in D but it is
 unclear to me what that means. Functions and virtual class methods are
 already callable. What else is planned in the near future? Exceptions?
 Support for C++ templates? (that seems difficult no?).
Using templates are already supported. Note, they need to instantiated on the C++ side.
 Is VS support planned (I think I saw Andrei only asking about GCC
 support for exceptions/stack unwining)? Atm it does not really work
 (even building x64 exe with D lib linked).

  From the PoV of small game developer relying its livelihood on C++ I
 must say that this is great thing. If I had better support for 2 things
 now: C++ interop so we could just start writing new code in D and
 ARM/iOS then we would just move immediately.
Don't know if this is what you're looking for but this pull request [1] adds support for extern(Objective-C). [1] https://github.com/D-Programming-Language/dmd/pull/3987 -- /Jacob Carlborg
Sep 29 2014
parent "Szymon Gatner" <noemail gmail.com> writes:
On Monday, 29 September 2014 at 14:36:10 UTC, Jacob Carlborg 
wrote:
 On 29/09/14 12:00, Szymon Gatner wrote:
 Hi,

 recently there is much talk about extending C++ interop in D 
 but it is
 unclear to me what that means. Functions and virtual class 
 methods are
 already callable. What else is planned in the near future? 
 Exceptions?
 Support for C++ templates? (that seems difficult no?).
Using templates are already supported. Note, they need to instantiated on the C++ side.
Ah, cool, but I still have no clue what to expect from ongoing discussion on C++ interop. Does anyone know?
 [1] https://github.com/D-Programming-Language/dmd/pull/3987
Yup, I saw it and this makes me very happy. iOS run-time is still an issue tho.
Sep 30 2014
prev sibling next sibling parent reply "bachmeier" <no spam.com> writes:
On Monday, 29 September 2014 at 10:00:27 UTC, Szymon Gatner wrote:

 From the PoV of small game developer relying its livelihood on 
 C++ I must say that this is great thing. If I had better 
 support for 2 things now: C++ interop so we could just start 
 writing new code in D and ARM/iOS then we would just move 
 immediately.
Is that all it would take? Do you also need a GC-free standard library, which seems to be the need of all the others saying "do this and I'll switch from C++"? Are the tools good enough? I don't think anyone is saying C++ interop is unimportant. There are a lot of us already using the language and we don't think C++ interop is the only thing that has value. More important IMO would be releasing a compiler without a bunch of regressions. D is a lot more than a C++ replacement for Facebook or video game developers.
Sep 29 2014
next sibling parent "Wyatt" <wyatt.epp gmail.com> writes:
On Monday, 29 September 2014 at 20:15:06 UTC, bachmeier wrote:
 Is that all it would take? Do you also need a GC-free standard 
 library, which seems to be the need of all the others saying 
 "do this and I'll switch from C++"? Are the tools good enough?
No relation to OP, but I can tell you it is unbelievably more important. For the most part, deficiencies in Phobos can reasonably be worked around or improved. The body of useful libraries written in C++ can't.
 I don't think anyone is saying C++ interop is unimportant. 
 There are a lot of us already using the language and we don't 
 think C++ interop is the only thing that has value.
That's true, but how many wheels are you really willing to reinvent? And how many man years are you willing to spend doing it? -Wyatt
Sep 29 2014
prev sibling parent reply "Szymon Gatner" <noemail gmail.com> writes:
On Monday, 29 September 2014 at 20:15:06 UTC, bachmeier wrote:
 On Monday, 29 September 2014 at 10:00:27 UTC, Szymon Gatner 
 wrote:


 Is that all it would take? Do you also need a GC-free standard 
 library, which seems to be the need of all the others saying 
 "do this and I'll switch from C++"? Are the tools good enough?
Considered how many games (and I don't mean indie anymore, but for example Blizzard's Heartstone) are now created in Unity which uses not only GC but runs in Mono I am very skeptical of anybody claiming GC is a no-go for games. - Especially- that native executable is being built in case of D. I realize AAA's have have their reasons against GC i but in that case one should probably just get UE4 license anyway. Tooling is acceptable for me tbh. Coming from C++ I don't have high expectations anyway. The only good debugger (for C++) is VC++ and so far I'v had surprisingly good experience with VisualD and mixed C++/D application. Stepping into function (between language boundries!) just works. Viewing variable values works properly too whether I in on *.cpp or .d file atm. Overall, can't complain too much especially I am getting all those goodies for free ;) Anyway, I accept that I would be an early adopter and I am OK with some cons that come with it as I see more gains overall. Btw, I think D is THE language to implement gameplay. Compilation times make it on par with scripting languages and since it becomes compiled there are no JIT restrictions on iOS for example. In our case AI will get rewritten from C++/Lua to D as soon as it is practical which s not just yet unfortunately.
 I don't think anyone is saying C++ interop is unimportant. 
 There are a lot of us already using the language and we don't 
 think C++ interop is the only thing that has value. More 
 important IMO would be releasing a compiler without a bunch of 
 regressions. D is a lot more than a C++ replacement for 
 Facebook or video game developers.
Don't get me wrong, I too want all those issue resolved, just saying for myself that (lack) of those features blocks us from adopting at all. And after we're on board I suspect I will join some other unhappy camp :P But for now we can't even get there.
Sep 30 2014
next sibling parent reply "Chris" <wendlec tcd.ie> writes:
On Tuesday, 30 September 2014 at 08:48:19 UTC, Szymon Gatner 
wrote:
 On Monday, 29 September 2014 at 20:15:06 UTC, bachmeier wrote:
 On Monday, 29 September 2014 at 10:00:27 UTC, Szymon Gatner 
 wrote:


 Is that all it would take? Do you also need a GC-free standard 
 library, which seems to be the need of all the others saying 
 "do this and I'll switch from C++"? Are the tools good enough?
Considered how many games (and I don't mean indie anymore, but for example Blizzard's Heartstone) are now created in Unity which uses not only GC but runs in Mono I am very skeptical of anybody claiming GC is a no-go for games. - Especially- that native executable is being built in case of D.
Very interesting.
 I realize AAA's have have their reasons against GC i but in 
 that case one should probably just get UE4 license anyway.

 Tooling is acceptable for me tbh. Coming from C++ I don't have 
 high expectations anyway. The only good debugger (for C++) is 
 VC++ and so far I'v had surprisingly good experience with 
 VisualD and mixed C++/D application. Stepping into function 
 (between language boundries!) just works. Viewing variable 
 values works properly too whether I in on *.cpp or .d file atm. 
 Overall, can't complain too much especially I am getting all 
 those goodies for free ;)

 Anyway, I accept that I would be an early adopter and I am OK 
 with some cons that come with it as I see more gains overall.

 Btw, I think D is THE language to implement gameplay. 
 Compilation times make it on par with scripting languages and 
 since it becomes compiled there are no JIT restrictions on iOS 
 for example. In our case AI will get rewritten from C++/Lua to 
 D as soon as it is practical which s not just yet unfortunately.
It's good to hear that. Maybe you could write a short article about that once you've moved to D. "Porting games to D" or something like that. With D you can develop fast due to short compilation times, that's important for testing and prototyping. iOS/ARM are very important. What's the latest state of affairs? I know some progress has been made but it has been off my radar for a month or two now.
 I don't think anyone is saying C++ interop is unimportant. 
 There are a lot of us already using the language and we don't 
 think C++ interop is the only thing that has value. More 
 important IMO would be releasing a compiler without a bunch of 
 regressions. D is a lot more than a C++ replacement for 
 Facebook or video game developers.
Don't get me wrong, I too want all those issue resolved, just saying for myself that (lack) of those features blocks us from adopting at all. And after we're on board I suspect I will join some other unhappy camp :P But for now we can't even get there.
Sep 30 2014
next sibling parent reply "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 30 September 2014 at 09:32:05 UTC, Chris wrote:
 It's good to hear that. Maybe you could write a short article 
 about that once you've moved to D. "Porting games to D" or 
 something like that. With D you can develop fast due to short 
 compilation times, that's important for testing and prototyping.
I actually was planning on something like that. I am still thinking about writing on automatic binding generation between D and Lua using D's compile-time reflection. Add a UDA to a function, class, method a voila! You can call it from Lua. Magic!
Sep 30 2014
next sibling parent reply "John Colvin" <john.loughran.colvin gmail.com> writes:
On Tuesday, 30 September 2014 at 10:06:47 UTC, Szymon Gatner 
wrote:
 On Tuesday, 30 September 2014 at 09:32:05 UTC, Chris wrote:
 It's good to hear that. Maybe you could write a short article 
 about that once you've moved to D. "Porting games to D" or 
 something like that. With D you can develop fast due to short 
 compilation times, that's important for testing and 
 prototyping.
I actually was planning on something like that. I am still thinking about writing on automatic binding generation between D and Lua using D's compile-time reflection. Add a UDA to a function, class, method a voila! You can call it from Lua. Magic!
I presume you're familiar with http://code.dlang.org/packages/luad
Sep 30 2014
parent "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 30 September 2014 at 10:39:53 UTC, John Colvin wrote:
 On Tuesday, 30 September 2014 at 10:06:47 UTC, Szymon Gatner 
 wrote:
 On Tuesday, 30 September 2014 at 09:32:05 UTC, Chris wrote:
 It's good to hear that. Maybe you could write a short article 
 about that once you've moved to D. "Porting games to D" or 
 something like that. With D you can develop fast due to short 
 compilation times, that's important for testing and 
 prototyping.
I actually was planning on something like that. I am still thinking about writing on automatic binding generation between D and Lua using D's compile-time reflection. Add a UDA to a function, class, method a voila! You can call it from Lua. Magic!
I presume you're familiar with http://code.dlang.org/packages/luad
I am, but it is incredible how much of the binding-code can be generated with just few lines of D. Please, does anybody know anything about my original question? :P
Sep 30 2014
prev sibling parent reply "Chris" <wendlec tcd.ie> writes:
On Tuesday, 30 September 2014 at 10:06:47 UTC, Szymon Gatner 
wrote:
 On Tuesday, 30 September 2014 at 09:32:05 UTC, Chris wrote:
 It's good to hear that. Maybe you could write a short article 
 about that once you've moved to D. "Porting games to D" or 
 something like that. With D you can develop fast due to short 
 compilation times, that's important for testing and 
 prototyping.
I actually was planning on something like that. I am still thinking about writing on automatic binding generation between D and Lua using D's compile-time reflection. Add a UDA to a function, class, method a voila! You can call it from Lua. Magic!
Great. I'm interested in Lua-D interaction. Would you share it on GitHub once it's done? Have you had a look at DerelictLua: https://github.com/DerelictOrg/DerelictLua
Sep 30 2014
next sibling parent "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 30 September 2014 at 11:46:30 UTC, Chris wrote:
 Great. I'm interested in Lua-D interaction. Would you share it 
 on GitHub once it's done?

 Have you had a look at DerelictLua: 
 https://github.com/DerelictOrg/DerelictLua
I was thinking about maybe just posting snippets on the blog but GitHub should be doable. I am not much of a blogger tho... Anyway, I would be nothing new to D programmer but I think it would be quite interesting for C++ programmer dealing with variadic marcos and boost.mpl for (the half of) similar result.
Sep 30 2014
prev sibling parent "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 30 September 2014 at 11:46:30 UTC, Chris wrote:
 Have you had a look at DerelictLua: 
 https://github.com/DerelictOrg/DerelictLua
Forgot to reply to 2nd part: yes I looked at it and in fact I tried my code using it.
Sep 30 2014
prev sibling parent reply Dan Olson <zans.is.for.cans yahoo.com> writes:
"Chris" <wendlec tcd.ie> writes:
 iOS/ARM are very important. What's the latest state of affairs? I know
 some progress has been made but it has been off my radar for a month
 or two now.
The iOS project with LDC has been idle during the windsurfing season :-). Days are geting shorter so I plan to resume work on it. For a start, it needs to be updated to latest LDC version. About 10 phobos unit tests were not passing back in April and most of these were due to floating pointing differences between host (x64) and target (arm). -- dano
Oct 14 2014
parent reply "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 14 October 2014 at 16:09:31 UTC, Dan Olson wrote:
 "Chris" <wendlec tcd.ie> writes:
 iOS/ARM are very important. What's the latest state of 
 affairs? I know
 some progress has been made but it has been off my radar for a 
 month
 or two now.
The iOS project with LDC has been idle during the windsurfing season :-). Days are geting shorter so I plan to resume work on it. For a start, it needs to be updated to latest LDC version. About 10 phobos unit tests were not passing back in April and most of these were due to floating pointing differences between host (x64) and target (arm).
That is good to hear indeed. In your estimate: how much longer until D is usable on iOS?
Oct 14 2014
parent reply Dan Olson <zans.is.for.cans yahoo.com> writes:
"Szymon Gatner" <noemail gmail.com> writes:
 That is good to hear indeed. In your estimate: how much longer until D
 is usable on iOS?
Depends on your definition of "usable" Szymon. If it is just me working on it, I think a standalone LDC cross compiler to 32-bit arm devices with druntime/phobos can be ready in a few months. Maybe early first quarter 2015. By standalone I mean just the LDC toolchain. This would allow a D library to be embedded in an otherwise Objective-C (or maybe Swift?) iOS app. How about bindings for APIs in the iPhone SDK? I think folks can build those as needed with help from Jacob's dstep tool. It would be nice to have a repository for these bindings somewhere though. It would be cool if by Feb/Mar 2015 a demo app could be submited to the App Store, just to test acceptance. I think Walter's D version of "Empire", but with the original ASCII character graphics, would be a fun choice ;-) I really don't know how to predict the timing for the following: Objective-C interop (DIP 43). Without it, it will be hard to go all out "D" in an iOS app. I have not been following the pull request and don't have any idea when it might bubble into LDC via DMD, but not anytime soon I would guess. Would it be good to merge it onto a LDC+iOS git branch? Just as a temporary proof of concept? Then there are all the tool related things that might hinder D use on iOS. Things such as no source level debugging, lack of D/Xcode integration. Oh, and compiling to arm64 for newer devices. -- dano
Oct 14 2014
next sibling parent "Szymon Gatner" <noemail gmail.com> writes:
On Wednesday, 15 October 2014 at 06:50:55 UTC, Dan Olson wrote:
 "Szymon Gatner" <noemail gmail.com> writes:
 That is good to hear indeed. In your estimate: how much longer 
 until D
 is usable on iOS?
Depends on your definition of "usable" Szymon. This would allow a D library to be embedded in an otherwise Objective-C (or maybe Swift?) iOS app.
That is my definition :) I would use static D library in C++ iOS application.
 How about bindings for APIs in the iPhone SDK?  I think folks 
 can build
 those as needed with help from Jacob's dstep tool.  It would be 
 nice to
 have a repository for these bindings somewhere though.
Would be nice but much less important for me.
 It would be cool if by Feb/Mar 2015 a demo app could be 
 submited to the
 App Store, just to test acceptance.
I would gladly do that
 Then there are all the tool related things that might hinder D 
 use on
 iOS.  Things such as no source level debugging, lack of D/Xcode
 integration.
Right
 Oh, and compiling to arm64 for newer devices.
Knowing Apple that will be mandatory for new apps soon. Thanks for all your work!
Oct 15 2014
prev sibling parent reply Jacob Carlborg <doob me.com> writes:
On 2014-10-15 08:50, Dan Olson wrote:

 This would allow a D library to be embedded in an otherwise Objective-C
 (or maybe Swift?) iOS app.
Sure, as long as it's using an Objective-C compatible API.
 How about bindings for APIs in the iPhone SDK?  I think folks can build
 those as needed with help from Jacob's dstep tool.  It would be nice to
 have a repository for these bindings somewhere though.
I will create Dub packages when I need some framework, unless someone else beats me to it.
 Objective-C interop (DIP 43).  Without it, it will be hard to go all out
 "D" in an iOS app.  I have not been following the pull request and don't
 have any idea when it might bubble into LDC via DMD, but not anytime
 soon I would guess.
It needs some refactoring, which I've already started.
 Then there are all the tool related things that might hinder D use on
 iOS.  Things such as no source level debugging
I think I have used Xcode to debug a D application.
 lack of D/Xcode integration.
Yeah, it will be far from as convenient as using Swift but I think it's possible. Most tools Xcode uses: compiling, build nib files and so on are command line tools. For example, TextMate is using Ninja as a build system, completely without Xcode. It still uses nib files and other OS X specific features. -- /Jacob Carlborg
Oct 15 2014
parent reply Dan Olson <zans.is.for.cans yahoo.com> writes:
Jacob Carlborg <doob me.com> writes:

 On 2014-10-15 08:50, Dan Olson wrote:

 Then there are all the tool related things that might hinder D use on
 iOS.  Things such as no source level debugging
I think I have used Xcode to debug a D application.
Specifically here I mean LDC targeted to arm-ios. The linker complains about the generated debug info and I end up stepping through D in arm assembly. -- dano
Oct 16 2014
parent Jacob Carlborg <doob me.com> writes:
On 2014-10-16 17:21, Dan Olson wrote:

 Specifically here I mean LDC targeted to arm-ios.  The linker complains
 about the generated debug info and I end up stepping through D in arm
 assembly.
Oh, right. I was mostly thinking about OS X applications. -- /Jacob Carlborg
Oct 17 2014
prev sibling next sibling parent reply "Johnathan" <johnathan.sanders glowcake.com> writes:
On Tuesday, 30 September 2014 at 08:48:19 UTC, Szymon Gatner 
wrote:
 I realize AAA's have have their reasons against GC i but in 
 that case one should probably just get UE4 license anyway.
UE4 uses a GC internally. The issue with using D's GC for games is a matter of quality/adaptability. Allocations in games should be rare (and after game startup, should mostly be small objects, if there's any allocations at all), so a GC for games would need minimal pauses and extremely quick small allocations.
Sep 30 2014
parent reply "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 30 September 2014 at 09:53:41 UTC, Johnathan wrote:
 On Tuesday, 30 September 2014 at 08:48:19 UTC, Szymon Gatner 
 wrote:
 I realize AAA's have have their reasons against GC i but in 
 that case one should probably just get UE4 license anyway.
UE4 uses a GC internally. The issue with using D's GC for games is a matter of quality/adaptability.
True, but not in the sense that it is using GC-based language. It is custom C++ solution tailored for the purpose.
 Allocations in games should be rare (and after game startup, 
 should mostly be small objects, if there's any allocations at 
 all), so a GC for games would need minimal pauses and extremely 
 quick small allocations.
All true again, pre-allocation can fix lots of pause issues. And simply not using GC in tight loops. While not the greatest fan of Unity, it proved that GC (on top of of VM) is not a concern for (I argue) most of gamedev. Minecraft was originally written in Java for crying out loud yet it didn't stop it from becoming gigantic success.
Sep 30 2014
parent reply "po" <yes no.com> writes:
 All true again, pre-allocation can fix lots of pause issues. 
 And simply not using GC in tight loops. While not the greatest 
 fan of Unity, it proved that GC (on top of of VM) is not a 
 concern for (I argue) most of gamedev. Minecraft was originally 
 written in Java for crying out loud yet it didn't stop it from 
 becoming gigantic success.
Unity the engine is written in C++. When you create a game using Unity you are merely scripting the C++ engine using C#, no different than the countless games that do the same using Lua.
Sep 30 2014
parent reply "Paulo Pinto" <pjmlp progtools.org> writes:
On Tuesday, 30 September 2014 at 13:29:15 UTC, po wrote:
 All true again, pre-allocation can fix lots of pause issues. 
 And simply not using GC in tight loops. While not the greatest 
 fan of Unity, it proved that GC (on top of of VM) is not a 
 concern for (I argue) most of gamedev. Minecraft was 
 originally written in Java for crying out loud yet it didn't 
 stop it from becoming gigantic success.
Unity the engine is written in C++. When you create a game using Unity you are merely scripting the C++ engine using C#, no different than the countless games that do the same using Lua.
This will most likely change when they get their IL2CPP production ready and start moving code from C++ to C#. Or when Microsoft finishes the ongoing work on .NET Native. -- Paulo
Sep 30 2014
parent reply "po" <yes no.com> writes:
 This will most likely change when they get their IL2CPP 
 production ready and start moving code from C++ to C#.

 Or when Microsoft finishes the ongoing work on .NET Native.

 --
 Paulo
I'd not seen IL2CPP before, but from this link: http://blogs.unity3d.com/2014/05/20/the-future-of-scripting-in-unity/ It appears to act as a replacement for the mono VM, allowing for AoT compilation of .Net IL into C++, so that they can benefit from existing C++ compiler tech. It doesn't mention anything about moving C++ into C#. Even with IL2CPP, C# has fundamental design trade offs that make it slower than C++(GC is just one of them), so it wouldn't make much sense to port engine code to C# unless they wanted it to run slower.
Sep 30 2014
next sibling parent "Ola Fosheim =?UTF-8?B?R3LDuHN0YWQi?= writes:
On Tuesday, 30 September 2014 at 13:59:01 UTC, po wrote:
  It doesn't mention anything about moving C++ into C#.
 Even with IL2CPP, C# has fundamental design trade offs that 
 make it slower than C++(GC is just one of them), so it wouldn't 
 make much sense to port engine code to C# unless they wanted it 
 to run slower.
Yes, the info on CIL instruction set suggests that is a very simple IR, which is an advantage if you want to prove safety or write portable code, but that also means CIL will have a hard time beating llvm. Some performance related decisions have to be taken at a higher abstraction level than CIL.
Sep 30 2014
prev sibling next sibling parent reply "Araq" <rumpf_a web.de> writes:
  It doesn't mention anything about moving C++ into C#.
 Even with IL2CPP, C# has fundamental design trade offs that 
 make it slower than C++(GC is just one of them), so it wouldn't 
 make much sense to port engine code to C# unless they wanted it 
 to run slower.
What are these fundamental design trade offs?
Sep 30 2014
next sibling parent reply "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 30 September 2014 at 14:19:51 UTC, Araq wrote:
 It doesn't mention anything about moving C++ into C#.
 Even with IL2CPP, C# has fundamental design trade offs that 
 make it slower than C++(GC is just one of them), so it 
 wouldn't make much sense to port engine code to C# unless they 
 wanted it to run slower.
What are these fundamental design trade offs?
Guys I beg you, is there any chance I will get my answers? ;)
Sep 30 2014
next sibling parent reply "Ola Fosheim =?UTF-8?B?R3LDuHN0YWQi?= writes:
On Tuesday, 30 September 2014 at 14:28:49 UTC, Szymon Gatner 
wrote:
 On Tuesday, 30 September 2014 at 14:19:51 UTC, Araq wrote:
 It doesn't mention anything about moving C++ into C#.
 Even with IL2CPP, C# has fundamental design trade offs that 
 make it slower than C++(GC is just one of them), so it 
 wouldn't make much sense to port engine code to C# unless 
 they wanted it to run slower.
What are these fundamental design trade offs?
http://en.wikipedia.org/wiki/List_of_CIL_instructions
 Guys I beg you, is there any chance I will get my answers? ;)
Nope :) I don't think anyone know what extended C++ actually will look like. Some people say D is going to have std::* support, but that would require someone to keep track of changes in all the c++ compilers D is supposed to support: Clang, G++, and VC++… Some people say they want full support for C++ exceptions, some say it is too difficult… However, you don't need std::* or C++ exceptions for a game? Some aspects of "extended C++ support" is going to be either wishful thinking or non-portable, so you probably should try to avoid depending on it. What are you missing?
Sep 30 2014
parent reply "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 30 September 2014 at 14:34:49 UTC, Ola Fosheim 
Grøstad wrote:
 Guys I beg you, is there any chance I will get my answers? ;)
Nope :)
I suspected so :P
 I don't think anyone know what extended C++ actually will look 
 like.
Great.
 Some people say  D is going to have std::* support, but that 
 would require someone to keep track of changes in all the c++ 
 compilers D is supposed to support: Clang, G++, and VC++…
My thoughts too. Seems like maintenance hell.
 Some people say they want full support for C++ exceptions, some 
 say it is too difficult…

 However, you don't need std::* or C++ exceptions for a game? 
 Some aspects of "extended C++ support" is going to be either 
 wishful thinking or non-portable, so you probably should try to 
 avoid depending on it.  What are you missing?
I use both std/boost and exceptions when makes sense - game is not just rendering and number crunching after all. Tbh what I -am missing- is proper run-time support for what is already suppose to work (building x64 C++/D app crashes when calling writeln() from D side). Win32 support is coming but I expect similar problems (is nobody really mixing C++ and D using VC++ atm?). It would be great to be able to call non-virtual members of C++ classes from D but I don't really need anything else from the language SPECS to start things going - my question is out of pure curiosity. That being said my biggest fear is that D2 will never be finished... I am lurking on those forums for 2 years now, waiting for the signal to start the transition but I need to be sure that in few months everything I need and the code I write will work as expected (and on iOS too). I am not seeing this unfortunately, language is still being actively discussed on the most basic level (allocators, ARC, auto-decoding of utf strings...). It looks like Phobos might need to be rewritten entirely and soon. I will not give up tho, if I must skip D for one more project (which lasts year or two) then be it, hopefully I will be able to use if for the nest one :(
Sep 30 2014
parent reply "Ola Fosheim Grostad" <ola.fosheim.grostad+dlang gmail.com> writes:
On Tuesday, 30 September 2014 at 17:11:48 UTC, Szymon Gatner 
wrote:
 I use both std/boost and exceptions when makes sense - game is 
 not just rendering and number crunching after all.
I used some parts of boost c++0x std on ios a few years ago. I guess it is no longer maintained, but maybe it is possible to use the useful parts of a generic std library and match the memory layout on the D side?
 calling writeln() from D side). Win32 support is coming but I 
 expect similar problems (is nobody really mixing C++ and D 
 using VC++ atm?).
Dunno.
 That being said my biggest fear is that D2 will never be 
 finished... I am lurking on those forums for 2 years now, 
 waiting for the signal to start the transition but I need to be 
 sure that in few months everything I need and the code I write 
 will work as expected (and on iOS too). I am not seeing this
Well, I looked at D1 eight years ago with the intent of using it for game/world content on the server side. It was kind of nice, but the compiler was basic. Then I decided to drop D1 and wait for D2 when it was announced, and been tracking it ever since... So yeah, impatient. I dont think there will be a game friendly D version untill someone decides to cooperate on D--. Basically cutting features and redesign for fast precise GC that minimize cache load and that can run 60 times per sec without taking more than 10% of the cpu. I think it is doable for a given execution and memory model. Add some constraints and performance will happen! :-)
 strings...). It looks like Phobos might need to be rewritten 
 entirely and soon. I will not give up tho, if I must skip D for 
 one more project (which lasts year or two) then be it, 
 hopefully I will be able to use if for the nest one :(
If all the people who want to use it for game content ( not engine, but content ) cooperated and created c++ compatible datatypes then maybe we could have something going within 6-12 months?
Sep 30 2014
parent "Marc =?UTF-8?B?U2Now7x0eiI=?= <schuetzm gmx.net> writes:
On Tuesday, 30 September 2014 at 19:47:32 UTC, Ola Fosheim 
Grostad wrote:
 I dont think there will be a game friendly D version untill 
 someone decides to cooperate on D--. Basically cutting features 
 and redesign for fast precise GC that minimize cache load and 
 that can run 60 times per sec without taking more than 10% of 
 the cpu.

 I think it is doable for a given execution and memory model. 
 Add some constraints and performance will happen! :-)
There's probably not much feature-wise that stands in the way of a fast precise GC. Implicitly shared `immutable` is one example, but other than that, I would say it's mostly unimplemented bits and pieces (missing type information) and "wrong" decisions made when designing the standard library.
Sep 30 2014
prev sibling parent Paulo Pinto <pjmlp progtools.org> writes:
Am 30.09.2014 16:28, schrieb Szymon Gatner:
 On Tuesday, 30 September 2014 at 14:19:51 UTC, Araq wrote:
 It doesn't mention anything about moving C++ into C#.
 Even with IL2CPP, C# has fundamental design trade offs that make it
 slower than C++(GC is just one of them), so it wouldn't make much
 sense to port engine code to C# unless they wanted it to run slower.
What are these fundamental design trade offs?
Guys I beg you, is there any chance I will get my answers? ;)
Sorry got carried away. Ola and others know better.
Sep 30 2014
prev sibling parent reply "po" <yes no.com> writes:
On Tuesday, 30 September 2014 at 14:19:51 UTC, Araq wrote:
 It doesn't mention anything about moving C++ into C#.
 Even with IL2CPP, C# has fundamental design trade offs that 
 make it slower than C++(GC is just one of them), so it 
 wouldn't make much sense to port engine code to C# unless they 
 wanted it to run slower.
What are these fundamental design trade offs?
-GC -no meta programming vs meta programming -defaults to ref semantics C# vs value semantics C++ -C++ supports unique types, C# does not -C# lambda automatic/GC, C++ lambda fully customized via capture list
Guys I beg you, is there any chance I will get my answers? ;)
Sorry no clue what C++ features will be supported! Just glad that a language is acknowledging how important it is to inter-op with C++ for once.
C has fundamental design trade offs that make it slower than 
Assembly
(function prologs is just of them), so it wouldn't make much 
sense to port engine code to C unless they wanted it to run 
slower.
I don't really think this is the same situations. I don't think C# is any higher level than C++. Having a GC does not make it automatically a higher level language, nor does it make it more "productive". That said, I think it is much easier to be productive in C# if you are starting from scratch, but with the proper setup & in depth knowledge of C++, it is every bit as productive(especially in games, where things like GC end up as more of a burden).
Sep 30 2014
next sibling parent simendsjo <simendsjo+dlang gmail.com> writes:
On 09/30/2014 05:32 PM, po wrote:
 On Tuesday, 30 September 2014 at 14:19:51 UTC, Araq wrote:
 It doesn't mention anything about moving C++ into C#.
 Even with IL2CPP, C# has fundamental design trade offs that make it
 slower than C++(GC is just one of them), so it wouldn't make much
 sense to port engine code to C# unless they wanted it to run slower.
What are these fundamental design trade offs?
-GC -no meta programming vs meta programming
(...) C# has wonderful meta-programming facilities: Generics! (/me run and hides)
Sep 30 2014
prev sibling parent Paulo Pinto <pjmlp progtools.org> writes:
Am 30.09.2014 17:32, schrieb po:
 On Tuesday, 30 September 2014 at 14:19:51 UTC, Araq wrote:
 It doesn't mention anything about moving C++ into C#.
 Even with IL2CPP, C# has fundamental design trade offs that make it
 slower than C++(GC is just one of them), so it wouldn't make much
 sense to port engine code to C# unless they wanted it to run slower.
What are these fundamental design trade offs?
-GC -no meta programming vs meta programming
C# has meta programming capabilities via attributes, MSIL manipulation, reflection and having the compiler available as a library. It is not as powerful or clean as D, but it gets the job done in many cases.
 -defaults to ref semantics C# vs value semantics C++
Yes, it is a bummer, but they do exist to a certain extent. One just needs to make use of them.
 -C++ supports unique types, C# does not
Lost me there.
 -C# lambda automatic/GC, C++ lambda fully customized via capture list
Which very few people understand properly and end up capturing the whole environment anyway.
...

   I don't really think this is the same situations. I don't think C# is
 any higher level than C++. Having a GC does not make it automatically a
 higher level language, nor does it make it more "productive".

   That said, I think it is much easier to be productive in C# if you are
 starting from scratch, but with the proper setup & in depth knowledge of
 C++, it is every bit as productive(especially in games, where things
 like GC end up as more of a burden).
The problem is not everyone has good knowledge of C++. I do use C++ on and off since 1993, and always advocated it vs C when it was considered slow(!). However I very seldom met fellow developers on projects with similar C++ knowledge, except for the time I spent at CERN. I follow at the distance the game industry, having tried a few times in the past to be part of it. I was an IGDA member for a while, did attend developer meetups at the game development university in Düsseldorf and buy regularly the game's development magazine of German studios. Many middle size studios in Germany are now betting in C# (Unity/MonoGame) and Flash. Mostly for tooling and indie quality games, but sometimes all the way to production. If D had already a GC that could rival with the CLR GC, it would be a great alternative for the said studios. Regardless what the decision regarding the D's answer to memory management will be. Specially given that it can interoperate better with C and C++ than the marshalling required by the alternatives. -- Paulo
Sep 30 2014
prev sibling parent "Paulo Pinto" <pjmlp progtools.org> writes:
On Tuesday, 30 September 2014 at 13:59:01 UTC, po wrote:
 This will most likely change when they get their IL2CPP 
 production ready and start moving code from C++ to C#.

 Or when Microsoft finishes the ongoing work on .NET Native.

 --
 Paulo
I'd not seen IL2CPP before, but from this link: http://blogs.unity3d.com/2014/05/20/the-future-of-scripting-in-unity/ It appears to act as a replacement for the mono VM, allowing for AoT compilation of .Net IL into C++, so that they can benefit from existing C++ compiler tech. It doesn't mention anything about moving C++ into C#.
No, but it is a possibility.
 Even with IL2CPP, C# has fundamental design trade offs that 
 make it slower than C++(GC is just one of them), so it wouldn't 
 make much sense to port engine code to C# unless they wanted it 
 to run slower.
C has fundamental design trade offs that make it slower than Assembly (function prologs is just of them), so it wouldn't make much sense to port engine code to C unless they wanted it to run slower. I have been through this discussion cycle a few times since the Z80. -- Paulo
Sep 30 2014
prev sibling next sibling parent "Paulo Pinto" <pjmlp progtools.org> writes:
On Tuesday, 30 September 2014 at 08:48:19 UTC, Szymon Gatner 
wrote:
 On Monday, 29 September 2014 at 20:15:06 UTC, bachmeier wrote:
 On Monday, 29 September 2014 at 10:00:27 UTC, Szymon Gatner 
 wrote:


 Is that all it would take? Do you also need a GC-free standard 
 library, which seems to be the need of all the others saying 
 "do this and I'll switch from C++"? Are the tools good enough?
Considered how many games (and I don't mean indie anymore, but for example Blizzard's Heartstone) are now created in Unity which uses not only GC but runs in Mono I am very skeptical of anybody claiming GC is a no-go for games. - Especially- that native executable is being built in case of D.
BlueByte latest games are done in Flash. There is an article on the German magazine Making Games about their experience switching from being hardcore C++ guys into the world of Flash and Stage3D.
 I realize AAA's have have their reasons against GC i but in 
 that case one should probably just get UE4 license anyway.
Which also offers a C++ GC API, although quite limited from what I have read. Sometimes it seems the whole Assembly vs C vs Pascal, followed by C vs C++ performance discussions all over again. -- Paulo
Sep 30 2014
prev sibling next sibling parent reply "Ethan" <gooberman gmail.com> writes:
On Tuesday, 30 September 2014 at 08:48:19 UTC, Szymon Gatner 
wrote:
 Considered how many games (and I don't mean indie anymore, but 
 for example Blizzard's Heartstone) are now created in Unity 
 which uses not only GC but runs in Mono I am very skeptical of 
 anybody claiming GC is a no-go for games. - Especially- that 
 native executable is being built in case of D.

 I realize AAA's have have their reasons against GC i but in 
 that case one should probably just get UE4 license anyway.
Hello. AAA developer (Remedy) here using D. Custom tech, with a custom binding solution written originally by Manu and continued by myself. A GC itself is not a bad thing. The implementation, however, is. With a codebase like ours (mostly C++, some D), there's a few things we need. Deterministic garbage collection is a big one - when our C++ object is being destroyed, we need the D object to be destroyed at the same time in most cases. This can be handled by calling GC.collect() often, but that's where the next thing comes in - the time the GC needs. If the time isn't being scheduled at object destruction, then it all gets lumped together in the GC collect. It automatically moves the time cost to a place where we may not want it. ARC garbage collection would certainly be beneficial there. I looked in to adding support at a language level and at a library level for it, but the time it would have taken for me to learn both of those well enough to not muck it up is not feasible. Writing a garbage collector that we have greater control over will also take up too much time. The simpler solution is to enforce coding standards that avoid triggering the GC. It's something I will look at again in the future, to be sure. And also to be sure, nothing is being done in Unity to the scale we do stuff in our engine (at least, nothing in Unity that also doesn't use a ton of native code to bypass Unity's limitations).
Sep 30 2014
next sibling parent reply "Sean Kelly" <sean invisibleduck.org> writes:
On Tuesday, 30 September 2014 at 21:19:44 UTC, Ethan wrote:
 With a codebase like ours (mostly C++, some D), there's a few 
 things we need. Deterministic garbage collection is a big one - 
 when our C++ object is being destroyed, we need the D object to 
 be destroyed at the same time in most cases. This can be 
 handled by calling GC.collect() often, but that's where the 
 next thing comes in - the time the GC needs. If the time isn't 
 being scheduled at object destruction, then it all gets lumped 
 together in the GC collect. It automatically moves the time 
 cost to a place where we may not want it.
Would delete on the D side work here? Or the more current destroy()? ie. is release of the memory a crucial part of the equation, or merely finalization?
Sep 30 2014
parent "Ethan" <gooberman gmail.com> writes:
On Tuesday, 30 September 2014 at 22:32:26 UTC, Sean Kelly wrote:
 Would delete on the D side work here?  Or the more current
 destroy()?  ie. is release of the memory a crucial part of the
 equation, or merely finalization?
Destruction of an object is *far* more important than releasing memory. Our D code's memory usage is drops in an ocean, but it can potentially hold on to resources that need to be destroyed in special ways depending on middleware/threading usage. Object.destroy() would do the job, but there's also a fragmentation problem that creeps in to a GC solution like the default D implementation the longer you have your application running. We already encounter plenty of cache-incoherent code in other areas of the codebase, and since one of my roles is to evangelise D (so to speak) I'm aiming to keep it running fast and avoiding as many stalls as possible. If I avoid the current implementation's garbage collection, then memory allocated stays in roughly the same region (some work that I did manage to do and intend on submitting a pull request for allows a user to specify a custom set of allocation functions, so all memory from core and phobos goes through our supplied memory allocator). Either way, it still comes down to a function call to free your object which means you're stepping outside of the way the GC natively does things.
Oct 01 2014
prev sibling next sibling parent reply "Cliff" <cliff.s.hudson gmail.com> writes:
On Tuesday, 30 September 2014 at 21:19:44 UTC, Ethan wrote:
 Hello. AAA developer (Remedy) here using D. Custom tech, with a 
 custom binding solution written originally by Manu and 
 continued by myself.

 A GC itself is not a bad thing. The implementation, however, is.

 With a codebase like ours (mostly C++, some D), there's a few 
 things we need. Deterministic garbage collection is a big one - 
 when our C++ object is being destroyed, we need the D object to 
 be destroyed at the same time in most cases. This can be 
 handled by calling GC.collect() often, but that's where the 
 next thing comes in - the time the GC needs. If the time isn't 
 being scheduled at object destruction, then it all gets lumped 
 together in the GC collect. It automatically moves the time 
 cost to a place where we may not want it.
Not a GC specialist here, so maybe the thought arises - why not turn off automatic GC until such times in the code where you can afford the cost of it, then call GC.collect explicitly - essentially eliminating the opportunity for the GC to run at random times and force running at deterministic times? Is memory usage so constrained that failing to execute runs in-between those deterministic blocks could lead to OOM? Does such a strategy have other nasty side-effects which make it impractical?
Sep 30 2014
parent "Marc =?UTF-8?B?U2Now7x0eiI=?= <schuetzm gmx.net> writes:
On Tuesday, 30 September 2014 at 23:31:36 UTC, Cliff wrote:
 Not a GC specialist here, so maybe the thought arises - why not
 turn off automatic GC until such times in the code where you can
 afford the cost of it, then call GC.collect explicitly -
 essentially eliminating the opportunity for the GC to run at
 random times and force running at deterministic times?  Is 
 memory
 usage so constrained that failing to execute runs in-between
 those deterministic blocks could lead to OOM?  Does such a
 strategy have other nasty side-effects which make it 
 impractical?
The latter. If you want a game to run at 60 fps, you have about 16 ms for each frame, during which time you need to make all the necessary game and graphics updates. There's no upper to limit to the amount of time a GC run can take, so it can easily exceed the few ms you have left for it. There are however GC algorithms that support incremental collection, meaning that you can give the GC a deadline. If it can't finish before this deadline, it will have to interrupt its work and continue on the next run. Unfortunately, these GCs usually require special compiler support (barriers, and distinguishing GC from non-GC pointers), which we don't have. But there is CDGC writte by Leandro Lucarella for D1, which uses a forking to achieve the same effect, and which Dicebot is currently porting to D2: http://forum.dlang.org/thread/exfrifcfczgjwkudqdgx forum.dlang.org
Oct 01 2014
prev sibling next sibling parent "Kiith-Sa" <kiithsacmp gmail.com> writes:
On Tuesday, 30 September 2014 at 21:19:44 UTC, Ethan wrote:
 On Tuesday, 30 September 2014 at 08:48:19 UTC, Szymon Gatner 
 wrote:
 Considered how many games (and I don't mean indie anymore, but 
 for example Blizzard's Heartstone) are now created in Unity 
 which uses not only GC but runs in Mono I am very skeptical of 
 anybody claiming GC is a no-go for games. - Especially- that 
 native executable is being built in case of D.

 I realize AAA's have have their reasons against GC i but in 
 that case one should probably just get UE4 license anyway.
Hello. AAA developer (Remedy) here using D. Custom tech, with a custom binding solution written originally by Manu and continued by myself. A GC itself is not a bad thing. The implementation, however, is. With a codebase like ours (mostly C++, some D), there's a few things we need. Deterministic garbage collection is a big one - when our C++ object is being destroyed, we need the D object to be destroyed at the same time in most cases. This can be handled by calling GC.collect() often, but that's where the next thing comes in - the time the GC needs. If the time isn't being scheduled at object destruction, then it all gets lumped together in the GC collect. It automatically moves the time cost to a place where we may not want it. ARC garbage collection would certainly be beneficial there. I looked in to adding support at a language level and at a library level for it, but the time it would have taken for me to learn both of those well enough to not muck it up is not feasible. Writing a garbage collector that we have greater control over will also take up too much time. The simpler solution is to enforce coding standards that avoid triggering the GC. It's something I will look at again in the future, to be sure. And also to be sure, nothing is being done in Unity to the scale we do stuff in our engine (at least, nothing in Unity that also doesn't use a ton of native code to bypass Unity's limitations).
GC.free() can be used to manually delete GC-allocated data. (destroy() must be called first to call te destructor, though) - delete does both but is deprecated. You could write a simple RAII pointer wrapper if you don't want to always call destroy()+GC.free() manually. Or do you need something else?
Sep 30 2014
prev sibling parent "Paulo Pinto" <pjmlp progtools.org> writes:
On Tuesday, 30 September 2014 at 21:19:44 UTC, Ethan wrote:
 On Tuesday, 30 September 2014 at 08:48:19 UTC, Szymon Gatner 
 wrote:
 Considered how many games (and I don't mean indie anymore, but 
 for example Blizzard's Heartstone) are now created in Unity 
 which uses not only GC but runs in Mono I am very skeptical of 
 anybody claiming GC is a no-go for games. - Especially- that 
 native executable is being built in case of D.

 I realize AAA's have have their reasons against GC i but in 
 that case one should probably just get UE4 license anyway.
Hello. AAA developer (Remedy) here using D. Custom tech, with a custom binding solution written originally by Manu and continued by myself. A GC itself is not a bad thing. The implementation, however, is. With a codebase like ours (mostly C++, some D), there's a few things we need. Deterministic garbage collection is a big one - when our C++ object is being destroyed, we need the D object to be destroyed at the same time in most cases. This can be handled by calling GC.collect() often, but that's where the next thing comes in - the time the GC needs. If the time isn't being scheduled at object destruction, then it all gets lumped together in the GC collect. It automatically moves the time cost to a place where we may not want it. ARC garbage collection would certainly be beneficial there. I looked in to adding support at a language level and at a library level for it, but the time it would have taken for me to learn both of those well enough to not muck it up is not feasible. Writing a garbage collector that we have greater control over will also take up too much time. The simpler solution is to enforce coding standards that avoid triggering the GC. It's something I will look at again in the future, to be sure. And also to be sure, nothing is being done in Unity to the scale we do stuff in our engine (at least, nothing in Unity that also doesn't use a ton of native code to bypass Unity's limitations).
Thanks for the feedback, quite interesting.
Oct 01 2014
prev sibling parent reply Nick Sabalausky <SeeWebsiteToContactMe semitwist.com> writes:
On 09/30/2014 04:48 AM, Szymon Gatner wrote:
 On Monday, 29 September 2014 at 20:15:06 UTC, bachmeier wrote:
 On Monday, 29 September 2014 at 10:00:27 UTC, Szymon Gatner wrote:


 Is that all it would take? Do you also need a GC-free standard
 library, which seems to be the need of all the others saying "do this
 and I'll switch from C++"? Are the tools good enough?
Considered how many games (and I don't mean indie anymore, but for example Blizzard's Heartstone) are now created in Unity which uses not only GC but runs in Mono I am very skeptical of anybody claiming GC is a no-go for games.
The whole "Unity3D == Mono" thing is a somewhat inaccurate misconception. Unity3D's engine (ie, the real workhorse of any Unity3D game) is written in plain old native C++. So not *necessarily* GC (though they might still use one internally, I wouldn't know). Only the game-specific scripts (and I *think* the Unity3D Editor) actually run on Mono. And even then, the game scripts *are* able to call into C-linkage stuff, which *is* occasionally done to work around performance issues within game scripts. Also, I imagine Mono's GC is probably quite a bit better than D's currently is.
Oct 14 2014
next sibling parent "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 14 October 2014 at 20:41:25 UTC, Nick Sabalausky 
wrote:
 On 09/30/2014 04:48 AM, Szymon Gatner wrote:
 On Monday, 29 September 2014 at 20:15:06 UTC, bachmeier wrote:
 On Monday, 29 September 2014 at 10:00:27 UTC, Szymon Gatner 
 wrote:


 Is that all it would take? Do you also need a GC-free standard
 library, which seems to be the need of all the others saying 
 "do this
 and I'll switch from C++"? Are the tools good enough?
Considered how many games (and I don't mean indie anymore, but for example Blizzard's Heartstone) are now created in Unity which uses not only GC but runs in Mono I am very skeptical of anybody claiming GC is a no-go for games.
The whole "Unity3D == Mono" thing is a somewhat inaccurate misconception. Unity3D's engine (ie, the real workhorse of any Unity3D game) is written in plain old native C++. So not *necessarily* GC (though they might still use one internally, I wouldn't know). Only the game-specific scripts (and I *think* the Unity3D Editor) actually run on Mono. And even then, the game scripts *are* able to call into C-linkage stuff, which *is* occasionally done to work around performance issues within game scripts. Also, I imagine Mono's GC is probably quite a bit better than D's currently is.
All good points. Still, my point was that GC does not mean language is automatically excluded from gamedev.
Oct 14 2014
prev sibling parent "Paulo Pinto" <pjmlp progtools.org> writes:
On Tuesday, 14 October 2014 at 20:41:25 UTC, Nick Sabalausky 
wrote:
 On 09/30/2014 04:48 AM, Szymon Gatner wrote:
 On Monday, 29 September 2014 at 20:15:06 UTC, bachmeier wrote:
 On Monday, 29 September 2014 at 10:00:27 UTC, Szymon Gatner 
 wrote:


 Is that all it would take? Do you also need a GC-free standard
 library, which seems to be the need of all the others saying 
 "do this
 and I'll switch from C++"? Are the tools good enough?
Considered how many games (and I don't mean indie anymore, but for example Blizzard's Heartstone) are now created in Unity which uses not only GC but runs in Mono I am very skeptical of anybody claiming GC is a no-go for games.
The whole "Unity3D == Mono" thing is a somewhat inaccurate misconception. Unity3D's engine (ie, the real workhorse of any Unity3D game) is written in plain old native C++. So not *necessarily* GC (though they might still use one internally, I wouldn't know). Only the game-specific scripts (and I *think* the Unity3D Editor) actually run on Mono. And even then, the game scripts *are* able to call into C-linkage stuff, which *is* occasionally done to work around performance issues within game scripts. Also, I imagine Mono's GC is probably quite a bit better than D's currently is.
Yeah, but on the other hand there are quite a few small studios living off Air, LibGDX/jMonkeyEngine and XNA/MonoGame. Which is an area where D could also appeal to indies. One needs to start somewhere. -- Paulo
Oct 15 2014
prev sibling parent reply Walter Bright <newshound2 digitalmars.com> writes:
On 9/29/2014 3:00 AM, Szymon Gatner wrote:
 Hi,

 recently there is much talk about extending C++ interop in D but it is unclear
 to me what that means. Functions and virtual class methods are already
callable.
 What else is planned in the near future? Exceptions? Support for C++ templates?
 (that seems difficult no?).
Currently, D supports C++: * function calling * name mangling * namespaces * templates * member functions * single inheritance * basic types that exist in C++ but not D (like 'long') Note that there are no plans to support C++ semantics - the D side will support only D semantic rules. SFINAE, Koenig lookup, etc., have no place in D. C++ interop will require the user to be flexible on both the C++ and D side, and bluntly will require strong knowledge of D and C++ and how they work under the hood to be successful with it. Probably the most tricky thing we're working on is interop with C++ exceptions. Essentially, we're going to see how far we can push interop.
Oct 14 2014
next sibling parent reply "Meta" <jared771 gmail.com> writes:
On Tuesday, 14 October 2014 at 22:27:35 UTC, Walter Bright wrote:
 Currently, D supports C++:

 * function calling
 * name mangling
 * namespaces
 * templates
 * member functions
 * single inheritance
 * basic types that exist in C++ but not D (like 'long')

 Note that there are no plans to support C++ semantics - the D 
 side will support only D semantic rules. SFINAE, Koenig lookup, 
 etc., have no place in D.

 C++ interop will require the user to be flexible on both the 
 C++ and D side, and bluntly will require strong knowledge of D 
 and C++ and how they work under the hood to be successful with 
 it.

 Probably the most tricky thing we're working on is interop with 
 C++ exceptions.

 Essentially, we're going to see how far we can push interop.
To clarify, templates have to be instantiated on the C++ side before being passed to D, right? Is it correct that D can't instantiate a C++ template?
Oct 14 2014
parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
On 10/14/14, 3:53 PM, Meta wrote:
 On Tuesday, 14 October 2014 at 22:27:35 UTC, Walter Bright wrote:
 Currently, D supports C++:

 * function calling
 * name mangling
 * namespaces
 * templates
 * member functions
 * single inheritance
 * basic types that exist in C++ but not D (like 'long')

 Note that there are no plans to support C++ semantics - the D side
 will support only D semantic rules. SFINAE, Koenig lookup, etc., have
 no place in D.

 C++ interop will require the user to be flexible on both the C++ and D
 side, and bluntly will require strong knowledge of D and C++ and how
 they work under the hood to be successful with it.

 Probably the most tricky thing we're working on is interop with C++
 exceptions.

 Essentially, we're going to see how far we can push interop.
To clarify, templates have to be instantiated on the C++ side before being passed to D, right? Is it correct that D can't instantiate a C++ template?
Correct. Here's the syntax on the C++ side: http://en.wikipedia.org/wiki/C++11#Extern_template -- Andrei
Oct 14 2014
next sibling parent "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 14 October 2014 at 23:01:49 UTC, Andrei Alexandrescu 
wrote:
 On 10/14/14, 3:53 PM, Meta wrote:
 On Tuesday, 14 October 2014 at 22:27:35 UTC, Walter Bright 
 wrote:
 Currently, D supports C++:

 * function calling
 * name mangling
 * namespaces
 * templates
 * member functions
 * single inheritance
 * basic types that exist in C++ but not D (like 'long')

 Note that there are no plans to support C++ semantics - the D 
 side
 will support only D semantic rules. SFINAE, Koenig lookup, 
 etc., have
 no place in D.

 C++ interop will require the user to be flexible on both the 
 C++ and D
 side, and bluntly will require strong knowledge of D and C++ 
 and how
 they work under the hood to be successful with it.

 Probably the most tricky thing we're working on is interop 
 with C++
 exceptions.

 Essentially, we're going to see how far we can push interop.
To clarify, templates have to be instantiated on the C++ side before being passed to D, right? Is it correct that D can't instantiate a C++ template?
Correct. Here's the syntax on the C++ side: http://en.wikipedia.org/wiki/C++11#Extern_template -- Andrei
Understood, makes sense.
Oct 14 2014
prev sibling parent reply Jacob Carlborg <doob me.com> writes:
On 2014-10-15 01:01, Andrei Alexandrescu wrote:

 Correct. Here's the syntax on the C++ side:
 http://en.wikipedia.org/wiki/C++11#Extern_template -- Andrei
"extern template class std::vector<MyClass>; which tells the compiler NOT to instantiate the template in this translation unit." That sounds like the complete opposite of what's needed. -- /Jacob Carlborg
Oct 14 2014
next sibling parent reply "Daniel N" <ufo orbiting.us> writes:
On Wednesday, 15 October 2014 at 06:18:48 UTC, Jacob Carlborg 
wrote:
 On 2014-10-15 01:01, Andrei Alexandrescu wrote:

 Correct. Here's the syntax on the C++ side:
 http://en.wikipedia.org/wiki/C++11#Extern_template -- Andrei
"extern template class std::vector<MyClass>; which tells the compiler NOT to instantiate the template in this translation unit." That sounds like the complete opposite of what's needed.
"C++03 has this syntax to oblige the compiler to instantiate a template: template class std::vector<MyClass>;"
Oct 14 2014
parent reply "Ola Fosheim =?UTF-8?B?R3LDuHN0YWQi?= writes:
On Wednesday, 15 October 2014 at 06:29:40 UTC, Daniel N wrote:
 "C++03 has this syntax to oblige the compiler to instantiate a 
 template:

 template class std::vector<MyClass>;"
But how does D handle concepts which most likely will be in the C++14 standard? http://concepts.axiomatics.org/~ans/
Oct 15 2014
parent reply Paulo Pinto <pjmlp progtools.org> writes:
Am 15.10.2014 um 09:18 schrieb "Ola Fosheim =?UTF-8?B?R3LDuHN0YWQi?= 
<ola.fosheim.grostad+dlang gmail.com>":
 On Wednesday, 15 October 2014 at 06:29:40 UTC, Daniel N wrote:
 "C++03 has this syntax to oblige the compiler to instantiate a template:

 template class std::vector<MyClass>;"
But how does D handle concepts which most likely will be in the C++14 standard? http://concepts.axiomatics.org/~ans/
I imagine you meant C++17. C++14 is already ratified. -- Paulo
Oct 15 2014
parent reply "Ola Fosheim =?UTF-8?B?R3LDuHN0YWQi?= writes:
On Wednesday, 15 October 2014 at 17:38:46 UTC, Paulo Pinto wrote:
 I imagine you meant C++17. C++14 is already ratified.
Yes, sorry, I meant that it is close enough for consideration as a draft. So discussing the effects of it on D's C++ support is now possible?
Oct 15 2014
parent reply "Daniel N" <ufo orbiting.us> writes:
On Wednesday, 15 October 2014 at 18:06:18 UTC, Ola Fosheim 
Grøstad wrote:
 On Wednesday, 15 October 2014 at 17:38:46 UTC, Paulo Pinto 
 wrote:
 I imagine you meant C++17. C++14 is already ratified.
Yes, sorry, I meant that it is close enough for consideration as a draft. So discussing the effects of it on D's C++ support is now possible?
There's no impact, we already support it since the template is instantiated from C++ side.
Oct 15 2014
parent reply "Ola Fosheim =?UTF-8?B?R3LDuHN0YWQi?= writes:
On Thursday, 16 October 2014 at 03:53:53 UTC, Daniel N wrote:
 There's no impact, we already support it since the template is 
 instantiated from C++ side.
But you don't know the return type of the templated function until you know which combination of templates it instantiated?
Oct 15 2014
parent reply "Daniel N" <ufo orbiting.us> writes:
On Thursday, 16 October 2014 at 05:45:00 UTC, Ola Fosheim Grøstad 
wrote:
 On Thursday, 16 October 2014 at 03:53:53 UTC, Daniel N wrote:
 There's no impact, we already support it since the template is 
 instantiated from C++ side.
But you don't know the return type of the templated function until you know which combination of templates it instantiated?
Yes, but this is true already today for enable_if? template<typename T> std::enable_if_t<std::is_same<T, int>::value, float> fun(const T& f) { return f; } template<typename T> std::enable_if_t<std::is_same<T, float>::value, int> fun(const T& f) { return f; } // Explicit Template Instantiation template float fun(const int&); template int fun(const float&);
Oct 17 2014
parent "Ola Fosheim =?UTF-8?B?R3LDuHN0YWQi?= writes:
On Friday, 17 October 2014 at 09:39:27 UTC, Daniel N wrote:
 On Thursday, 16 October 2014 at 05:45:00 UTC, Ola Fosheim 
 Grøstad wrote:
 But you don't know the return type of the templated function 
 until you know which combination of templates it instantiated?
Yes, but this is true already today for enable_if?
That sounds right, but I think the combination of auto + concepts will make it easy to do and it might turn into a common paradigm… Composing the most efficient return object based on some constraints generally sounds like a good idea when people get used to using auto for capturing return types. After having watched some of the cppcon videos I am getting the impression that C++ will be more and more difficult to interface with without building "clang" into the compiler.
Oct 17 2014
prev sibling parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
On 10/14/14, 11:18 PM, Jacob Carlborg wrote:
 On 2014-10-15 01:01, Andrei Alexandrescu wrote:

 Correct. Here's the syntax on the C++ side:
 http://en.wikipedia.org/wiki/C++11#Extern_template -- Andrei
"extern template class std::vector<MyClass>; which tells the compiler NOT to instantiate the template in this translation unit." That sounds like the complete opposite of what's needed.
C++11 includes C++03. -- Andrei
Oct 15 2014
parent Jacob Carlborg <doob me.com> writes:
On 2014-10-15 19:31, Andrei Alexandrescu wrote:

 C++11 includes C++03. -- Andrei
I kind of only read the C++11 part. -- /Jacob Carlborg
Oct 15 2014
prev sibling next sibling parent reply "Szymon Gatner" <noemail gmail.com> writes:
On Tuesday, 14 October 2014 at 22:27:35 UTC, Walter Bright wrote:
 On 9/29/2014 3:00 AM, Szymon Gatner wrote:
 Hi,

 recently there is much talk about extending C++ interop in D 
 but it is unclear
 to me what that means. Functions and virtual class methods are 
 already callable.
 What else is planned in the near future? Exceptions? Support 
 for C++ templates?
 (that seems difficult no?).
Currently, D supports C++: * function calling * name mangling * namespaces * templates * member functions * single inheritance * basic types that exist in C++ but not D (like 'long')
I do understand current situation tho I admit I am not aware of the "single inheritance". Does it mean that one can derive in D from a C++ class (don't see it in the docs)?
 Essentially, we're going to see how far we can push interop.
I suppose that is the answer I was looking for, time will tell yes? :)
Oct 14 2014
parent Walter Bright <newshound2 digitalmars.com> writes:
On 10/14/2014 5:40 PM, Szymon Gatner wrote:
 I do understand current situation tho I admit I am not aware of the "single
 inheritance". Does it mean that one can derive in D from a C++ class (don't see
 it in the docs)?
It's part of D's COM support.
Oct 14 2014
prev sibling parent reply "Wyatt" <wyatt.epp gmail.com> writes:
On Tuesday, 14 October 2014 at 22:27:35 UTC, Walter Bright wrote:
 Currently, D supports C++:

 * function calling
 * name mangling
 * namespaces
 * templates
 * member functions
 * single inheritance
 * basic types that exist in C++ but not D (like 'long')
I get the sense that http://dlang.org/cpp_interface needs some updates then? At the very least, it mentions "...it is very unlikely that any sort of reasonable method could be found to express C++ templates in a link-compatible way with D." Or am I misunderstanding what you mean with that bullet point? -Wyatt
Oct 15 2014
parent "Daniel Murphy" <yebbliesnospam gmail.com> writes:
"Wyatt"  wrote in message news:vhwivrusiysydgkxrjqw forum.dlang.org... 

 I get the sense that http://dlang.org/cpp_interface needs some 
 updates then?  At the very least, it mentions "...it is very 
 unlikely that any sort of reasonable method could be found to 
 express C++ templates in a link-compatible way with D."
 
 Or am I misunderstanding what you mean with that bullet point?
That page is many years out of date.
Oct 15 2014