Array operation for computing the dot product?

[retard]

Fri, 05 Feb 2010 11:35:20 -0800, Ali Çehreli wrote:

> I did need to change my text only a few times, e.g. when constant-sized
> arrays became value types.

You can easily check from the changelogs what happened between dmd 1.00 
and 1.056. Quite a lot changed. You could even write a 200 page book 
about the changes.

> D is great because it is being designed openly by great programmers: the
> person with the longest C++ compiler writing experience, the person who
> has pushed C++ templates beyond their limits and introduced needs for
> stronger templates, many others who contribute to the language at
> various levels. Heck, even my naive voice has an effect on the language.

Heh, whatever. But the problem is, when I write a book about C, C++, 
Java, or some other language, I do know how it behaves. I can write 
informal programming books for novices or exact academic text with full 
description of the grammar rules, type system, and e.g. denotational or 
operational semantics. A D book is like a c++0x, Java7 or Haskell 2010 
book - you constantly need to update it to reflect the changes in the 
next spec update.

Now with D this isn't the case. I have to participate in the spec writing 
process no matter what I do. I do know how lazily Walter responds to 
queries and I do know that even though many have complained about 
semantics of the protection attributes in class inheritance several times 
during the past 10 years, nothing has changed. I don't want to write 
books that say

1. Classes
----------

1.1. Inheritance
----------------

Classes in D can inherit from a base class. [snip] The syntax below shows 
how to do this:

class {classname} : {protection-attr} {baseclassname} {
}

  {classname} == name of the new class, represents the type name

  {baseclassname} == name of the base class

  {protection-attr} == perhaps one of these {public|protected|package|
private} - I have no effing clue what this does and neither does anyone 
else but isn't this a cool feature that somehow proves that D is very 
practical language and also implementing your own compiler is so damn easy