My D book is now officially coming soon
Adam D. Ruppe via Digitalmars-d-announce
digitalmars-d-announce at puremagic.com
Tue May 6 06:11:59 PDT 2014
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.
More information about the Digitalmars-d-announce
mailing list