The D Programming Language 1st Edition
|
Andrei Alexandrescu
(Author)
Find all the books, read about the author, and more.
See search results for this author
|
Use the Amazon App to scan ISBNs and compare prices.
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
-
Apple
-
Android
-
Windows Phone
-
Android
|
Download to your computer
|
Kindle Cloud Reader
|
Frequently bought together
Customers who viewed this item also viewed
What other items do customers buy after viewing this item?
Editorial Reviews
From the Back Cover
―From the Foreword by Walter Bright
“This is a book by a skilled author describing an interesting programming language. I’m sure you’ll find the read rewarding.”
―From the Foreword by Scott Meyers
D is a programming language built to help programmers address the challenges of modern software development. It does so by fostering modules interconnected through precise interfaces, a federation of tightly integrated programming paradigms, language-enforced thread isolation, modular type safety, an efficient memory model, and more.
The D Programming Language is an authoritative and comprehensive introduction to D. Reflecting the author’s signature style, the writing is casual and conversational, but never at the expense of focus and pre¿cision. It covers all aspects of the language (such as expressions, statements, types, functions, contracts, and modules), but it is much more than an enumeration of features.
Inside the book you will find
- In-depth explanations, with idiomatic examples, for all language features
- How feature groups support major programming paradigms
- Rationale and best-use advice for each major feature
- Discussion of cross-cutting issues, such as error handling, contract programming, and concurrency
- Tables, figures, and “cheat sheets” that serve as a handy quick reference for day-to-day problem solving with D
Written for the working programmer, The D Programming Language not only introduces the D language―it presents a compendium of good practices and idioms to help both your coding with D and your coding in general.
Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.
Product details
- Publisher : Addison-Wesley Professional; 1st edition (June 2, 2010)
- Language : English
- Paperback : 460 pages
- ISBN-10 : 0321635361
- ISBN-13 : 978-0321635365
- Item Weight : 1.69 pounds
- Dimensions : 6.9 x 1.1 x 9 inches
-
Best Sellers Rank:
#785,440 in Books (See Top 100 in Books)
- #114 in LANs (Books)
- #306 in C++ Programming Language
- #2,112 in Computer Programming Languages
- Customer Reviews:
Customer reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
thorough and well written description of this relatively new,
well-designed and powerful software development paradigm.
The book explains complex language features in a clear and
concise manner and builds understanding of the language
starting from the basic concepts and building up to rather
advanced topics. It is packed with examples and has quite
a few motivational discussions justifying why certain design
decisions were made in creating the language.
The writing is precise for the most part, as one would hope to
find in a definitive work. But it is laced with allegories and
humor that both clarify the content and make it a lighter read
than might be expected. As you can tell, I liked the book.
I came away with a good understanding of the intentions
and capabilities of the "D" language, although I am sure it
will take another pass through the book and a few hands-on
programming projects for me to really feel comfortable with it.
During that learning phase this book will never be far from
my hand.
In the interest of completeness, let me list a few things that
this book is not. It is not a text on how to write programs.
The examples are laser-focused on the language feature being
described, and many of the descriptions start a step or two
above "beginner" level and are somewhat terse. One would do
better with this book coming from a solid software development
background and familiarity with the concepts and terminology
of, for example, object-oriented programming.
Curiously, only a little more than half a year off the
presses, there are aspects of the book that are out of sync
with the existing "D" infrastructure. The canonical "Hello,
World!" program will not compile without changes that align it
with the current run-time support libraries. Also, I have run
across a couple of keywords that don't work quite as described
or are not recognized at all by the current compilers. In this
regard, my guess is that the book is a description of how
"D" should be, and the implementation is trying to catch up.
This is certainly not a fatal flaw and perhaps something to be
expected in a dynamic situation, but try out a feature before
you commit large amounts of effort to it.
My only other caveat is that this first edition is somewhat
lacking as a reference manual. The index needs some work;
entries could at least highlight which of a half-dozen page
references is the primary one. At one point I wanted to
clarify use of the "binary '!'" operator. It took me quite a
while to find it on page 234 under "Parameterized Classes and
Interfaces." Some of the "Summary and Reference" sections at
the end of chapters contain useful tables of statement types
or operator precedence, but there is no "List of Tables" to
guide one to the best reference. I'm sure the next edition
will be much improved as a language reference, in the meanwhile
my copy is full of pencil notes and bookmarks.
Note that I have just started coding in "D" and my comments
should be interpreted in that light. I hope that you have
found this review useful.
While some previous programming previous is assumed, familiarity with the specifics of given paradigms is not. The justification behind concepts such as contract programming is stated, before discussing D's implementation. The author assumes no familiarity with D's syntax, making this book an excellent way to learn the language.
One of the best features of this book is its bibliography. Throughout the text citations are provided for certain facts or arguments, which provide more depth or context. These also serve to strengthen the implicit argument that D is a well-thought out and designed language.
When a code example is given, it shows up as inline text, with a hyperlink above that says "Click here to view code image". At first, I was having trouble understanding the code in the inline text - it had gaps in it, as if extra spaces were inserted. For instance, here's one example from section 4.1.7:
double[] a, b, c;
double d;
...
a[] = ( b[] (c[] 4)) c[] d;
The last line doesn't make any sense.
What I realized is that none of the punctuation symbols that represent operators were being displayed! The last line should show as:
a[] = -( b[] * (c[] + 4)) + c[] * d;
It shows correctly if I click on the "Click here to view code image" link, and it also has the correct characters if you copy the line and, for example, paste it into Notepad. So the problem is clearly not that the characters are missing, it's that they are not being displayed for some reason.
This is not isolated to one place, it happens in pretty much every code example that has any operator characters in it.
So if you are trying to understand a code example, the "Click here to view code image" link might be your friend :-)
Thanks.
Top reviews from other countries
When I began my PhD I started scripting some models in python, and quickly realised that while this would do for prototyping, in terms of speed, I would need to pick something a little faster and more manageable for my needs. After trying out Java again I decided to take another look at D which I had come across a couple of years earlier. As I was the only developer on my projects for my PhD, I didn't need to worry much about software dependencies, and figured if I wanted a compiled, garbage collected language, I should give D a try. By this time, a lot of the older issues had been settled with D2, deciding on a standard library to use, as well as providing 3 compilers to choose from: DMD, LDC (LLVM) and GDC (GNU). After some browsing on the website and forums, and a little digging, I had decided that implementing my own projects in D would be a good test of how easy it was to pick up, and how enjoyable it was to work with during those stressful moments.
# Book review starts here
This book was my starting point, and along with the somewhat decent documentation on the dlang site, it has been my only reference point so far. Andrei is an excellent writer when it comes to getting you excited about programming. This isn't a book for the novice programmer, but for anyone with a little programming experience (enough to pick up the basics of a new language) this book is full to the brim with novel and exciting implementations of functions that surprise you with their simplicity and elegance when implemented in the D language. Andrei takes you from small examples through to implementing and reimplementing utility functions such as sorting algorithms in order to fully demonstrate the expressive power of D. It's both a really nice, gentle walk through a new language, as well as an excellent book for bookmarking reference tables for the different types in the language, as well as neat tricks you can do with templates that you might not have dreamt of before.
Explanations come with code and even diagrams in places, and the writing is always clear and precise. It's a comprehensive book considering its size, and will set you up for venturing into D for sure. It might be a little outdated in terms of running the examples in the book, given that D is constantly implementing new language features and deprecating old library functions for smarter, more elegant solutions. But the errata can be found at http://erdani.com/tdpl/errata/ should you need help and the compiler isn't explicit enough to point you in the right direction.
I cannot recommend this book enough. Andrei is an excellent teacher for people wanting a refreshing introduction to a new language, and he succeeds in getting you excited about programming and trying out D. I hope he continues to update the book in the future.
The book is clearly aimed at experienced programmers wanting to learn D as a second or subsequent language. If that's you, I recommend it without hesitation. The book assumes you already know what types, variables and functions are, and goes straight into specifics about D. It also explains not only the choices that D has made, but why it made them and how to work with them. D draws strongly from C++ and C, and you'll find it easiest to learn D from this book if you've used those languages already. However, D also exploits a number of important ideas drawn from other strands, such as functional programming, so don't feel put off if your expertise lies elsewhere.
Although D itself would make a good choice of first language, this book is not a programming primer. Ali Cehreli's book is aimed squarely at that constituency, and you might do better there if you're a beginner.
The only reason I've given Dr Alexandrescu's book only four stars is that -- as you can see by visiting (...) and looking at the change logs -- D has come a long way since 2010. If the author could be persuaded to update his book and keep it to the same standard, I'd certainly award it five stars.
Die Programmiersprache D verdient Aufmerksamkeit, ihre Besonderheiten und viele Designentscheidungen die Sprache betreffend werden hervorragend erklärt.
Ich bin schon mehrfach auf die Sprache gestoßen, der Wunsch sich genauer mit ihr zu beschäftigen kam aber erst vor kurzem, als heise.de vermeldet hat, dass Facebook die ersten in D geschriebenen Module produktiv genommen hat. Diese wurden übrigens vom Autor des Buches, Andrei Alexandrescu, für Facebook erstellt.
Il linguaggio D parte "da zero" e credo arrivi ad un buon risultato.
Le livre est très bien écrit, comme toujours avec cet auteur, et nettement plus agréable à lire que la plupart des ouvrages de ce genre. Les exemples sont bien choisis et pertinents. L'auteur explique non seulement comment utiliser les nombreuses fonctionnalités du langage, mais leur raison d'être, qui n'est pas toujours explicite lors de la lecture de la spécification, ainsi que les choix d'implémentation.
Tout ceci fait que la compréhension du D passe par la lecture de cet ouvrage.






