On Tuesday, 28 November 2017 at 03:01:33 UTC, A Guy With an
Opinion wrote:
+ D code so far is pushing me towards more "flat" code (for a
lack of a better way to phrase it) and so far that has helped
tremendously when it comes to readability. C# kind is the
opposite. With it's namespace -> class -> method coupled with
lock, using, etc...you tend to do a lot of nesting. You are
generally 3 '{' in before any true logic even begins. Then
couple that with try/catch, IDisposable/using, locking, and
then if/else, it can get quite chaotic very easily. So right
away, I saw my C# code actually appear more readable when I
translated it and I think it has to do with the flatness. I'm
not sure if that opinion will hold when I delve into 'static
if' a little more, but so far my uses of it haven't really
dampened that opinion.
I come from a heavy C#/C++ background. I also I *felt* this as
well, but never really consciously though about it, until you
mentioned it :-)
- Some of the errors from DMD are a little strange. I don't
want to crap on this too much, because for the most part it's
fine. However occasionally it throws errors I still can't
really work out why THAT is the error it gave me. Some of you
may have saw my question in the "Learn" forum about not knowing
to use static in an embedded class, but the error was the
following:
Error: 'this' is only defined in non-static member functions
Please submit things like this to the issue tracker. They are
very easy to fix, and if I'm aware of them, I'll probably do the
work. But, please provide a code example and offer a suggestion
of what you would prefer it to say; it just makes things easier.
- Modules. I like modules better than #include, but I don't
like them better than C#'s namespaces. Specifically I don't
like how there is this gravity that kind of pulls me to
associate a module with a file. It appears you don't have to,
because I can do the package thing, but whenever I try to do
things outside that one idiom I end up in a soup of errors. I'm
sure I'm just not use to it, but so far it's been a little
dissatisfying. Sometimes I want where it is physically on my
file system to be different from how I include it in other
source files. To me, C#'s namespaces are really the standard to
beat or meet.
I feel the same. I don't like that modules are tied to files; it
seems like such an arbitrary limitation. We're not alone:
https://youtu.be/6_xdfSVRrKo?t=353
- Attributes. I had another post in the Learn forum about
attributes which was unfortunate. At first I was excited
because it seems like on the surface it would help me write
better code, but it gets a little tedious and tiresome to have
to remember to decorate code with them. It seems like most of
them should have been the defaults. I would have preferred if
the compiler helped me and reminded me. I asked if there was a
way to enforce them globally, which I guess there is, but I
guess there's also not a way to turn some of them off
afterwards. A bit unfortunate. But at least I can see some
solutions to this.
Yep. One of my pet peeves in D.
- The defaults for primitives seem off. They seem to encourage
errors. I don't think that is the best design decision even if
it encourages the errors to be caught as quickly as possible. I
think the better decision would be to not have the errors
occur. When I asked about this, there seemed to be a
disassociation between the spec and the implementation. The
spec says a declaration should error if not explicitly set, but
the implementation just initializes them to something that is
likely to error. Like NaN for floats which I would have thought
would have been 0 based on prior experiences with other
languages.
Another one of my pet peeves in D. Though this post
(http://forum.dlang.org/post/tcldaatzzbhjoamnv...@forum.dlang.org) made me realize we might be able to do something about that.
+- Unicode support is good. Although I think D's string type
should have probably been utf16 by default. Especially
considering the utf module states:
"UTF character support is restricted to '\u0000' <= character
<= '\U0010FFFF'."
See http://utf8everywhere.org/
+ Templates seem powerful. I've only fiddled thus far, but I
don't think I've quite comprehended their usefulness yet. It
will probably take me some time to figure out how to wield them
effectively. One thing I accidentally stumbled upon that I
liked was that I could simulate inheritance in structs with
them, by using the mixin keyword. That was cool, and I'm not
even sure if that is what they were really meant to enable.
Templates, CTFE, and mixins are gravy! and D's the only language
I know of that has this symbiotic feature set.
So those are just some of my thoughts. Tell me why I'm wrong :P
I share much of your perspective. Thanks for the interesting
read.
Mike
