This talk intends to introduce the present and future of the D development stack: Everything from build tools to configuration management all the way up to project management. The past and present of DSSS and of DSource will be explained by their respective creators, and their integrated future will be revealed. This will outline the reasons why D-specific tools and services exist, what D-specific tools like rebuild, build (bud) and DSSS can do to make D development easier, and what can be expected from both in the future.
Whether you're hosting at SourceForge, your own site or DSource, and whether you're using a D-specific tool or still using C-tailored tools like make, this talk should be informative.
STM is the hottest new paradigm in concurrent programming. This talk will explain how it works and how it might be supported in D.
This talk will examine the central role played by array-slicing in high-performance systems, and how slicing may be applied effectively in a general-purpose library. Two informal case-studies will be presented.
The innovative metaprogramming features in D give library writers the possibility of generating highly optimised code on-demand, with a quality that was previously only available to a compiler back-end. In this presentation, the key techniques will be discussed, and illustrated using the BLADE library, which performs basic linear algebra operations with a performance equivalent to hand-crafted assembly code.
This talk will attempt to explain the reasoning behind the idea that the runtime is actually three separate libraries, how they interact, and some of the relatively unique features that have been produced as the result of such a design. The underlying theme being that the runtime should not be a black box, and explicitly defining certain aspects of its behavior actually makes for more powerful user code.
This will be a talk covering a number of topics involving template compile time techniques. It will begin with a quick intro to what these techniques are. Then it will progress to a more in depth look at some compile time abstractions and a few novel compile time processing structures. Lastly it will take a look at why, when and when not to use compile time techniques.