My D book is now officially coming soon

Chris via Digitalmars-d-announce digitalmars-d-announce at puremagic.com
Tue May 6 06:51:12 PDT 2014


On Tuesday, 6 May 2014 at 13:12:01 UTC, Adam D. Ruppe wrote:
> On Tuesday, 6 May 2014 at 12:40:48 UTC, Szymon Gatner wrote:
>> Any way to see the TOC?
>
> Hmm, not on the website yet but here it is. Each one is shown 
> through examples (with a few exceptions where I couldn't think 
> of a good example but wanted to discuss the principle behind it 
> anyway):
>
> Chapter 1: "Core Tasks", has a brief introduction to D then 
> gets into using modules, libraries, immutability, classes, 
> basic stuff to get you acquainted with the core language.
>
> BTW the book assumes you already know basic programming stuff, 
> so I don't explain what variables are and stuff like that.
>
> Chapter 2: "Phobos", goes over some phobos modules to show you 
> the basic idea. Covers files and directories, socket clients 
> and servers, zlib, random numbers, and a bit more. It isn't 
> comprehensive, there's the documentation for that, but it 
> covers a few important points you'll need to know throughout 
> through representative examples.
>
> Chapter 3: "Ranges" goes over how to create a range, use a 
> range (including something I had to ask the group: what is a 
> "generic input range"?), transform ranges, and use some of the 
> algorithms. Also goes into why the efficiency rules are 
> important (don't emulate range features you don't really 
> support) by showing a bad sort result with a linked list that 
> pretends to be an array.
>
> Chapter 4: "Integration" talks about how to integrate with 
> outside code, including calling C functions (including doing 
> your own bindings and using implib on Windows), C++ interfaces, 
> Windows API and Linux system calls in asm, C functions calling 
> D, using COM, cross-language resource management (briefly) and 
> I show some convenient scripting bindings using opDispatch with 
> my script.d
>
> Chapter 5: "Resource Management" gives tips on avoiding the GC, 
> writing your own reference counted objects, using owned 
> pointers, and stuff like how not to use class destructors.
>
> Chapter 6: "Wrapped Types" goes into a bunch of struct features 
> you can use to wrap other things. Includes a cute trick to make 
> a gettext translation file in D alone, operator overloading, 
> disabling default construction, etc.
>
> Chapter 7: "Correctness Checking" talks about bug catching. 
> Includes an introduction to ddoc, static assert, throw vs 
> assert, @safe, and more.
>
> Chapter 8: "Reflection" goes into compile time and runtime 
> reflection including TypeInfo, __traits, is(), std.traits, and 
> using module constructors to extend typeinfo. Culminates in an 
> automatic function caller from the command line, showing how to 
> get functions by name, convert strings to their arguments, and 
> their return values back to strings, all generically with CT 
> reflection.
>
> Chapter 9: "Code Generation" talks about user-defined literals 
> (including showing a disassembly to you can prove it did what 
> it was supposed to do), template value parameters, string 
> mixins, domain-specific language converters (including a 
> relatively traditional programming language and an ASCII art 
> diagram conversion to a struct), and talks about doing more 
> efficient generation with the right statements so the optimizer 
> can do its magic.
>
> Chapter 10: "Multitasking" introduces you to threads, fibers, 
> pipe process, and std.parallelism. I don't go too deeply into 
> all this since I think the documentation and Andrei's book both 
> did a good job and I didn't have a lot to add.
>
> (generally, I wanted my book to be a nice complement to 
> Andrei's book and avoid repeating documentation, so it is 
> genuinely something new that you might not have seen before. 
> Though much of it is stuff I've talked about on the forums, 
> stack overflow, or IRC, so it won't be all new if you've seen 
> my posts over the last couple years.)
>
> Chapter 11: "Kernel coding in D" gets you started using D on 
> bare metal x86; booting your PC to a D program without an 
> operating system. Shows how to remove druntime then add back 
> the minimal parts to get hello world to compile, how to easily 
> compile and link the program so it can run without the OS (a 
> simpler process can be used to make a minimal tiny binary that 
> works on an OS btw, it would be like using D as C), then kinda 
> dumps some code on you to get keyboard interrupt handling 
> working.
>
> I didn't go into the details of how the hardware specific code 
> works; I didn't explain what an interrupt table actually is or 
> why its format is so weird, but I did give you the pieces to 
> make it work and discuss the D features that are helpful in 
> this environment (and some pitfalls) like naked asm functions.
>
> Chapter 12: "Web and GUI programming" shows how to get some fun 
> stuff started with my misc github libraries including a dynamic 
> website, a desktop graphics demo, some image file manipulation, 
> an OpenGL window, and my dom.d for HTML parsing and 
> manipulation.
>
> The main focus isn't so much how to use the libraries though, 
> there's the [s]docs[/s] lol, the source and emailing me with 
> questions for that. Instead, I talked more about how I 
> implemented them and some lessons learned in the process so you 
> see more practical application of stuff the book talked about 
> before and can hopefully use that to extend your own libraries.
>
> Each thing also has a See Also section pointing to other D 
> libraries.
>
> Appendix A: has a small assortment of things that didn't fit 
> elsewhere like bare metal ARM getting started, Raspberry Pi 
> coding, getting a stack trace without an exception, the 
> exponent operator, and finally, how to get more help and 
> resources about D.

Wow! I'm really looking forward to reading it. I'll probably 
first have a look at the Ranges chapter and dom.d.


More information about the Digitalmars-d-announce mailing list