Hi Folks,

My D language playlist on YouTube has just hit 100 episodes (including a guest lecture from Ali and two shorts) -- hurray! However, I think an 'official' 100th episode with some more production is in order (Currently we're on lesson #97).

I was hoping to center this lesson around some community feedback answering (any or all of the following):

1. What's your favorite feature of DLang?
2. Why did you choose the D programming language or what first drew you in?
3. One cool D Language trick/idiom you'd like to share.
4. Why you're excited about the future of DLang
5. A cool article/resource/favorite DConf talk/blog you'd like to share
6. A cool project you'd like to share (e-mail me images and short video clips if you like!)
7. Something else?

Feel free to chime in on one or all questions.

If you want me to show your forum handle or name in the video as part of the community for the submission please let me know (I'll assume anonymity otherwise even if you post here).

You can e-mail me at mikeshah@northeastern.edu otherwise if there's something you want to share. I'll plan on otherwise having video 100 done towards the end of the month.

The playlist otherwise: https://www.youtube.com/playlist?list=PLvv0ScY6vfd9Fso-3cB4CGnSlW0E4btJV (And good news, there's another 70-80 videos planned ... then there will probably be more 'project-based' or 'API-based' videos in separate playlists -- so plenty more to add over the years :) )

On Wednesday, 5 June 2024 at 14:37:41 UTC, Mike Shah wrote:

article that I think should go viral but just... hasnt for some reason, Im unsure if 30 poeple have even read it

https://crazymonkyyy.github.io/writings/gif.html

https://github.com/crazymonkyyy/raylib-2024/blob/master/docs/examplecode.md

my raylib wasm thing, should be plenty of videoable gifs

I think that imperative style templates are under explored and could probably write up some sane example "patterns" that while most poeple would hate them I think have valid use cases

On Wednesday, 5 June 2024 at 14:37:41 UTC, Mike Shah wrote:

package/module system, ufcs/chaining, dub, foreach, and good parts of std.* (range, algorithm, string, conv, studio). I love the overall syntax and syntactic sugar implemented in D ("..", 200_000, (){}, n.callUfcs(), etc).

I came to like D as a JavaScript developer because it was familiar, easy to write like JavaScript, and allowed me to have static types + go low level when I needed to (rare use case). Basically a single productive language to do it all. I didn't have to deal with pointers and unnecessarily complicated syntax (e.g. I could never live with the cout syntax in C++). Basically a better JavaScript. D's cleaver features was also a huge selling point.

Big fan of the package repository too.

I write regular obvious D code. Nothing fancy.

D is already complete for me. I'm looking forward to more cleaning up (language, std.v2), language stability and ecosystem improvements. More packages on dub too.

I'm not a fan of attribute salad... fun() const @safe @live @nothrow scope ... at least it shouldn't be the default. Allow the dev to choose the style without forcing it in their throat (a simple language by default). I don't dislike all attributes though (like in, out, ref, immutable, etc), just not a fan of it's overuse in D.

I used to write articles about D on OpenSource.com until RedHat shut it down. Many people did like D's design and wanted to know more. My D article were the top read and I even got some Merch :).

On Wednesday, 5 June 2024 at 14:37:41 UTC, Mike Shah wrote:

Probably just "alias" and symbol management in general.

I just read the D 1.0 specification, when looking for a C++ replacement, coming from a Pascal/Ocaml background C++ was such a downgrade I knew there was something better somewhere.

At first I was convinced by inline asm, NaN comparison operators, _ in number literals, relatively minor stuff in retrospect.

I don't have new ones.

In my view Dlang allows to be on the "Pareto front" between experimentation and production programs, with not too much type system getting in the way.

If C++ goal were to allow maximum control, Dlang corrects a bit this trajectory to make this power perhaps more available and productive.

The classic:
https://www.youtube.com/watch?v=LIb3L4vKZ7U

is a show off the what the STL style can do.

https://github.com/p0nce/turtle/tree/master/examples has 13 examples now, relatively easy to draw a 2D experiment

You can find cool projects looking at recently updated or created dub packages: https://code.dlang.org/?sort=updated

On Wednesday, 5 June 2024 at 14:37:41 UTC, Mike Shah wrote:

opDispatch. Such a cool feature. You can read a json using
the D syntax. You can implement optional access. You can
program many cool things with opDispatch.

With a Delphi background I was always a bit reluctant toward C or C++.
I considered Java like a bit too "professional-oriented" but also the fact that it was interpreted was a big no-no.

When I've discovered D it was like "yes it's the one with a C syntax"

use UDA and template meta-programing

I'm not excited. The great joys recently were about new operators, which will never be impelmented in D. However I appreciate how templates allow alternatives, i.e as a kind of generic solution.

Nothing here. I think that the Berlin Panel was over the top however.
Probably the venue played a role too. It was so cool. I remember Meyer's saying
"no disrecpect guys, but what your are doing will never work" (approximatively).

Yes, my hobby project was written in D, until boostrapped. See
https://gitlab.com/styx-lang/styx/-/tags/v0.1.0.

IA sucks. The earth is not a sphere, it's a potatoid.

C interoperability. That makes it easy to work not only with C code, but any other language that can be called from C.

I wanted a language that was statically typed, garbage collected, produced fast enough code, made it easy to work with C, was fun to use, and was production ready. I gave it a test and it did quite well.

Because it does everything I need and it'll still be around in 30 years.

There's nothing I want to do with respect to data analysis that can't be done conveniently and efficiently with D. Maybe there is, but I haven't found it. That includes things like connecting to a particular database, statistical analysis, plotting, deep learning, etc. Interoperability with other languages means I can call R, Python, Julia, C, and C++ libraries with little effort if there's no pure D version. The discussions around here might leave one with the impression that this is not the case. I started a repo/website explaining for others how I do this stuff. It's far from complete but I add to it when I have time.

https://bachmeil.github.io/betterr/
https://github.com/bachmeil/betterr

On Thursday, 6 June 2024 at 18:40:43 UTC, bachmeier wrote:

Thanks for all the feedback folks, I'll start compiling and try to put something together nice for the 100th episode!

On Wednesday, 5 June 2024 at 14:37:41 UTC, Mike Shah wrote:

I don’t use D professionally because I can’t, so I’m doing some toy stuff. I remember when I discovered D and it had so many obvious good designs. Having used Java, C# and C++ a lot (professional dev in those), I had a phase when I sent links to Ali Çehreli’s book to various people.

What makes D great are small and simple things like foreach. D’s foreach has zero clutter and is extremely flexible and efficient. It’s easy to use and easy to make types that work with it with two very different approaches for the vast span of possible applications, that is, the range interface and opApply. In many cases, I found D just offered all options in cases where some language did this and the other that, both of which are valid, and in D, you get to choose depending on your particular situation, where other languages just force annoying choices on you.

String mixins and CTFE are brutal. Almost anything you can think of is possible and reasonably simple.

I love the forum, maybe except for the Markdown post font (which I can just change using CSS). My only real objection to the forum is the Learn forum. That should be on a site like StackOverflow, so that D people can earn some StackOverflow reputation to their name doing what they love.

Walter is a great guy. He has some strong opinions like everyone else has, but he’s not stubborn or married to his ideas.

The no-warnings policy is fantastic. It makes the design more principled and one thing I hate about C++ is reading code that suppresses warnings for different compilers. Having a delineated UB-free (@safe) subset of the language is fantastic, and it’s undogmatic as you can step out of checks, but be reminded of it by having to use special syntax.

The DIPs I draft try to address holes in the language. At some point, I want to be able to sell D to my superior or coworkers in good conscience.

On Wednesday, 5 June 2024 at 14:37:41 UTC, Mike Shah wrote:

Extremely powerful metaprogramming/templating/introspection that is also syntactically clean and aesthetic (from the end user's perspective). "Modify code in only one place" philosophy so updating a basic data structure, when done right, does not require any additional changes to other areas of code such as parsers, readers, writers, enumerators, etc. UDAs and .tupleof make magic happen.

Was looking for a better, more modern language with a comfortable migration from the C lineage or syntactic philosophy that isn't the eternal disaster of C++. The choice at the time was D or Go, and I'm glad I picked D.

void toString(scope void delegate(const(char)[]) writer) {
	writer.formattedWrite("Just because you can allocate doesn't mean you need to.");
}

Adam's fork should hopefully encourage two parallel development paths to keep improving and (hopefully) learn from each other. I use D professionally and creatively, so I'm actually rather interested in new features that aid workflow, like the recent string interpolation, moreso than what interests the language specialists lately, like code freezes apparently. I like new toys and I feel confident I won't hurt myself on their sharp edges.

DConf '22: Structured Concurrency -- Sebastiaan Koppe
https://www.youtube.com/watch?v=hJhNhIeq29U

Loosely inspired by above, I rolled together a simple but flexible asynchronous RPC/proxy layer that makes use of the CRTP. The full version is not in a state I'd want to publish, but a slimmed down proof of concept looks like the below. Naturally this version operates synchronously, but one can imagine the full effect when function calls and their replies are serialized and transmitted across a network, etc. Javascript's sync stuff works similar to this AFAIK, but what's amazing IMO is just how little D needs to be written to achieve things like this, and it can be easily slapped on top of just about any existing class setup. Even the completed version I wrote with network dispatch clocks in at under a thousand lines.

Full: https://rentry.org/o628eptk

class Person : Proxyable!(Person, "name", "getPerson") {
               // Template args specifiy how the Proxy layer retrieves a
               // unique ID for an object, and contacts a remote object via ID
	static Person[string] allPeople;
	static auto getPerson(string s){
		if (auto p = s in allPeople)
			return *p;
		return null;
	}

	string name;
	Person friend;
	this(string str) {
		this.name = str;
		allPeople[name] = this;
	}

	@Proxy:
	Person getFriend() => friend;
	void bark() {
		writeln(i"My name is $(name).");
	}
	int doubleMyInt(int x) {
		return x * 2;
	}
}

void main() {
	{
		// Server-side stuff
		new Person("bob").friend = new Person("joe");
	}

	auto p = Proxy!Person("bob");

	p.doubleMyInt(4).then((n) {
		writefln("Doubled Result: %s", n);
	});

	p.bark();
	p.getFriend().then((f) {
		writeln("I'm the friend, and my name...");
		f.bark();
	});
}