Continuation of `Having "blessed" 3rd party libraries may make D more popular` DIP thread

[WraithGlade]

On Thursday, 3 July 2025 at 03:06:53 UTC, monkyyy wrote:
> [...]
>
> Dead code isnt *that* bad, it just means its your problem to 
> fix bugs or more likely ignore the docs and test it like a 
> black box, but its not going anywhere, you could even keep 
> local copies.
>
> [...]
>
> I has 70 repos
>
> [...]

That's a good point and a healthy reminder to my mindset. Thanks!

After all, it's not like the text of code itself decays even if 
it becomes inoperable. In the worst case, code from one language 
or library can be rewritten in another language or library, etc.

Similarly, I have ~50 project folders on my computer, most of 
which are stubs with design ideas and partial assets and partial 
codebases, so I really feel for you. We are kindred spirits 
regarding starting and stopping projects then. I have had some 
great ideas over the years, including even some that I had ideas 
to make for years before someone else made great income on them, 
but have historically switched around on projects too much to get 
real outcomes done. It is embarrassing for me, and has been the 
greatest struggle of my life, my #1 internal mental nemesis, but 
I'm working to change and intend to embody that change no matter 
what.

Tangentially, I seldom publish anything on GitHub because (1) I 
don't know what I'll make into a product later on potentially and 
thus can't afford to be too open yet unfortunately and (2) 
Microsoft trains AI on GitHub now from what I understand and so 
there's now great IP risk in exposing any important code to 
GitHub. I can't afford to have my work stolen. If I was 
independently wealthy though then I'd probably open up basically 
everything though.


On Thursday, 3 July 2025 at 15:57:11 UTC, Dennis wrote:
> [...]
>
> Don't worry, this is a normal, maybe even necessary part of a 
> programmer's journey. There's a talk I can recommend in its 
> entirety, but the most relevant part starts at 11:07:
> https://www.youtube.com/watch?v=89bLKVvF85M&t=667s
>
> [...]
>
>> I wish I could turn back the clock to when working in any 
>> programming language or system was pure joy and wonder and not 
>> just some amorphous sense of looming liability and risk, but 
>> here I am anyway, wishing for years that I could break that 
>> cycle of stagnation.
>
> Relatable as well. I used to just write code willy nilly, now 
> I'm constantly pondering like: https://xkcd.com/1445/
>
> [...]
>
> You've already said this to yourself and I doubt me saying it 
> is making a difference, but I don't know what else to say. 🙂
>
> [...]
>
> There's indeed a risk factor when using a more niche language 
> like D instead of a more mainstream language. But a lot of your 
> software robustness comes from how you choose to write it. If 
> your code is full of `mixin` / `__traits` etc., then you are 
> highly dependent on the D compiler and its development. But 
> simple code like `if (x > 0) x -= 2;` has been stable across 
> decades in multiple languages.
>
> [...]
>
>> Anyway, I hope the best for everyone for our future, myself 
>> included.
>
> The same, good luck!

I watched the entire video you linked to and enjoyed it quite a 
lot. Thank you for that!

Likewise, the XKCD meme link is extremely relatable and relevant 
to me. I would go so far as to even say that the meme is like "my 
life in a nutshell" in a sense, heh.

And, actually, your words have helped me feel better, genuinely, 
so I wouldn't say it is/was futile at all! I have indeed said 
loosely *similar* things to myself in a sense, but the aspect of 
the experience being a part of a programmer's normal development 
and  the reminder that many others have gone through it is 
heartening. It lightens the weight of the sense of lost time and 
guilt at least some, which helps me feel less crushed by it.

Also, the insight that most of the code is interchangeable 
(besides the most uncommon features) seems also like a wise 
reminder. Sometimes I get stuck in a mindset of thinking of code 
and assets in more heavy and petrified terms than I really 
should. Software is not the Pyramids or the Parthenon, and some 
level of malleability and transience has to be accepted, etc.

I wish you luck as well and thank you for your efforts here!


On Thursday, 3 July 2025 at 17:50:36 UTC, Mike Shah wrote:
> [...]
>
> I forgot to mention in the other thread that perhaps an 
> actionable thing would be to again check this page out or 
> perhaps update it in regards to new libraries: 
> https://wiki.dlang.org/Libraries_and_Frameworks
>
> I think the greater discussion is to your bottom point however, 
> about worrying about investing a lot of time/energy/code to D.
>
>> I want what I make to last.
>
> The D compiler being open source, and having the LDC and GCC 
> backends means D is here to stay. Learning D and spending time 
> with the language will not go to waste . An exercise metaphor 
> might be that of 'cross-training' -- spending time biking will 
> help you with running and vice versa. But I think with 
> programming it's even more direct a benefit. I have some talk 
> about this with D and C++ here as some proof 
> (https://www.youtube.com/watch?v=CnKsOak0DHU&t=1s).
>
> [...]
>
> Whenever I'm in a  position to hire and I see someone has 
> ventured outside of standard languages taught in school, that's 
> a big indicator that person really cares about 
> exploring/expanding their craft
> 
> [...]
>
> Another random note: Try to give yourself some small projects. 
> e.g. Build a raytracer in a day (sounds like you have some 
> game/graphics experience), build a small game, set a clock for 
> 1-hour and write a tutorial for some topic, etc.  These small 
> little projects add up to big wins and motivation over time :) 
> Good luck!

