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.

Reply via email to