<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0">

<channel>
  <title>Programming in D</title>
  <link>http://ddili.org/</link>
  <description>Programming with the D programming language</description>
  <language>en</language>
  <category>D Programming Language Book</category>

  <item>
    <title>'deprecated', 'extern', and 'extern()'</title>
    <link>http://ddili.org/modules.html</link>
    <description>Added 'deprecated' that helps with deprecation process of library features, 'extern' that is for declaring external symbols, and 'extern()' that allows interacting with libraries of other languages (extern(C), extern(C++, std), etc.).</description>
    <category>Chapter</category>
    <pubDate>24 Oct 2015 22:00</pubDate>
  </item>

  <item>
    <title>Code Samples .zip File</title>
    <link>http://ddili.org/index.html</link>
    <description>You can download most of the code samples that appear in the book as a .zip file.</description>
    <category>Code</category>
    <pubDate>16 Oct 2015 20:00</pubDate>
  </item>

  <item>
    <title>Book Index</title>
    <link>http://ddili.org/ix.html</link>
    <description>The index section of the book.</description>
    <category>Chapter</category>
    <pubDate>21 Aug 2015 02:00</pubDate>
  </item>

  <item>
    <title>Fibers</title>
    <link>http://ddili.org/fibers.html</link>
    <description>Cooperative multitasking in D with fibers.</description>
    <category>Chapter</category>
    <pubDate>17 Aug 2015 15:00</pubDate>
  </item>

  <item>
    <title>Pragmas</title>
    <link>http://ddili.org/pragma.html</link>
    <description>Pragmas that allow interactions with the compiler, including the most recent pragma(inline).</description>
    <category>Chapter</category>
    <pubDate>17 Aug 2015 15:00</pubDate>
  </item>

  <item>
    <title>Operator Precedence</title>
    <link>http://ddili.org/operator_precedence.html</link>
    <description>The rules that specify the execution order of chained operators and the expressions that they use.</description>
    <category>Chapter</category>
    <pubDate>17 Aug 2015 15:00</pubDate>
  </item>

  <item>
    <title>Foreword by Andrei Alexandrescu</title>
    <link>http://ddili.org/foreword2.html</link>
    <description>"Instead of falling for getting things done quickly, 'Programming in D' focuses on getting things done properly, to the lasting benefit of its reader."</description>
    <category>Chapter</category>
    <pubDate>17 Aug 2015 15:00</pubDate>
  </item>

  <item>
    <title>Ebook versions</title>
    <link>http://ddili.org/index.html</link>
    <description>In addition to the PDF version, now there are EPUB and AZW3 versions as well.</description>
    <category>Ebook</category>
    <pubDate>15 Dec 2014 02:00</pubDate>
  </item>

  <item>
    <title>'.offsetof' property and 'align' attribute</title>
    <link>http://ddili.org/memory.html</link>
    <description>The .offsetof property to get the offsets of and the align attribute to specify the alignments of struct members.</description>
    <category>Chapter</category>
    <pubDate>25 Nov 2014 17:00</pubDate>
  </item>

  <item>
    <title>Contract inheritance</title>
    <link>http://ddili.org/invariant.html</link>
    <description>Inheriting 'in' and 'out' blocks of interface and class functions.</description>
    <category>Chapter</category>
    <pubDate>25 Nov 2014 17:00</pubDate>
  </item>

  <item>
    <title>The special keywords</title>
    <link>http://ddili.org/templates_more.html</link>
    <description> __MODULE__, __FILE__, __LINE__, __FUNCTION__, and __PRETTY_FUNCTION__</description>
    <category>Chapter</category>
    <pubDate>25 Nov 2014 17:00</pubDate>
  </item>

  <item>
    <title>pragma</title>
    <link>http://ddili.org/templates.html</link>
    <description>The pragma directive</description>
    <category>Chapter</category>
    <pubDate>25 Nov 2014 17:00</pubDate>
  </item>

  <item>
    <title>Nested Functions, Structs, and Classes</title>
    <link>http://ddili.org/nested.html</link>
    <description>Defining functions, structs, and classes inside existing scopes.</description>
    <category>Chapter</category>
    <pubDate>25 Nov 2014 17:00</pubDate>
  </item>

  <item>
    <title>Lvalues and Rvalues</title>
    <link>http://ddili.org/lvalue_rvalue.html</link>
    <description>Lvalues, rvalues, their differences, and 'auto ref' parameter type that can accept either kind.</description>
    <category>Chapter</category>
    <pubDate>25 Nov 2014 17:00</pubDate>
  </item>

  <item>
    <title>The 'Index' section</title>
    <link>http://ddili.org/pdf_indir.html</link>
    <description>Automatically generated index section for the PDF version of the book.</description>
    <category>Chapter</category>
    <pubDate>25 Nov 2014 17:00</pubDate>
  </item>

  <item>
    <title>The 'Table of Contents' section</title>
    <link>http://ddili.org/pdf_indir.html</link>
    <description>Automatically generated TOC section for the PDF version of the book.</description>
    <category>Chapter</category>
    <pubDate>28 Sep 2014 23:00</pubDate>
  </item>

  <item>
    <title>The attributes of Throwable</title>
    <link>http://ddili.org/exceptions.html</link>
    <description>The attributes of the Throwable interface, collateral exceptions, and an example of accessing collateral exceptions through the .next property.</description>
    <category>Chapter</category>
    <pubDate>18 Sep 2014 16:00</pubDate>
  </item>

  <item>
    <title>Selective, local, renamed, and package imports</title>
    <link>http://ddili.org/modules.html</link>
    <description>Importing modules selectively, locally, under a different name, and as a package.</description>
    <category>Chapter</category>
    <pubDate>17 Sep 2014 00:30</pubDate>
  </item>

  <item>
    <title>@disable</title>
    <link>http://ddili.org/special_functions.html</link>
    <description>The @disable attribute to disable special functions of structs.</description>
    <category>Chapter</category>
    <pubDate>12 Sep 2014 00:15</pubDate>
  </item>

  <item>
    <title>Operator overloading for multi-dimensional indexing and slicing</title>
    <link>http://ddili.org/templates_more.html</link>
    <description>The templated versions of opDollar, opIndex, and opSlice, and examples of using them to support multiple indexes inside square brackets.</description>
    <category>Chapter</category>
    <pubDate>11 Sep 2014 00:15</pubDate>
  </item>

  <item>
    <title>static this, static ~this, shared static this, and shared static ~this</title>
    <link>http://ddili.org/index.html</link>
    <description>Specifying the initial and final operations of threads and programs.</description>
    <category>Chapter</category>
    <pubDate>26 Aug 2014 23:30</pubDate>
  </item>

  <item>
    <title>User Defined Attributes (UDA)</title>
    <link>http://ddili.org/uda.html</link>
    <description>Assigning user defined attributes to type and variable declarations, testing the attributes at compile time, and compiling the program according to those attributes.</description>
    <category>Chapter</category>
    <pubDate>26 Aug 2014 22:30</pubDate>
  </item>

  <item>
    <title>Memory Management</title>
    <link>http://ddili.org/memory.html</link>
    <description>The garbage collector, allocating memory, and placing objects at specific locations in memory.</description>
    <category>Chapter</category>
    <pubDate>24 Jul 2014 01:00</pubDate>
  </item>

  <item>
    <title>Type traits</title>
    <link>http://ddili.org/cond_comp.html</link>
    <description>Using type traits in conditional compilation.</description>
    <category>Chapter</category>
    <pubDate>29 May 2014 20:30</pubDate>
  </item>

  <item>
    <title>Data Sharing Concurrency</title>
    <link>http://ddili.org/concurrency_shared.html</link>
    <description>Multi-threaded programming in D by data sharing.</description>
    <category>Chapter</category>
    <pubDate>20 May 2014 12:00</pubDate>
  </item>

  <item>
    <title>More Ranges</title>
    <link>http://ddili.org/ranges_more.html</link>
    <description>Useful range templates of the std.range module. Providing range capabilities depending on the capabilities on dependent ranges.</description>
    <category>Chapter</category>
    <pubDate>01 November 2013 17:00</pubDate>
  </item>

  <item>
    <title>Mixins</title>
    <link>http://ddili.org/mixin.html</link>
    <description>Template and string mixins that allow inserting compile-time generated code into the source code.</description>
    <category>Chapter</category>
    <pubDate>01 November 2013 17:00</pubDate>
  </item>

  <item>
    <title>More Functions</title>
    <link>http://ddili.org/functions_more.html</link>
    <description>More features of D functions: auto, ref, auto ref, and inout return attributes; pure and nothrow behavioral attributes; and @safe, @trusted, and @system memory safety attributes.</description>
    <category>Chapter</category>
    <pubDate>01 November 2013 17:00</pubDate>
  </item>

  <item>
    <title>More Templates</title>
    <link>http://ddili.org/templates_more.html</link>
    <description>More information about templates: Templates can define any kind of code; template parameters can be of type, value, alias, this, and tuple; template constraints enable template definitions only for template arguments that satisfy that template's requirements.</description>
    <category>Chapter</category>
    <pubDate>19 September 2013 00:30</pubDate>
  </item>

  <item>
    <title>Tuples</title>
    <link>http://ddili.org/tuples.html</link>
    <description>Tuples, which combine values of different types and make them available similar to struct objects, and TypeTuple, which represents the concept of 'list of values' as seen in parameter lists, template argument lists, and array literal initialization lists.</description>
    <category>Chapter</category>
    <pubDate>19 September 2013 00:30</pubDate>
  </item>

  <item>
    <title>Ranges</title>
    <link>http://ddili.org/ranges.html</link>
    <description>The code examples in the Ranges chapter are made const-correct and they take advantage of UFCS.</description>
    <category>Chapter</category>
    <pubDate>09 July 2013 19:30</pubDate>
  </item>

  <item>
    <title>Labels and goto</title>
    <link>http://ddili.org/goto.html</link>
    <description>Labels that give names to code lines and the goto statement that make program execution go to a label.</description>
    <category>Chapter</category>
    <pubDate>28 June 2013 19:00</pubDate>
  </item>

  <item>
    <title>Unions</title>
    <link>http://ddili.org/union.html</link>
    <description>Sharing the same memory area for multiple members.</description>
    <category>Chapter</category>
    <pubDate>26 June 2013 10:00</pubDate>
  </item>

  <item>
    <title>foreach with Structs and Classes</title>
    <link>http://ddili.org/foreach_opapply.html</link>
    <description>Providing foreach support for structs and classes.</description>
    <category>Chapter</category>
    <pubDate>14 June 2013 18:30</pubDate>
  </item>

  <item>
    <title>Function Pointers, Delegates, and Lambdas</title>
    <link>http://ddili.org/lambda.html</link>
    <description>Function pointers and delegates allow storing how the program should behave at a later time. Lambdas (anonymous function or function literals) make code more readable and reduce boilerplate code.</description>
    <category>Chapter</category>
    <pubDate>9 June 2013 18:00</pubDate>
  </item>

  <item>
    <title>is Expression</title>
    <link>http://ddili.org/is_expr.html</link>
    <description>is expression, one of the most powerful compile-time features of the D programming language.</description>
    <category>Chapter</category>
    <pubDate>3 June 2013 22:00</pubDate>
  </item>

  <item>
    <title>Conditional Compilation</title>
    <link>http://ddili.org/cond_comp.html</link>
    <description>Compiling parts of programs in special ways depending on conditions that are checked at compile time.</description>
    <category>Chapter</category>
    <pubDate>3 June 2013 21:30</pubDate>
  </item>

  <item>
    <title>Bit Operations</title>
    <link>http://ddili.org/bit_operations.html</link>
    <description>The D features that enable manipulating data bit-by-bit.</description>
    <category>Chapter</category>
    <pubDate>21 May 2013 23:30</pubDate>
  </item>

  <item>
    <title>Pointers</title>
    <link>http://ddili.org/pointers.html</link>
    <description>Pointers are variables that provide access to other variables. They are low-level capabilities of the microprocessor.</description>
    <category>Chapter</category>
    <pubDate>31 Jan 2013 20:30</pubDate>
  </item>

  <item>
    <title>alias this</title>
    <link>http://ddili.org/alias_this.html</link>
    <description>'alias this' enables automatic type conversions of user-defined types.</description>
    <category>Chapter</category>
    <pubDate>31 Jan 2013 20:30</pubDate>
  </item>

  <item>
    <title>alias</title>
    <link>http://ddili.org/alias.html</link>
    <description>'alias' assigns aliases to existing names</description>
    <category>Chapter</category>
    <pubDate>31 Jan 2013 20:30</pubDate>
  </item>

  <item>
    <title>Contract Programming for Structs and Classes</title>
    <link>http://ddili.org/invariant.html</link>
    <description>The 'invariant' keyword and the use of the 'in' and 'out' blocks with structs and classes.</description>
    <category>Chapter</category>
    <pubDate>31 Jan 2013 20:30</pubDate>
  </item>

  <item>
    <title>Properties</title>
    <link>http://ddili.org/property.html</link>
    <description>Properties allow using member functions like member variables.</description>
    <category>Chapter</category>
    <pubDate>31 Jan 2013 20:30</pubDate>
  </item>

  <item>
    <title>Universal Function Call Syntax (UFCS)</title>
    <link>http://ddili.org/ufcs.html</link>
    <description>UFCS enables the member function syntax even for regular functions.</description>
    <category>Chapter</category>
    <pubDate>31 Jan 2013 20:30</pubDate>
  </item>

  <item>
    <title>Encapsulation and Protection Attributes</title>
    <link>http://ddili.org/encapsulation.html</link>
    <description>Preserving class invariants by limiting access to class members.</description>
    <category>Chapter</category>
    <pubDate>2 Nov 2012 21:00</pubDate>
  </item>

  <item>
    <title>Modules and Libraries</title>
    <link>http://ddili.org/modules.html</link>
    <description>Organizing D programs and libraries as modules and packages.</description>
    <category>Chapter</category>
    <pubDate>2 Nov 2012 21:00</pubDate>
  </item>

  <item>
    <title>destroy and scoped</title>
    <link>http://ddili.org/destroy.html</link>
    <description>'destroy()' to call destructors explicitly and 'scoped()' to destroy objects automatically.</description>
    <category>Chapter</category>
    <pubDate>2 Nov 2012 21:00</pubDate>
  </item>

  <item>
    <title>Interfaces</title>
    <link>http://ddili.org/interface.html</link>
    <description>The 'interface' keyword to define class interfaces.</description>
    <category>Chapter</category>
    <pubDate>2 Nov 2012 21:00</pubDate>
  </item>

  <item>
    <title>Object</title>
    <link>http://ddili.org/object.html</link>
    <description>The Object class that is at the top of class hierarchies and its member functions toString(), opEquals(), opCmp(), and toHash().</description>
    <category>Chapter</category>
    <pubDate>2 Nov 2012 21:00</pubDate>
  </item>

  <item>
    <title>Inheritance</title>
    <link>http://ddili.org/inheritance.html</link>
    <description>Inheriting the members of existing classes.</description>
    <category>Chapter</category>
    <pubDate>2 Nov 2012 21:00</pubDate>
  </item>

  <item>
    <title>Classes</title>
    <link>http://ddili.org/class.html</link>
    <description>The 'class' feature of the D programming language, which supports the object oriented programming (OOP) paradigm.</description>
    <category>Chapter</category>
    <pubDate>2 Nov 2012 21:00</pubDate>
  </item>

  <item>
    <title>Operator Overloading</title>
    <link>http://ddili.org/operator_overloading.html</link>
    <description>Defining the behaviors of operators for structs to allow their uses as convenient as the fundamental types.</description>
    <category>Chapter</category>
    <pubDate>15 Sep 2012 23:30</pubDate>
  </item>

  <item>
    <title>Constructor and Other Special Functions</title>
    <link>http://ddili.org/special_functions.html</link>
    <description>The four special functions of structs: constructor, destructor, postblit, and assignment.</description>
    <category>Chapter</category>
    <pubDate>15 Sep 2012 23:30</pubDate>
  </item>

  <item>
    <title>Message Passing Concurrency</title>
    <link>http://ddili.org/concurrency.html</link>
    <description>Receiving LinkTerminated and OwnerTerminated exceptions as messages.</description>
    <category>Chapter</category>
    <pubDate>09 Aug 2012 23:45</pubDate>
  </item>

  <item>
    <title>Parallelism</title>
    <link>http://ddili.org/parallelism.html</link>
    <description>Explain the parameters of the functions of the std.parallelism module: Work unit size and buffer size.</description>
    <category>Chapter</category>
    <pubDate>09 Aug 2012 23:30</pubDate>
  </item>

  <item>
    <title>Immutability</title>
    <link>http://ddili.org/const_and_immutable.html</link>
    <description>The consequences of marking function parameters const or immutable.</description>
    <category>Chapter</category>
    <pubDate>09 Aug 2012 22:00</pubDate>
  </item>

  <item>
    <title>const ref Parameters and const Member Functions</title>
    <link>http://ddili.org/const_member_functions.html</link>
    <description>Marking parameters as 'const ref' and member functions as 'const' in order to be able to use them with immutable variables as well.</description>
    <category>Chapter</category>
    <pubDate>Sun, 10 Jun 2012 17:40</pubDate>
  </item>

  <item>
    <title>Member Functions</title>
    <link>http://ddili.org/member_functions.html</link>
    <description>Defining functions that are closely related to a struct inside the curly brackets of that struct definition.</description>
    <category>Chapter</category>
    <pubDate>Sun, 10 Jun 2012 16:15</pubDate>
  </item>

  <item>
    <title>Function Overloading</title>
    <link>http://ddili.org/function_overloading.html</link>
    <description>The function overloading feature that enables defining multiple functions having the same name.</description>
    <category>Chapter</category>
    <pubDate>Sun, 10 Jun 2012 14:50</pubDate>
  </item>

  <item>
    <title>Variable Number of Parameters</title>
    <link>http://ddili.org/parameter_flexibility.html</link>
    <description>Default parameter values and variadic functions.</description>
    <category>Chapter</category>
    <pubDate>Sun, 10 Jun 2012 13:20</pubDate>
  </item>

  <item>
    <title>Structs</title>
    <link>http://ddili.org/struct.html</link>
    <description>The 'struct' feature for defining higher-level concepts as user-defined types.</description>
    <category>Chapter</category>
    <pubDate>Sun, 10 Jun 2012 12:20</pubDate>
  </item>

  <item>
    <title>Type Conversions</title>
    <link>http://ddili.org/cast.html</link>
    <description>Automatic and explicit type conversions of D: integer promotions, arithmetic conversions, the to() and assumeUnique() functions, and the cast operator.</description>
    <category>Chapter</category>
    <pubDate>Sun, 10 Jun 2012 00:05</pubDate>
  </item>

  <item>
    <title>The null Value and the is Operator</title>
    <link>http://ddili.org/null_is.html</link>
    <description>The null value and the is and !is operators.</description>
    <category>Chapter</category>
    <pubDate>Sat, 09 Jun 2012 18:30</pubDate>
  </item>

  <item>
    <title>Value Types and Reference Types</title>
    <link>http://ddili.org/value_vs_reference.html</link>
    <description>Introducing value types, reference variables, and reference types; and their differences.</description>
    <category>Chapter</category>
    <pubDate>Sat, 09 Jun 2012 17:45</pubDate>
  </item>

  <item>
    <title>Lifetimes and Fundamental Operations</title>
    <link>http://ddili.org/lifetimes.html</link>
    <description>Object lifetimes: Initialization and finalization of variables.</description>
    <category>Chapter</category>
    <pubDate>Sat, 09 Jun 2012 15:15</pubDate>
  </item>

  <item>
    <title>Contract Programming</title>
    <link>http://ddili.org/contracts.html</link>
    <description>Contract programming in D: the 'in' and 'out' blocks of functions.</description>
    <category>Chapter</category>
    <pubDate>Tue, 27 Apr 2012 23:15</pubDate>
  </item>

  <item>
    <title>Unit Testing</title>
    <link>http://ddili.org/unit_testing.html</link>
    <description>Unit tests for reducing the risk of bugs and test driven development (TDD).</description>
    <category>Chapter</category>
    <pubDate>Tue, 24 Apr 2012 22:15</pubDate>
  </item>

  <item>
    <title>Installing dmd and compiling programs</title>
    <link>http://ddili.org/hello_world.html</link>
    <description>Added how to install dmd and how to compile programs on the command line.</description>
    <category>Chapter</category>
    <pubDate>Sat, 21 Apr 2012 22:15</pubDate>
  </item>

  <item>
    <title>Message Passing Concurrency</title>
    <link>http://ddili.org/concurrency.html</link>
    <description>Multi-threaded programming in D by message passing, provided by the std.concurrency module.</description>
    <category>Chapter</category>
    <pubDate>15 Apr 2012 23:15</pubDate>
  </item>

  <item>
    <title>assert and enforce</title>
    <link>http://ddili.org/assert.html</link>
    <description>The assert checks and the enforce() function that help with program correctness.</description>
    <category>Chapter</category>
    <pubDate>12 April 2012 23:30</pubDate>
  </item>

  <item>
    <title>scope</title>
    <link>http://ddili.org/scope.html</link>
    <description>The scope(success), scope(failure), and scope(exit) statements of D, which in many cases obviate the need for try-catch-finally blocks and RAII classes.</description>
    <category>Chapter</category>
    <pubDate>28 Mar 2012 23:20</pubDate>
  </item>

  <item>
    <title>Program Environment</title>
    <link>http://ddili.org/main.html</link>
    <description>The environment that starts a D program and the ways the program can interact with its environment: return value, parameters, environment variables.</description>
    <category>Chapter</category>
    <pubDate>28 Mar 2012 23:10</pubDate>
  </item>

  <item>
    <title>Lazy Operators</title>
    <link>http://ddili.org/lazy_operators.html</link>
    <description>The shortcut evaluations of three operators: logical or, logical and, and the ternary operator.</description>
    <category>Chapter</category>
    <pubDate>28 Mar 2012 01:00</pubDate>
  </item>

  <item>
    <title>Function Parameters</title>
    <link>http://ddili.org/function_parameters.html</link>
    <description>Different kinds of function parameters and how they affect the functions and the arguments.</description>
    <category>Chapter</category>
    <pubDate>28 Mar 2012 01:00</pubDate>
  </item>

  <item>
    <title>Immutability</title>
    <link>http://ddili.org/const_and_immutable.html</link>
    <description>The concept of immutability in the D programming language, the const and immutable keywords, and recommendations on how to take advantage of immutability when defining variables and function parameters.</description>
    <category>Chapter</category>
    <pubDate>22 Mar 2012 22:50</pubDate>
  </item>

  <item>
    <title>Functions</title>
    <link>http://ddili.org/functions.html</link>
    <description>The functions that define the building blocks of program behavior.</description>
    <category>Chapter</category>
    <pubDate>14 Mar 2012 00:30</pubDate>
  </item>

  <item>
    <title>enum</title>
    <link>http://ddili.org/enum.html</link>
    <description>The enum feature that enables defining named constant values.</description>
    <category>Chapter</category>
    <pubDate>13 Mar 2012 18:30</pubDate>
  </item>

  <item>
    <title>switch and case</title>
    <link>http://ddili.org/switch_case.html</link>
    <description>The switch and final switch statements, their case sections, and the use of the goto statement under the case sections.</description>
    <category>Chapter</category>
    <pubDate>27 Feb 2012 18:10</pubDate>
  </item>

  <item>
    <title>The foreach Loop</title>
    <link>http://ddili.org/foreach.html</link>
    <description>The foreach loop, one of the most common statements of D. Its use with arrays, strings, and associative arrays.</description>
    <category>Chapter</category>
    <pubDate>27 Feb 2012 18:00</pubDate>
  </item>

  <item>
    <title>Associative Arrays</title>
    <link>http://ddili.org/aa.html</link>
    <description>Associative arrays, the hash table implementation of the D programming language.</description>
    <category>Chapter</category>
    <pubDate>26 Feb 2012 22:40</pubDate>
  </item>

  <item>
    <title>Parallelism</title>
    <link>http://ddili.org/parallelism.html</link>
    <description>The std.parallelism module to make programs run faster by taking advantage of multiple cores of the system.</description>
    <category>Chapter</category>
    <pubDate>19 Feb 2012 23:10</pubDate>
  </item>

  <item>
    <title>The do-while Loop</title>
    <link>http://ddili.org/do_while.html</link>
    <description>The do-while loop and its comparison to the while loop.</description>
    <category>Chapter</category>
    <pubDate>11 Feb 2012 20:10</pubDate>
  </item>

  <item>
    <title>Formatted Input</title>
    <link>http://ddili.org/formatted_input.html</link>
    <description>Reading data that match specific formats.</description>
    <category>Chapter</category>
    <pubDate>11 Feb 2012 20:00</pubDate>
  </item>

  <item>
    <title>Formatted Output</title>
    <link>http://ddili.org/formatted_output.html</link>
    <description>Determining the format of printed values.</description>
    <category>Chapter</category>
    <pubDate>31 Jan 2012 00:00</pubDate>
  </item>

  <item>
    <title>Literals</title>
    <link>http://ddili.org/literals.html</link>
    <description>The syntax of literals of different D types.</description>
    <category>Chapter</category>
    <pubDate>31 Jan 2012 00:00</pubDate>
  </item>

  <item>
    <title>The Ternary Operator ?:</title>
    <link>http://ddili.org/ternary.html</link>
    <description>The ternary operator and comparing it to the if-else statement.</description>
    <category>Chapter</category>
    <pubDate>31 Jan 2012 00:00</pubDate>
  </item>

  <item>
    <title>The for Loop</title>
    <link>http://ddili.org/for.html</link>
    <description>The for loop and its comparison to the while loop.</description>
    <category>Chapter</category>
    <pubDate>31 Jan 2012 00:00</pubDate>
  </item>

  <item>
    <title>PDF version of the book</title>
    <link>http://ddili.org/index.html</link>
    <description>The PDF version of the book is now available through a link in chapter headers</description>
    <category>News</category>
    <pubDate>21 Jan 2012 18:00</pubDate>
  </item>

  <item>
    <title>Name Space</title>
    <link>http://ddili.org/name_space.html</link>
    <description>The lifetime and accessibility of names of variables and other program constructs</description>
    <category>Chapter</category>
    <pubDate>21 Jan 2012 18:00</pubDate>
  </item>

  <item>
    <title>auto and typeof</title>
    <link>http://ddili.org/auto_and_typeof.html</link>
    <description>The 'auto' keyword and its use during type inference, and the typeof keyword to get the type of expressions</description>
    <category>Chapter</category>
    <pubDate>21 Jan 2012 18:00</pubDate>
  </item>

  <item>
    <title>Files</title>
    <link>http://ddili.org/files.html</link>
    <description>Reading from and writing to files using the std.stdio.File struct</description>
    <category>Chapter</category>
    <pubDate>21 Jan 2012 18:00</pubDate>
  </item>

  <item>
    <title>Redirecting Standard Input and Output Streams</title>
    <link>http://ddili.org/stream_redirect.html</link>
    <description>How to redirect standard input and output streams of program to files and other programs</description>
    <category>Chapter</category>
    <pubDate>21 Jan 2012 18:00</pubDate>
  </item>

  <item>
    <title>Templates</title>
    <link>http://ddili.org/templates.html</link>
    <description>The 'Templates' chapter</description>
    <category>Chapter</category>
    <pubDate>12 Jan 2012 00:40</pubDate>
  </item>

  <item>
    <title>Strings</title>
    <link>http://ddili.org/strings.html</link>
    <description>The 'Strings' chapter</description>
    <category>Chapter</category>
    <pubDate>03 Jan 2012 18:00</pubDate>
  </item>

  <item>
    <title>Slices and Other Array Features</title>
    <link>http://ddili.org/slices.html</link>
    <description>The 'Slices and Other Array Features' chapter</description>
    <category>Chapter</category>
    <pubDate>31 Dec 2011 19:15</pubDate>
  </item>

  <item>
    <title>Characters</title>
    <link>http://ddili.org/characters.html</link>
    <description>The 'Characters' chapter</description>
    <category>Chapter</category>
    <pubDate>18 Dec 2011 19:15</pubDate>
  </item>

  <item>
    <title>Arrays</title>
    <link>http://ddili.org/arrays.html</link>
    <description>The 'Arrays' chapter has been proofread.</description>
    <category>Proofreading</category>
    <pubDate>18 Dec 2011 19:00</pubDate>
  </item>

  <item>
    <title>Arrays</title>
    <link>http://ddili.org/arrays.html</link>
    <description>The 'Arrays' chapter</description>
    <category>Chapter</category>
    <pubDate>11 Dec 2011 14:00</pubDate>
  </item>

  <item>
    <title>Floating Point Types</title>
    <link>http://ddili.org/floating_point.html</link>
    <description>The 'Floating Point Types' chapter</description>
    <category>Chapter</category>
    <pubDate>09 Dec 2011 22:10</pubDate>
  </item>

  <item>
    <title>Index</title>
    <link>http://ddili.org/index.html</link>
    <description>The index of the book</description>
    <category>Book</category>
    <pubDate>13 Nov 2011 23:00</pubDate>
  </item>

</channel>
</rss>
