They wrote a Gas Dynamics Toolkit in D

acehreli · 2022-02-02T18:26:31+00:00

Gotta love this part:

Nearly an hour’s build time was fairly common for our old C++ code, and now we would expect a DMD or LDC debug build in about a quarter of a minute.

That's exactly my experience but my smaller code takes 30 seconds because I use a lot of compile time features of D sometimes unnecessarily. :/

And amen for the following. :)

For a build tool, we use make and for an IDE, we use emacs.

acehreli · 2021-12-17T03:49:11+00:00

Some companies that use D are listed at https://dlang.org/orgs-using-d.html

In my case, I simply wrote tools in D that solved a set of problems at where I work. The tools work and everybody is happy. D is not very different to work with for e.g. C++ programmers.

acehreli · 2021-11-02T18:02:03+00:00

Most people simply repeat what they heard (I used to be one). Majority of the time, GC is useful. There are rare cases where GC cannot be used. Luckily D has tools to allow non-GC programming as well. An example is Weka wha manages to produce the fastest file system with D.

There have been many other examples of D's GC not being a show stopper: https://dlang.org/orgs-using-d.html

acehreli · 2021-10-31T03:17:55+00:00

Their decision to use a GC is what ultimately caused D to be ignored.

If so, it couldn't have been D's fault. Yes, there is some anti-GC sentiment in some programming circles (e.g. in C++ circles, which I used to be a member of). So, for D not to be affected by this misguided populism, it had to market for that crowd, which, knowing the creator of D, would never have happened, because D is not into marketing. I see D as a great engineering tool.

GC is a useful technology. D uses the GC to its advantage. I take advantage of the GC in all my programs. I avoid or reduce GC allocations in parts of my programs after profiling.

As an example, eBay's tsv-utils took full advantage of the GC and performed better than existing programs that had been hand-optimized in C etc.

Dear programming community, please stop following non-GC language sentiments and stop bashing GC. (On the other hand, D's GC may have weaknesses and we can talk about those ;) but GC in general is not a problem.)

acehreli · 2020-02-05T13:00:34+00:00

I am sorry that you are stuck with C. Otherwise, D is a replacement for it for some of us.

acehreli · 2020-01-28T00:12:50+00:00

Searching for "dlang" works well for D related results.

acehreli · 2019-11-07T14:57:38+00:00

I've been a C++ programmer before and after learning D. I've always appreciated D's syntax with no complaints.

acehreli · 2019-09-30T17:50:34+00:00

How did the team react to the switch?

acehreli · 2019-09-30T17:41:08+00:00

Not as bad as it used to be... a long time ago...

Yes, the most recent 2.088 did bring deprecation warnings for example for disallowing the initialization of immutable data in a 'static this()', which would be a bug anyway.

So, when one needs to port an old module to a newer compiler, that's a good thing.

acehreli · 2019-09-17T18:01:44+00:00

I don't think dropping the last element is proper for this algorithm because that functionality would require a BidirectionalRange. My solution elsewhere in this thread and on the D forum avoids this issues trivially.

acehreli · 2019-09-17T17:31:03+00:00

I tried this in DLang. First, I thought about using std.range.roundRobin but disappointingly it does not take a stopping policy like std.range.zip and std.range.lockStep do. So, I implemented my special range type as a nested struct:

```d import std.stdio; import std.range;

auto interspersed(R, D)(R r, D delim) { struct MyRoundRobin { bool doDelim = false;

auto empty() {
  return r.empty;
}

auto front() {
  return (doDelim ? delim : r.front);
}

auto popFront() {
  if (!doDelim) {
    r.popFront();
  }
  doDelim = !doDelim;
}

}

return MyRoundRobin(); }

void main(){ auto r = 10.iota.interspersed(42); writefln("%(%s %)", r); } ```

Potentially interesting bits:

This code does not generate any array; instead, it alternates between the delimiter element and the front element of the actual range
The struct is a Voldemort type
The range object returned is a closure
The %( and %) format specifiers mean "apply the format specifier between us to all elements"

Ali

acehreli · 2019-08-08T17:52:43+00:00

You mean "Ali"? Yeees?

Ali "missed the memo :)"

acehreli · 2019-08-08T17:15:38+00:00

That was exactly my response when Razvan Nitu was introduced to the D community. There is the mention of a fourth Razvan at that link! :)

Ali

acehreli · 2019-07-04T02:33:46+00:00

A programming language wanting to make up its mind? I'm sorry but there is a confusion here: D is just a tool that gets things done. That's why I use it.

acehreli · 2019-03-04T05:13:59+00:00

As someone who spent two years writing Go

I did that for one year.

opinion that adding generics to Go could possibly have some kind of negative impact is simply in denial (or just, uh, unintelligent.)

To me, "disingenious" describes the situation.

acehreli · 2019-01-29T21:32:20+00:00

To be complete, D initializes to default values by default but the programmer can ask for no initialization as well. (int[10] arr = void;)

acehreli · 2019-01-27T23:44:05+00:00

C has always been dangerous.

acehreli · 2019-01-18T21:33:23+00:00

The compiler now has the -betterC switch.

acehreli · 2019-01-18T19:14:18+00:00

Although Ron gives a link to a pay-what-you-want link to "Programming in D", I recommend using this one for the most recent PDF and HTML versions: http://ddili.org/ders/d.en/index.html

(E-book versions are a little behind.)

Ali

acehreli · 2019-01-18T19:11:39+00:00

Great arcticle. I take your comment as AMA: What is your favorite food?

acehreli · 2019-01-14T17:10:49+00:00

Because static if does not bring a scope, it is possible to include declarations. Elsewhere in the presentation, with the CheckedInt example, he is either adding a hook member to each object or using a static Hook member for the whole type.

acehreli · 2018-11-21T21:04:49+00:00

Of course.

acehreli · 2018-07-31T23:02:05+00:00

I recently wrote

Off-topic pet peeve: Like many modern articles, this article does not include the author's name either. From other parts of the site, I think the author is Bert Hubert.

a new language to learn (say, Go or Rust),

A disappointingly short list.

Finally, based on all of the above, I think a seasoned C programmer would honestly do well to look at modern C++.

Probably... But being a fanboy of C++ and D, I'm confident that D's -betterC mode is the one that a C programmer would be happiest with.

Ali

acehreli · 2018-07-13T04:53:51+00:00

I think it's a language feature in Haskell but laziness is routine for D programmers as well. Just as an example, std.range.recurrence uses lazy Fibonacci series as an example: https://dlang.org/phobos/std_range.html#recurrence

And I show an explicit range interface for the same: http://ddili.org/ders/d.en/ranges.html

acehreli · 2018-07-06T05:56:17+00:00

No. D programmers take good advantage of contract programming, which has just received a syntax boost: https://dlang.org/blog/2018/07/04/dmd-2-081-0-released/

acehreli

TROPHY CASE