How does D improve on C++17?

D with an Hotspot comparable GC quality would be quite good.

I thought using SIMD to accelerate it more on the integrator and acceleration calculation, inside of the parallel for.

Reuse rather than free and reallocate is a core practice whenever you feel the need for speed, regardless of the memory allocate strategy used.

For some very fast D code:

https://github.com/facebook/warp

Minimizing the amount of heap memory allocated is a core strategy.

I just discovered that the language authors are converting the std library (phobos) to be "no GC".

http://dlang.org/version.html

http://dlang.org/version.html

The salient point is that conditional compilation in D is not text based, it is AST based. Furthermore, for 'static if', the conditional expression has access to the full symbol table and power of the D language - it is not a separate preprocessor language with its own rules and separate symbol table.

http://dlang.org/version.html

The constructs are simply built into the language.

This has considerable benefits: you can use e.g. `static if` to enable/disable code based on conditions which refer to constants declared in the program (there is no longer a separate namespace for preprocessor defines and program constants), and with CTFE, you can use any expression that can be evaluated during compilation.

    version (Posix) {
      version(OSX) {
        // Weird stuff on OSX
      }
    // Sane stuff for Linux or FreeBSD
    }
    version (Windows) {
      // Weird stuff for Windows
    }

http://tech.adroll.com/blog/data/2014/11/17/d-is-for-data-sc...

[1]https://github.com/facebook/warp

Here's a bit of code from a personal shopping comparison program I wrote a few days ago, which combines some standard library constructs with my own libraries:

  string findProduct(string name)
  {
      return
          ("http://www.tp-link.com/en/search/?q=" ~ encodeComponent(name))
          .download
          .readText
          .toXML
          .xmlParse
          .I!(doc => zip(
              doc
              .findAll("#productResult > li > dl > dt > a")
              .map!(e => e.attributes["href"])
          ,    
              doc
              .findAll("#productResult > li > dl > dt > a")
              .map!(e => e.children[$-1].text.strip)
          ))
          .filter!(t => !icmp(t[1], name))
          .I!(r => r.empty ? null : "http://www.tp-link.com" ~ r.front[0])
      ;
  }

D fits lots of purposes (more than C++), but I'm only going to talk about scripting.

The minimalistic approach for the C++ standard library makes C++ inappropriate to replace, for example, Bash scripts. In C++, you can't do any operation on the file system (erase a directory, get file size, list files, create pipes, ..) in a portable way. You can't create processes in a portable way.

The D standard library (aka Phobos) doesn't suffer these limitations. Which means you can write very high-level code using only a few (readable) lines. By adding a shebang "#!/usr/bin/env rdmd" at the beginning of your D programs, you can execute them without prior explicit compilation, like: ./myProgram.d

I've been porting all my Bash scripts to D. The code runs incredibly faster, and now I can have structs again!

I really enjoy a lot more writing on D, but I keep finding the issue that I need to interface with C++ libs for something (for example Qt 5 for an emulator GUI) or weird errors like these problem with std.net.curl on Ubuntu 14.04 . If not was for that, I would wrote the Trillek virtual computer on D.

Anyone here unhappy with pip?

Package managers for development allow things such as installing multiple versions of a library, creating "sandboxes" with specific versions of libraries, and sometimes they are also the de-facto build system for a language.

The OS package manager isn't doing the same job and has very different requirements. Not all libraries (especially ones that are usually built statically or header-only) end up in an OS package manager. Typically OS package managers don't bundle any libraries that are not required by one or more of applications in the package repository.

So no, an OS package manager doesn't cut it for C or C++ development. They don't ship all the libraries and they can't do all the things you need for serious development.

As a C and C++ developer, this pisses me off constantly. Even though most libraries are easy enough to fetch these days with Git, there's no standard way of configuring, building and installing them. And no OS package manager has ever been able to provide all the libraries I need.

Lets you specify contracts which are asserted on construction and destruction, it's great.

The meta programming is also wonderful for things like serialization of data, simply iterating over a type's members at compile-time to generate serialization code, cutting out much bloated code. It's worth noting that it's metaprogramming for humans, _compared_ to c++, but sometimes leaves a bit to be desired documentation-wise, all the building blocks are there, but sometimes you'd like to not need to reinvent the wheel every time you attempt some metaprogramming-related task.

Things I don't enjoy include the core language's reliance on the GC, including things like exceptions relying on GC allocations.

Thankfully they've made it a bit easier to track down things which may allocate gc memory lately with accompanying flags to the compiler, which prints a trace of where it may happen.

Making games? :) I'm half joking here, Kenta Cho has made tons of shoot'em up games, mostly written in D (and released as Open Source) for years:

https://en.wikipedia.org/wiki/ABA_Games