Decent, concise introduction to SLA Theories
345308
This text provides a reasonable overview of the major current theories of second language acquisition. Each chapter is laid out in the same manner, addresses a core set of questions and provides information for further reading. This structure helps tremendously because each chapter is authored by different authors, and that can sometimes lead to disjointed text. It's not as in-depth as some texts, but it covers a broad range of theories in a cogent fashion. It provides enough information for beginners in the field to be able to make sense out of the research.

The major drawbacks are that it is overly heavy on psycholinguistically oriented theories and it provides no data for analysis. Thus, it works best if paired with another text that can provide these alternatives.
225079
I found this book by accident in a used book store. I have the older edition by Cozens and Wainwright. The book (and Perl!) doesn't have too much of a learning curve. You can go from zero to writing useful scripts very quickly. The examples and explanations that follow are straightforward. Also, I don't have to read tons of stuff and lookups like in Python. It is less pretentious than Programming Perl (which is also excellent, by the way). Lets you get started with scripting and leaves the rest to the user (Programming Perl can be read later if one wants to learn more).
779004
This was a great book that provided a broad introduction to SOA along with drill-down into BPEL, XPATH, etc.
A great addition to my technical library.
1675400
The grammar explanations presented here are very easy to follow since it is first explained in native English, then the Deutsch Grammatik just makes sense.  The book doesn't go into great detail of each topic and the chapters are short and to the point.  It is intended to be a companion book to go along with other study materials, but the information it does share is very helpful.
371802
The Principle and Parameters approach in linguistics is one of Chomsky's most profound theoretical insights, and its elegance and depth in explaining linguistic phenomena across languages is one of the most impressive achievements in linguistics. Baker's book is the best popular introduction to the approach that I have read. It is not as fun and entertaining as Pinker, but it is certainly as understandable, and it does not "dumb down" quite as much as Pinker. The book is a quick read, and contains an impressive chapter on Mohawk. Baker takes the theoretical approaches that he introduces earlier in the book, applies it to the case of Mohawk, formulates a novel explanation, and shows how we can get a deep understanding of the structure of Mohawk from a few, easily understood and elegant principles.
All in all, the book is an excellent introduction to how linguistics is done, and the models through which linguists currently think about languages and linguistic phenomena. It gives the best, most understandable explanation of central theoretical concepts such as "parameter" and "I-language" that I have seen, and gives a brief overview of "optimality theory" and other hypotheses in competition to Chomsky's version of P&P.
There is much to learn from this book, but I think that only those with a genuine interest in and sympathy to generative linguistics will find this book illuminating. To appreciate the depth and insight of the Principles and Parameters approach, you need some mastery of the technicalities and constructions, and mastery of the technicalities requires patience. To understand the problems and solutions that arise, you have to be willing to sit, think, and go over words and sentences in exotic languages slowly, including their inflections, affixes, and word order. Baker provides enough so that anyone can understand them; but you will still need to spend some time on these sections. I recommend this book to educated readers with some competence in linguistics, or to those who have a genuine interest in learning about generative grammar by looking at specific exotic languages.
1762422
I would recommend this book as a reference for anyone studying or researching SLA. It has an incredibly comprehensive list of references and despite its magnitude is surprisingly easy to read. Professor Rod Ellis is widely regarded as one of the world's leading authorities on the subject and with nearly four pages of the (110-page!) bibliography filled with his own publications alone it is easy to see why. The book is logically organised and easy to navigate. It is not the type of book most people would read for fun, but as a reference for anyone planning a literature review, I couldn't rate it highly enough; truly an indispensable resource!
1818586
On the whole, I found this an adequate introduction. It goes over the basic notion of a graph database, built as a web of nuggets of information with explicit connections between them. The authors contrast this to the popular, table-oriented relational model, and describe cases where the graph approach offer better conceptual match to the real world, better performance, and many other advantages. Although this ties to specific products, it presents some examples in terms of a very non-SQL-like query language with some intriguing possibilities. It comes across more as a conceptual introduction than a detailed manual for the practitioner, but that's OK.

Not surprisingly, it skips over cases where relational's implicit, regular parallelism offers huge possibility for acceleration compared to the random access patterns of graph databases, but one could concoct cases for advantage in either direction. Also, despite the effort in computing a relational "join", there's great freedom in being able to create arbitrary new relationships between data elements - graph DBs show no straightforward way to step off the trails defined by the graph's existing edges. To boldly go through the data where no one has gone before seems not to be part of the paradigm.

