Programming in D
ddili.org
ddili.org
I hear it's a bit better these days, but my "better C++" interests lie in Rust nowadays. That said, this link is one of the ways D is strictly better: since it's been around a while, there's more educational information out there.
The biggest thing that D is better at is having been around for a much longer time. There's way more docs and users.
(it's a substantial amount... or it just decides to break conventions, which dmd did also with it's '-offilename' type flags.)
Rust is also harder to learn, and it seems (to me) to also be more difficult to use C libraries from Rust than D. I cut my teeth on D by creating a few bindings, and I really struggle to do the same in Rust.
Just my experiences...
PS - Rereading this it occurs to me that D is probably just as complex as Rust, but it 'feels' less complex due to syntax familiarity.
Even for a while after the phobos/tango thing 'was resolved,' people were still bitter/split over it.
Like I said, I'm glad things are better nowadays.
http://dconf.org/talks/buclaw.html
There's also LDC led by David Nadlinger:
Pretty much everyone uses D2 these days unless they are maintaining a legacy system written in D1 and transitioning to D2 isn't worth the effort in their case.
Phobos versus Tango hasn't been an issue for years. In fact, in D2 you can use Phobos and Tango side by side[1].
Rust is very interesting and I'm excited to see where it is headed but it's still rather immature compared to something like D.
Right, hence the 'I hear it's a bit better these days.' Maybe I should have been more clear.
> I'm not sure what licensing issues you've had
The whole time I was using the language, there was the dual licensed aspect of the compiler, where the front end (I think?) was not open, but the back end was? Or maybe the other way around? I think I heard that Walter ended up OSSing the entire thing. As a strong BSD proponent I find complex licensing requirements tiring.
> but it's still rather immature compared to something like D.
Right, I thought I said this too.
The good news is that GDC (gcc backend) and LDC (LLVM backend) both produce faster binaries than DMD and are completely open source. The only downside is they tend to be a version or two behind DMD (which at DMD's release rate is around 3-6 months or so I'd say). Also, LDC isn't available for Windows primarily because LLVM doesn't yet support SEH exceptions.
In any case, the compiler's licensing doesn't affect software you write in D.
http://thecybershadow.net/d/docs/
http://thecybershadow.net/d/docs/d2.chm sudo apt-get install chmsee
wget http://thecybershadow.net/d/docs/d2.chm
chmsee d2.chm &On the other hand, amazingly fast compiler, very concise language, and metaprogramming! Want a decent IDE!
I recommend you use Mono-D or Visual D. and, D has great parallelism and SIMD support in standard library. http://dlang.org/phobos/std_parallelism.html http://dlang.org/phobos/core_simd.html
Let's try!
Some people like to read the documentation and not let their editor figure out how to program for them.
I find languages with poor tooling irritating to use, in the same way that I find other language deficiencies irritating. I usually wish I was back using something more powerful. For example, it's the feeling I get when working with strings in C, or using a language without lambdas. I am irritated at my time being wasted when using languages where the compiler doesn't warn me about simple mistakes, or when I have to manually filter out false positives when renaming something with a tool that doesn't understand the code beyond doing find/replace/regex on a stream of unicode characters. None of this means that I can't get work done with 'blub' language and tooling, but the fact that something better exists is always in the back of my mind, and knowing I have mastered a worse tool doesn't give me much satisfaction.
The idea that more modern and better tools are a crutch is hardly unique to software development. In just about any field you can find people advocating for the 'character developing' tedium of the old ways. The irony of course is that the same arguments nearly always apply to the older methods being advocated: they once were new, and the hard won knowledge of the even older method became redundant. See: punchcards, assemblers, compilers, build automation tools, version control software, syntax highlighting, documentation being a big physical book with an index, compiler errors and warnings, images, refactoring tools, automated testing. Just about all of those have been described as a crutch that prevents people achieving real deep understanding of the computer or their code. Does it make you feel inadequate as a programmer to know that you couldn't do your job using punchcards, or as you put it, to be 'beholden to a text editor to the point where you can't program without one'.
Supports completion, as well as error checking.
Works for me.
Go is fantastinc for writing servers. The concurrency model is awesome and the standard library is surprisingly extensive given its age. It does work for non-server things, but it was developed for making concurrency as used in servers easier. There is no manual memory management, unless you use a C extension.
Pain points:
* no inheritence: it's fine for 90% of problems, but really annoying for the last 10%
* super-strict type system: byte isn't implicitly convertable to int, for example
* opinionated: code style, build system, etc.; everything can be worked around, but it's a recurring theme
* no manual memory management: the GC is getting better, but it'll never be good enough for writing intense games
D is awesome for writing more general software. The general feel is what C++ would have been if it was designed better. It has a stronger connection to C, so manual memory management is an option with free/malloc. However, most of the time you'd rely on the GC, but it's nice when you absolutely have to control things, e.g. for a game.
Pain points:
* not enough documentation: the website is awesome, but when you try to do something complicated (like write a game), it's uncharted territory
* Annoying bugs, especially in CTFE: most normal operations work fine, so this isn't really an issue
* no package manager: well, there is DSSS and Orbit, but I haven't found one that I like
* no standard http lib: terrible if you want to do web-stuff
I actually recommend them both. They're very different languages built for very different things, but you can't go wrong with either. Go 1.1 is about to be released (the "final" release candidate was released last week), and it has some cool new features (I like method values a lot). Then again, D has awesome metaprogramming support (templates are magic =D).
http://ddili.org/ders/d.en/hello_world.html
"Do not install a D1 compiler. This book covers only D version two."