The link to the list of libraries is a helpful supplement to the 
Awesome D list previously linked to in the thread, so I 
appreciate the additional resource. I think I random saw it once 
before, but it is good to be reminded of it.

I watched your whole video talk on D (on 1.75 speed for parts 
I've already learned about, which was most of it) and found it a 
good quality feature overview and comparison to C++.

Diversification of programming language knowledge certainly has 
upsides and has broadened my perspective quite a bit and your 
reminder that at least some people in hiring positions view it 
positively (though job board postings seem to almost always do 
the opposite) is helpful.

I do think I've gone much too far into that extreme of language 
dilettante-ism though in terms of time management, since I 
basically don't have real projects to show for it, seeing as 
tutorials and random messing around doesn't really rise to the 
level of presentability.

The advice to focus on smaller projects or smaller pieces of 
things is another prudent reminder that I appreciated. The fact 
that I've got so little tangible software from so many years of 
messing around is one of the biggest weights on my mind and 
having more actual completed software would help me not feel as 
stuck. Cumulative wins could help a lot to free me from the sense 
of "learned helplessness" that has blighted my programming life 
these past several years.


On Friday, 4 July 2025 at 07:54:43 UTC, Steve wrote:
> @WraithGlade
> You seem to be suffering from analysis paralysis.
>
> [...]

Yep, definitely a fair label at this point!

Being flustered and stuck in my endeavors has really been a huge 
struggle for me. It's my #1 problem pretty much. I intend to 
change though and here's to hoping I pass the critical threshold 
soon and get a lot more done in the future.


On Friday, 4 July 2025 at 15:11:25 UTC, GrimMaple wrote:
> [...]
>
> This is how I initially ended up with D myself, trying to 
> figure out a better way to write software than C++.
> 
> [...]
>
> Having done that, I would tell you straight away: no. If you 
> want to start building Real™
> Software in D, you'll most likely end up absolutely __having__ 
> to contribute to multiple
> 3rd party project, or building a significant part of low-level 
> libraries yourself. For me,
> it was adopting dlangui (I still keep maintenance of it, if you 
> file a PR I'll be more than glad to accept it). It also 
> inevitably forced me and Adam to create OpenD, because
> upstream D had very little care to anything non-compiler 
> related.
>
> [...]
>
> Since a few releases back, C# is able to compile to __native 
> code__. Yes, it can compile to native code, without tucking 
> behind a .NET library or JIT. So if you want a 
> natively-compiled language with GC (which is why I personally 
> selected D), you can now use C#. The world has gone so mad that 
> you can actually __link-in C libraries__ to your natively built 
> C# application.
>
> [...]
>
>> I have squandered practically the entire past decade just 
>> running in circles switching between different programming 
>> languages and reading countless programming language tutorials 
>> and books and messing around in them in aimless ways and 
>> basically hardly creating anything real or substantive. That's 
>> not the life I wanted for myself, nor is it even a responsible 
>> way of living for me at this point given how much time I've 
>> lost doing that.
>
> I don't think you should be going too hard on yourself for 
> this. Yours truly done this too, and nowadays can use 5 or 6 
> programming languages reasonably well. It accumulates general 
> experience, general knowledge, and fixes your brain from 
> thinking in one language's paradigm.
>
> [...]

Thank you for the warning about the potential to have to lay down 
a lot of groundwork on libraries. It's good to hear from 
someone's direct perspective and experience with such things.

I had no idea that C# could compile to native code now. That's 
good for them and for Unity and Godot developers no doubt. C# is 
at least better than Java, though still moderately stilted for my 
own preferences in languages. The Microsoft connection is not 
great, especially considering they have embraced the AI-powered 
plagiarism trends (among other things) and hence are increasingly 
untrustworthy. However, it is a pragmatic option to consider at 
least, though I'd probably pick something else if I switch again 
(such as Lua + Love2d, or Rust + Macroquad, or Nim + Raylib, or 
whatever else).

There is also of course the option of C++, but I have become 
tired of the mess of it and even more so of C++'s build ecosystem 
(CMake, etc). It does at least have a huge range of mature 
libraries and engines though (the most dominant game dev language 
by far, even now).

Thank you for reassuring me to not be so hard on myself! It is 
heartening to hear from other programmers who have experienced 
these kinds of struggles.

I am committed to making this change in my life and living a 
healthier balance in my mentality as a programmer. Both my 
responsibilities and my lifelong creative intentions depend upon 
it, so I've got to get unstuck in my head and start living more 
again.

--------

Anyway though, I'm going to take the rest of the day off on these 
matters and give myself permission to relax some. I spend most 
days so tightly wound up about "must be productive" while 
ironically not being so and hardly ever let myself take it easy. 
I've barely even played games these past several years (maybe <50 
hours per entire year on average) because I don't give myself 
permission to, because I feel guilty about my stagnation, but I 
need to stop being so uptight, both regarding programming and 
living life, I suppose.

Most importantly of all though: I am wishing you all a Happy 4th 
of July (American Independence Day)!