My problem lies in presenting graph databases as shiny and new, the next great thing after relational. They're also shiny and old, the last great thing before relational.  Network-based&nbsp;<a data-hook="product-link-linked" class="a-link-normal" href="/CODASYL/dp/0471995797/ref=cm_cr_arp_d_rvw_txt?ie=UTF8">CODASYL</a>&nbsp;databases held sway through the 1970s and early 1980s, before the relational model swept the industry in a seismic shift. For some reason, the authors omit all mention of this fact. The index doesn't even list the word CODASYL. Whether intentionally or not, the authors come across as Santayana's "those who cannot remember the past." In particular, they choose not to discuss database optimizations based on the physical, on-disk relationships between data items - something explicit in at least one CODASYL database I used back in the day, and that offered very worthwhile speedups.

This presents good conceptual foundation for graph databases. It's not the how-to for a serious programmer, though, and completely disregards decades of practice and hard-won experience.

-- wiredweird
3944146
I have been using JSL to generate applications and to automate analyses since JMP 7 was released. Like most others who program in this language, my proficiency has improved through a combination of trial & error, reading the JMP forum, contacting JMP technical support, and referencing the help menu and JMP scripting guide. This combination works, but it can be frustrating, especially when just beginning to use JSL.

The JSL Companion succeeds by covering the majority of challenges that users will face, while working through and discussing methods to address examples presented within. It does not have the burden of trying to be comprehensive like the JMP help menus and JMP Scripting guide. As a consequence, the text is enriched with the discussion of commands and syntax that are the most relevant.

In any programming language there are multiple ways to achieve a desired outcome. The advantage of the JSL Companion is that it explores different JSL methods, while providing a comparison and contrast to the different approaches. By explaining the advantages of each method, the authors provide insight into the programming decision making process, and often provide the novice programmer alternative JSL methods with the rationale for their use.

As an experienced JMP scripter, I was pleased to add a few tools to my bag of tricks. I especially enjoyed the occasional references to undocumented JSL commands. I would recommend this book as a primer for anyone who would like to accelerate their learning of JSL and to anyone who writes JMP scripts regularly that would like to use JSL more comprehensively.
2226026
This short book (139 pages in the ePub version) serves as a good introduction and quick reference on how to utilize the new async and await features in C# 5.0

It also explains in detail how asynchronous programming works in .NET when using these features and some of the consideration to have when designing an asynchronous API.

If you are experienced with asynchronous programming in .NET or any other platform you can very well skim over the first three chapters. They serve as an introduction for what asynchronous programming is and some of the gotchas you will find if you are not used too.

The book gets to the meat of it on chapter 4 and keeps progressing nicely into more complex and real world scenarios.

I'm particularly glad to see a chapter on how to address testing with asynchronous code.

Aside from the main content some of the chapters I really enjoyed are Chapter 13 that deals with Async in WinRT applications and Chapter 14 that explains how the compiler transform your code and how some of those "magic" trick work. I think is very important we get an understanding of it, specially if we have to debug some obscure bug later on.

All and all a very nice read.
4077349
This book does not assume that you understand compilers or programming language theory. However, the beauty and eloquence of what the book is trying to teach you will be far clearer if you do understand these disciplines. This book teaches you how to build nondeterministic recursive-descent parsers. If you are interested in other kinds of parsers, then you need to consult another source. The classic source on these other kinds of parsers is "Compilers: Principles, Techniques, and Tools" by Aho, also known as "The Dragon Book".

This book explains how to write parsers for new computer languages that you create. Each chapter focuses on either background, techniques, or applications. A chart at the beginning of chapter one shows you which chapter focuses on each topic. Each chapter builds on the material presented in preceding chapters, so you should probably proceed through this book linearly. I review this book in the context of the table of contents:

1. Introduction - Just performs an overview of the book.

2. The Elements of a Parser - Explains what a parser is, introduces the building blocks of applied parsers, and shows how to compose new parsers from existing ones.

3. Building a Parser - Explains the steps in designing and coding a parser.

4. Testing a Parser - How to test a new language's features and also how to use random testing to detect ambiguity and other problems.

5. Parsing Data Languages - Shows how to create a parser that reads the elements of a data language. A data language is a set of strings that describe objects following a local convention.

