
D on embedded Linux (ARM) - pjmlp
https://fkromer.gitbooks.io/d-on-embedded-linux-arm/content/
======
jordigh
It's always exciting for me to see more D usage. What's nice is that it has
both gcc and llvm frontends, with all the optimisations and target
architectures that those come with, such as the article's ARM.

I recently worked through Advent of Code in D to get a better feel for the
language, and I had a blast. It's a fun language with some very interesting
ideas.

[http://jordi.inversethought.com/blog/advent-
of-d/](http://jordi.inversethought.com/blog/advent-of-d/)

I particularly enjoyed concurrency during Day 18, which seemed to really stump
those who tried Advent of Code in other languages, whereas D made it very
easy.

[http://jordi.inversethought.com/blog/advent-
of-d/#day18](http://jordi.inversethought.com/blog/advent-of-d/#day18)

~~~
simias
I wonder if D could ever become mainstream at this point. Back when the
language first released as a C++ coder I was very interested in D but the
weird not-technically-open-source license and the garbage collector put me
off. Now they "fixed" the licensing and I suppose garbage collection is more
readily accepted in system programming but it doesn't have the hype and
novelty of Go or Rust. I don't know any program I use that's written in D for
instance while I do use a few Rust and Go programs daily. I can't shake the
feeling that D missed its chance at becoming mainstream.

~~~
pjmlp
It has been proven multiple times, at Xerox PARC, ETHZ, DEC Olivetti,
Microsoft that garbage collection systems programming languages are doable.

However technology adoption always needs to fight against non-believers.

Joe Duffy has stated on his Rustconf 2017 presentation [0] that even Midori
running on front for their eyes, with some use cases where System C# was even
shoulder-with-shoulder with C++ [1], that Windows devteam was not getting it.

Nowadays he is an happy Go coder instead of trying to convince them otherwise.

D has a big problem with their GC implementation, which provides good
arguments for the anti-GC crowd in systems programming.

However they have been improving it quite a bit during the latest releases, as
well as, making the runtime library more @nogc friendly.

As for reaching mainstream, I share your thoughts. It is not only Rust and Go.
There is also Swift, C++17 and the ongoing improvements to make Java and C#
more machine friendly (memory management and AOT compilation).

Still, even if just a small group gets to use it, it is already a victory.

Most languages never achieve it.

[0] -
[https://www.youtube.com/watch?v=CuD7SCqHB7k](https://www.youtube.com/watch?v=CuD7SCqHB7k)
[1] - [http://joeduffyblog.com/2015/12/19/safe-native-
code/](http://joeduffyblog.com/2015/12/19/safe-native-code/)

~~~
HumanDrivenDev
> It has been proven multiple times, at Xerox PARC, ETHZ, DEC Olivetti,
> Microsoft that garbage collection systems programming languages are doable.

It's my understanding that D's garbage collection isn't considered very
performant. I know it used to receive a lot of criticism.

~~~
pjmlp
Which I happen to address on my comment....

------
VHRanger
I really think D, like Go has a better chance of attracting programming
languages from higher, not lower level languages.

C++ can't event get the C greybeards to switch over while being a strict
superset. On the other hand, Go is being embraced as a python replacement in
the backend world

~~~
JoeAltmaier
pedant here: C++ is far from a strict superset of C, with many syntactic
changes over the years.

~~~
HumanDrivenDev
C++ is actually missing some of the nicer stuff from the last few ANSI-C
standards. Struct initializers especially.

~~~
pjmlp
That is what constructors are for.

In any case, they might make it into C++20.

[http://en.cppreference.com/w/cpp/language/aggregate_initiali...](http://en.cppreference.com/w/cpp/language/aggregate_initialization)