6. Transforming a Grammar - How to ensure the correct behavior of operators in a language and how to avoid looping in a parser, which can follow from loops in a grammar.

7. Parsing Arithmetic - This chapter develops an arithmetic parser. Arithmetic usually appears as part of a larger language.

8. Parsing Regular Expressions - develops a regular expression parser. A regular expression is a string that uses symbols to describe a pattern of characters.

9. Advanced Tokenizing - Describes the tokenizers that are part of the Java programming language as well as the customizable tokenizer of this particular book. Tokenizing a string means breaking the string into logical nuggets so that you can define your parser in terms of these nuggets rather than individual characters.

10. Matching Mechanics - Explains how the fundamental types of parsers in this book match text.

11. Extending the Parser Toolkit - How to extend a parser toolkit which includes introducing new types of terminals or completely different parser types.

12. Engines - Introduces a logic engine, which is a piece of software that is able to return objects and groups of objects in response to a logical query.

13. Logic Programming - Shows how to program with facts and rules.

14. Parsing a Logic Language - How to construct a parser for a logic language. It shows how to build a parser for the Logikus programming language that was introduced in the previous chapter.

15. Parsing a Query Language - Constructs a parser for a query language. A query language parser translates textual queries into calls to an engine. The engine proves the query against a source of rules and data and returns successful proofs as the result of the query.

16. Parsing an Imperative Language - Shows how to create a parser for imperative languages. An imperative language parser translates a textual script into a composition of commands that direct a sequence of actions.

17. Directions - Points out areas for further reading and programming.

I used this book to create a parser for a visual language, and I found the instructions in this book very complete and helpful. I would recommend the following books if you are interested in getting deeper into the theory behind this book - "Programming Language Pragmatics" and also "Introduction to the Theory of Computation" by Sipser.
12465
This book is extensive without being long winded. It covers most, if not all of the functionality locked away in Xtext. It does a respectable job of introducing Xtend. It is well organized, which makes it easy to skip chapters not of interest to the reader without losing context in later chapters. Examples are concise, focussed, practical and accurate - and the examples work too!

Compared to some of the works on other language construction tools, this book is a shining example of what a book on language construction should look like.

Caveat: don't take on this book if you do not have some knowledge of language construction. A little knowledge of ANTLR will go a long way as it will make a big difference in dealing with the ANTLR errors/warnings when constructing a new language.

Well done Lorenzo and the editors of this book!
134245
When I learned that this was the required book for my introductory data structures class this semester, I was somewhat worried by the large number of very negative reviews I saw it had received here. However, during the first class meeting, the professor made a point of instructing us to get the third edition (published in 2004), explaining that the differences between the second and third editions were significant.

Judging by the older reviews below, he was right - the book I read seems to bear little if any resemblance to the one denounced by the other reviewers. I found it clear and readable, though it was rather basic and dry. But then, I wasn't expecting great literature - this is a introductory compsci textbook, after all. Though it could be dull at times, it generally managed to get its information across clearly, which is all it needs to do. There were some typos, of course, though probably not more than should be expected to accompany such a major revision. The book's main flaw was an index that had essentially no relation to the actual text itself. A corrected index is available at the book's Web site.

In terms of organization, Goodrich and Tamassia start off with a brief introduction to Java, object oriented design and a brief and very basic discussion of running time and asymptotic analysis. They then work their way through basic data structures and abstract data types - stacks, queues, vectors, lists, trees (general, binary, and binary search), priority queues, heaps, dictionaries, hash tables and graphs. They discuss the structures' purposes and major operations, analyze the operations' running times, and include decent, heavily-documented Java implementations of some of the structures and methods. They also do some stuff with algorithms, though generally nothing very complex or sophisticated. I used this book in an introductory data structures course at a liberal arts college, which managed to cover pretty much everything in the book with little difficulty.

There are a lot of exercises at the end of each chapter. Goodrich and Tamassia divide them up into progressively more complex "Reinforcement", "Creativity" and "Projects" sections. My instructor preferred to assign problems and programming assignments of his own creation, though, so I don't know how helpful or useful the exercises in the book actually are.

All in all, it seem Goodrich and Tamassia noticed the sort of reviews the earlier editions of this book were getting and took steps to correct the many problems they had. I expect that if you have to use the book in a data structures course, you'll find it at least reasonably clear and generally acceptable. As long as you're using the third edition, that is.
1978695
Functional programming (Erlang, haskell, OCAML, mainly) has returned to devs' mindshare, look at lambda-the-ultimate, artima, reddit.  It's produced a lot of blogs, online tutorials, but if you want a current book that's a complete overview, carefully written and vetted?  Pretty slim pickings.

This book is an offshoot (or inspired by, or something) of Armstrong's PhD thesis.  It is (or was) a pragmatic beta product, reviewed by 100's of developers, and this shows in exposition of data structures and algorithms.  It's as good as intro dev texts get.  The intro bits, like where the math teacher says "all X's mean the same thing" are kind of helpful but after that there's not a lot of handholding of the type of "how to do __ in java and erlang, side by side" (except the Exceptions chapter), or "Here's my definition of functional programming".  There's lots of things similar to the ruby or python or smalltalk dev environment, some counter-intuitive things as well(no short-circuits of boolean expressions) but this book's an exposition of Erlang features, common tasks, and  best practices.  I liken this to the best software books, K&R, Python in a Nutshell, SICP, it's rigorous and intellectually and viscerally satisfying ;-)

If you know prolog or lisp, or read the arguments about DSLs /metaprogramming that java and smalltalk/lisp/ruby/javascript devs are won't to have, you may say it fits your brain.  Others have noted that the syntax is a complete rework of how they approach programming, that unification/pattern matching and constraint satisfaction is nothing like programming the algol-family.  But i think all devs have to understand how regular expression engines work, so you can draw parallels there (tho no backtracking in erlang).

(extremely) minor drawbacks of the book: preachy tone of superiority of COP (concurrency-oriented programm'g), fault-tolerance, many processes, etc.  Some of the typesetting (code bits in footnotes against grey background) is hard to read.  Division of the book into chapters is kinda odd (there's a couple 2-page chapters)
3455751
This book contains roughly 90 task-based tutorials, all roughly 3-4 pages in length. Each tutorial begins with a short introductory paragraph, and continues on to a point-form summary of code and configuration. As the tutorials are so short; there are usually between 4 and 8 steps to complete a task. The tasks expand on the official documentation; filling a gap in which API meets real-world tasks.

The layout of each task is formulaic, and while this breeds consistency; it hurts context. There are many tasks where I would have preferred more descriptive text. Many of the code points also need description closer to code. Sometimes "In the views/common directory, open header.php and use this code as follows" is not enough to justify strange or new code.

I also missed syntax highlighting. The book is about code and syntax-highlighting is as important to reading code as grammar is to reading a novel. I can understand when self-publishers omit this sort of thing; because of the limitations of their cheap-as-free tools, but big publishing outfits have the resources to ensure this sort of slip-up doesn't happen.

I enjoyed most of the tasks, though there were some obscure sections on setup (right in the beginning of the book). There are a broad range of topics; including forms, authentication, database, controllers, routing, views, packages, security and testing. There are also many tasks focussed on JavaScript and third-party service integration. These range, in difficulty, from beginner to intermediate.

The content is suited to short bursts of development activity. Since the tasks are short and quick; the book finds it's place as a reference book. Need to implement OAuth and remember reading about it in the cookbook? Pull it off the shelf and flip to that chapter! While this is the reason I have many of the books that I do; it's not the best for prolonged learning/development sessions. At around the twentieth consecutive task, they all start to blend together until you start to forget what you've already done.

The best way you can use this book is to pick a handful of tasks you want to achieve and learn them. Remember what you've done, each session, and know where to find them again when the time comes to implement in a real-world situation. It's good for that!
3686446
This is a great place to get a clear introduction to first-order modal logic.  It elegantly straddles the line between philosophy and mathematics, without getting bogged down in the details of either (as much of the rest of the modal logic literature seems to).  This book, along with Nerode and Shores "Logic for Applications"--which also focuses on tableaux proofs--really shaped my thinking about modal logic.
17951
"The D Programming Language" by Andrei Alexandrescu is a
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.
426186
Although it is thinner than Copi's, I think the author processes the tutorial in a better way, more appealing to me, at least. It is a necessary for a beginner at the gate of logic. It suffices the three standards of a good textbook: general, simple and clear. After that, you can go deeper in some specific areas.
In short, I recommend this book without reservation.