https://sites.google.com/feeds/content/ikor.org/www2017-09-26T21:40:34.687ZPosts of BooksGoogle Sites1https://sites.google.com/feeds/content/ikor.org/www/88660482852180134122011-10-08T16:40:08.864Z2016-07-19T01:25:57.039Z2011-10-08T17:32:01.626ZProgramming on Purpose: Essays on Software Design

Why is software design so hard? Maybe because there aren't any guidelines for
developing successful working systems. And although many design methods have
been proposed, most too often teach us nothing more than their proponents'
methodology and not how to make the best use of them.

Most classical analysis and design books fall short of telling us when to use
the methods and techniques they advocate. Since there are no silver bullets
(that is, no "one-size-fits-all" method in software engineering) and, as P.J.
Plauger says in Programming on Purpose: Essays on Programming Design, "we
often cannot articulate why we do what we do when we do it," our experience ends
up being the only guide we have when facing new projects. This leads many
software projects to failure, rather than repeatable successes.

The patterns movement has filled a niche by cataloging well-crafted solutions
to many analysis and design problems (see, for example, Erich Gamma et al.'s Design Patterns: Elements of Reusable
Object-Oriented Software or Martin Fowler's Analysis Patterns: Reusable Object
Models). But even before the patterns fad, P.J. Plauger disseminated
simple but powerful ideas in dozens of magazine articles and a column, mainly in
late Computer Language magazine. In some sense, Programming on Purpose
complements the pattern approach because patterns are usually employed to
describe solutions at the architectural level, while the principles Plauger
describes are focused on detailed design and coding.

Programming on Purpose is the keystone of a three-volume collection of
essays he wrote between 1986 and 1993. This volume focuses on software design
while the others collect articles on people and technology. In spite of its
somewhat dated context (part of it was written before the widespread use of
object-oriented techniques, WIMP interfaces, and other prevailing practices),
the ideas and principles in this book are surprisingly fresh. In fact, Plauger's
observations are timeless and will be always relevant to software professionals
because they tackle the problem of mastering complexity that lies at the heart
of software development.

Programming on Purpose presents excellent discussions on a wide range
of design methods and techniques, from the stepwise refinement used in top-down
design to the use of grammars to parse input data (left-to-right design) or a
structure approach to build programs that model the structure of the output data
(right-to-left design). A total of 12 design methods are presented, along with
their strengths and weaknesses. Although Plauger's design methods categorization
technique is somewhat artificial, the book's value is in no way diluted since
all methods are put into a context of guiding you using analogies and advice.

Apart from his survey of software design methods, Plauger provides some
interesting nuggets such as three essays on demystifying object-oriented
programming (a novel trend when the essays were written), some ideas on software
development that could seem to be counterintuitive ("software design heresies,"
as Plauger calls them), and a curious approach to teaching software engineering
that could be an eye-opener for many instructors.

A couple of chapters with interesting references to further reading and
Plauger's view on landmark software design publications complete this superb
book. Programming on Purpose is a must have book for anyone involved in
professional software development.

Davis has collected an interesting set of his previous essays on relevant issues for the software practitioner. He has appended a few questions at the end of each essay. That is all there is about actual debates in this book. The questions might stir debates in a classroom setting, or simply make you position yourself from a different point of view. This collection of essays is worth a look.

Funnily, a recurring theme in some essays is the use (and abuse) of software tools and techniques. The software development community has lived through many "silver bullets," which tend to be temporary fads. Oversold techniques are often easy to follow and misuse, because if they fail, they can be blamed, and our own egos are therefore protected. Unfortunately, that makes us look like lemmings (one of Davis' landmark essays). Throughout the book, you will be reminded that there are proven techniques that work, and produce moderate gains. Even "silver bullets" are good when properly used, obviously.

Management topics are covered in a whole section of the book. The author, a manager himself, describes the hard knocks that rookie managers suffer, and their most common mistakes, and even notes that a good manager has to disobey orders sometimes. As an entrepreneur, the author shares the lessons he learned at his own startup, as well as Ed Bersoff's lessons learned at BTG, providing an invaluable retrospective for those who aim to create a new company.

Another section of the book addresses requirements, one of the author's pet topics. He makes it clear that requirements have to do with understanding, not just with documentation. Requirements describe the external view of a system (namely, its phenotype), hence its object-oriented analysis limitations, as detailed in one of the essays. Some of the other essays in this section provide a good overview of the complete analysis phase, emphasizing requirements elicitation, triage, and volatility (as well as its inherent impact on estimation).

As someone who has worked in the industry, and also at universities, the author devotes another set of essays to technology transfer. The gap between researchers and practitioners is discussed, a gap that, surprisingly, exists in requirements engineering, where engineers are supposed to be able to understand their users' needs. As any good analyst would do, the author dissects the academic system, and highlights the severe limitations of the current educational model, where instructors usually don't have real-life experience in the topics they are supposed to teach, and incentives usually interfere with the ability to obtain practical research results.

Some personal recollections from the author complete the miscellaneous set of essays in the book. Since it could not be any other way, the perennial question about software development as an art or as engineering also crops up; a funny essay written by Jim Sanders highlights the parallels between writing music and writing software.

Even though most of the essays in this book are not new, they are as relevant today as they were when they were originally published. Two-thirds of the essays in this book will be familiar to IEEE Software readers, because they are rehashed from this bimonthly magazine (this fact should come as no surprise, since Davis is the former editor in chief). Despite this apparent lack of novelty, the topics covered by these essays deserve to be revisited with the benefit of hindsight, given that the current situation is not much different from what it was a few years ago. Moreover, the few essays that haven't been published before, and those that are harder to find, are valuable; they round off this excellent book.

This book deserves a place on any software engineer's bookshelf, next to Glass' book [1]. Like that book, this one will "make you think about the things you might have been taking for granted." At least, it will make you keep your brain in gear, an essential quality for software engineers settled into their daily routines.

If you think you are already acquainted with Davis' recommendations, let his common sense and sagacity become widely known and passed on. Get a copy of this book for your manager if you are a developer, for your boss if you are a manager, or for your partners if you are an entrepreneur. I did.

Networks have always been relevant to computer scientists, since graphs provide a nice mathematical model to represent relationships of any kind. However, until the publication of some significant network models around the turn of the century [1,2], they were not in the spotlight in scientific domains other than social networks and mathematical graph theory. The early models spurred the development of the study of networks as an interdisciplinary field, with myriad applications in computer science, sociology, economics, physics, biology, and many other realms of scientific endeavor.

Until recently, in order to get an idea of the state of the art in the field of networks, scientists and researchers had to wade through journal papers, resort to some published surveys, and peruse major paper collections [3]; more general overviews were only available from popular science titles [4,5]. Fortunately, several recent textbooks have tried to organize what is currently known about networks and their structure and behavior, from different points of view [6,7,8]. Newman adds a new perspective--that of a physicist with a keen eye on networks--to this collection of textbooks.

Newman’s book consists of five parts of increasing complexity, from an informative description of different types of networks to the study of dynamic processes on networks. His writing style is engaging, witty, clear, and instructive--and mathematically rigorous when needed--without being condescending. The book starts with a survey of the most relevant kinds of technological, social, information, and biological networks, as well as the empirical techniques used to discover their structures.

The second part of the book focuses on network theory in general, beyond particular application domains. It provides the fundamental mathematical tools needed for the scientific study of networks, along with a nice introduction to graph theory and a thorough survey of the measures and metrics employed to characterize networks. This part ends with a chapter on the large-scale structure of networks, including their connectivity, shortest paths, degree distributions, and clustering coefficients.

Algorithms for networks are discussed in the next part. After an introductory chapter on data structures and algorithmic complexity for non-computer scientists, Part 3 complements Part 2 by providing efficient algorithmic solutions for computing some of the most common network features: clustering coefficients, shortest paths, and maximum flows/minimum costs. It also analyzes matrix algorithms for computing matrix eigenvalues and eigenvectors--which are needed for some centrality metrics--and discusses the problem of graph partitioning and community detection in networks.

Part 4 is the most mathematically demanding, since it deals with theoretical network models. Its pages are devoted to the study of random graphs, different models of network formation, and other relevant network models. Starting from classic results attributed to Erdős and Rényi, Newman analyzes and proves the formal properties of random graphs with arbitrary degree distributions (such as the configuration model), preferential attachment models (such as the Barabási-Albert model), vertex copying models, network optimization models, and exponential random graphs. Beyond the mathematical proofs and the formal study of particular models--which may not always correspond to what is found in practice--the reader gets a general understanding of network properties and what might lie behind them. For example, in Section 13.3, “Excess Degree Distributions,” readers will discover that, in general, “your friends have more friends than you do.”

The last part of the book turns attention toward processes on networks. Although still in its infancy as a research area, some interesting results are discussed. For instance, Newman discusses what happens when nodes are removed--a process that physicists refer to as “percolation.” This process has severe implications concerning network resilience, and has application as a model for the effects of vaccination. The related issue of epidemics is also studied, by applying classical epidemiological models on networks in order to analyze the spread of diseases, fads, and ideas. The last couple of chapters provide a general overview of stability analysis, synchronization, search, and message passing on networks.

Overall, this is an excellent textbook for the growing field of networks. It is cleverly written and suitable as both an introduction for undergraduate students (particularly Parts 1 to 3) and as a roadmap for graduate students. Furthermore, its more than 300 bibliographic references will guide readers who are interested in particular topics. Being highly self-contained, computer scientists and professionals from other fields can also use the book--in fact, the author himself is a physicist. In short, this book is a delight for the inquisitive mind.

Loosely defined, “multiagent systems are those systems that include multiple autonomous entities with either diverging information or diverging interests, or both.” Obviously, this definition is broad enough to cover a wide variety of real-world systems, from different kinds of complex networks to interactions among human individuals and organizations. In fact, many of the ideas discussed in this book apply to situations that have nothing to do with multiagent systems, commonly viewed as the modern approach to artificial intelligence (AI).

This thorough textbook on multiagent systems mainly focuses on game theory. Written from a computer scientist’s perspective, this book surveys many of the game-theoretic ideas that have been developed since the Second World War, when von Neumann and Morgenstern’s landmark book [1] created the interdisciplinary field of game theory. Game theory, as a branch of applied mathematics, is typically associated with economics and other social sciences. However, as the study of the interaction among independent agents, its strong connections to multiagent systems is self-evident, so a textbook on game theory from a computer scientist’s perspective is more than welcome.

Most of the book is devoted to game-theoretic concepts. Many chapters study competition among agents or noncooperative game theory, while coalitional game theory is addressed in a separate chapter. In these chapters, readers will find the most important topics in game theory, as well as the essential mathematics behind them and some detailed proofs. Apart from the mathematical proof that every game with a finite number of players and action profiles has at least one Nash equilibrium--a result that gave Nash a Nobel Prize in economics and was, let’s say, freely interpreted in the Hollywood blockbuster A Beautiful Mind--you will also find discussions on the computational complexity of computing solution concepts of normal-form and extensive-form games. A variety of other game representations are also reviewed.

Another group of chapters is devoted to “protocols for groups,” a term used by the authors to refer to social choice. From the designer’s perspective, these chapters analyze what rules should be put in place by the designer orchestrating a set of agents. These rules include voting schemes and ranking systems. Mechanism design, as “an exercise in incentive engineering,” is the strategic version of social choice theory. Its better-known application, auctions, also deserves its own chapter, since it is directly related to multiagent resource allocation.

A few chapters address other important topics in multiagent systems, from coordination and communication to learning. The coordination chapters deal with distributed problem solving, focusing on constraint satisfaction (for example, using asynchronous backtracking) and optimization (for example, distributed dynamic programming and learning real-time A*). The short communication chapter discusses when talk precedes action (cheap talk and speech-act theory) and when actions speak louder than words (that is, talking by doing--signaling games as games of asymmetric information). Finally, the chapter on multiagent learning also approaches the topic from a game-theoretic perspective, and is based on an AI paper written by Shoham and other collaborators [2].

The book ends with a couple of chapters on logical theories, which will interest those who work on multiagent systems, and a few short technical appendices. The chapters on logic explore modal logics and beyond. Modal logics qualify the truth of a judgment by means of unary modal operators. The authors also study how knowledge and belief statements change over time (belief dynamics) and how to formalize the notion of goals and intentions. The brief technical appendices provide quick refreshers on probability, linear/integer programming, Markov decision problems, and classical logic--subjects that are needed to understand the rest of the book.

The authors’ style is quite formal, since the textbook is mainly addressed to graduate students and researchers. Although Shoham and Leyton-Brown often refer to their chapters as crash courses, casual readers should not start their inroads into game theory by reading this book. Later, they can refer to this rigorous textbook, if they want to plow through the mathematical details.

The history of ideas deals with the proposal, rebuttal, and evolution of ideas over time. This is always a fascinating topic, as it makes us aware of many of our underlying assumptions, suggests alternatives we might not have considered, and makes us reflect upon the trends and controversies that shape the history of a research field. The field of artificial intelligence (AI) is particularly relevant, due to the multitude of distinct ideas that have been devised, borrowed from other fields, adapted, combined, and often discarded, but also adopted to build many practical systems now in use. Now that the field has been with us for the last 50 years or so, we are offered the opportunity to read a roughly chronological account of its evolution, from the perspective of one of its pioneers.

Nilsson considers intelligence to be “that quality that enables an entity to function appropriately and with foresight in its environment.” Throughout his historical account, he surveys many of the major milestones that have led AI to its current state, from the often-unsuccessful trials of people who were ahead of their time and its modest origins in related disciplines. Logic, statistics, philosophy, psychological theories, what we now call neuroscience, and engineering all contributed to the early experiments that led to the first AI systems built at sites such as Stanford University, the Massachusetts Institute of Technology (MIT), and Carnegie Mellon University (CMU), in the 1950s and 1960s.

Those early efforts led to robotic systems such as Shakey. Nilsson’s first-hand recollection of it is certainly enjoyable. At its time, Shakey was “the first robot system having the abilities to plan, reason, and learn; to perceive its environment using vision...[;] and to monitor the execution of its plans.” Many ideas now familiar to computer scientists, such as the A* heuristic search procedure or the STRIPS planner, were originally proposed by Nilsson and his collaborators during the late 1960s and the early 1970s. Many knowledge representation techniques, such as scripts and frames, are from the same period (semantic networks were proposed earlier).

During the following decade, research led to the development of many perceptual systems that allowed machines to interact more like humans. Some noteworthy computer vision algorithms and many natural language processing techniques fall within this category. Speech recognition systems, for instance, also introduced an assorted toolbox that would later be used in many other contexts, from hidden Markov models to blackboard architectures. Work on knowledge representation, on the other hand, led to the flourishing of expert systems during the 1980s, whose techniques are at the heart of modern business rules engines.

Significant success toward the goal of making a machine behave in ways that would be called intelligent if a human behaved so also led to overly optimistic predictions. This caused an expectations management problem that finally led to the “AI winter,” as Nilsson puts it. Apart from mentioning the funding and political issues that influenced the development of AI research projects, Nilsson complements his chronological account with a proper discussion of the “controversies that were simmering on the sidelines and within the field itself.”

Good-old-fashioned AI ultimately led to the development of new paradigms, whose growth led to the now-fragmented AI subfield, from machine learning and data mining, to knowledge engineering techniques, computer vision systems, and the statistical natural language processing techniques currently in vogue. We have already witnessed some extraordinary achievements, from world-champion-level game-playing machines, to autonomous robots and driverless automobiles. Nilsson comments on challenging problems that AI techniques have recently helped solve, and then goes on to predict what AI programs might still do. Even though he modestly acknowledges that “more accomplished historians ... have wisely avoided writing accounts that get too close to the present,” Nilsson is bold enough to predict and even advocate for the appearance of human-level AI during the current century.

Apart from the fact that one might find the final human-level AI issue too debatable to be included in a historical retrospective such as this, Nilsson provides an otherwise balanced look at what AI has been able to do during its first 50 years of existence. His personal recollections and the rationale behind many decisions, as retold by an insider, make this book a unique contribution, interesting both for the informed and for the general reader. Both kinds of readers can learn a lot from Nilsson’s book about the evolution of this now-mature research field. The book is written in a friendly conversational style, without any unnecessary mathematical formalisms, and is richly illustrated with many diagrams that depict representative AI systems and photographs of the many innovators that led to their development.

Fernando Berzalfberzal@gmail.com05211229374https://sites.google.com/feeds/content/ikor.org/www/21007450780832323032011-09-15T21:50:11.219Z2016-07-19T01:25:53.925Z2011-10-01T16:35:10.962ZNetworks, Crowds, and Markets: Reasoning about a Highly Connected World

As complex systems made of individual nodes connected by links, networks are behind many natural and artificial phenomena. So, it comes as no surprise that scientists from different disciplines try to understand how connected systems work. This book is a recent addition to the growing collection of recent textbooks that deal with networks [1,2,3], with substantial overlap among them. While these others try to understand networks by mainly focusing on the mathematical [1], algorithmic [2], or game-theoretic [3] aspects of existing models, Easley and Kleinberg survey the field with a strong emphasis on connecting models to real-world situations. This is partially due to the book’s origin: an undergraduate course at Cornell University. Hence, mathematical details have been stripped away, whenever possible, and algorithmic considerations are almost missing.

It is, however, an excellent introductory textbook. The 24 chapters are organized into seven blocks that correspond to its central themes. Most chapters include optional sections at the end, with advanced material that would not typically be taught in a standard undergraduate one-semester course. They also include lists of exercises, most of which are quite mechanical, intended to acquaint students with the material covered in each chapter (generally, you can find more demanding problems and open questions in Newman’s book [1]).

After the usual introductory overview chapter, the first block of chapters starts the study of network structure by introducing graph theory and some key topics related to social networks. An easy-to-understand nontechnical introduction to graph theory is followed by a nice treatment of strong and weak ties in social networks, key structural metrics (such as clustering coefficient and betweenness), external factors that affect link formation (such as homophily and affiliation), and the stability of positive and negative relationships (structural balance).

The second part of the book introduces game theory as a key tool to model interdependence in the behavior of individuals. Like the rest of the book, it is written clearly and provides many intuitive examples that highlight the key issues discussed in each section. Modeling traffic through a network and auctions are discussed as two interesting applications of game theory that sometimes lead to counterintuitive conclusions (for example, Braess’ paradox, which states that adding capacity to a network can sometimes slow down the traffic).

A third block of chapters combines the material from the previous two, from an economic point of view. A preliminary chapter on matching markets sets the stage; without taking network structure into account, it focuses on optimal assignments and market-clearing prices. Later, trading networks--markets with intermediaries--and network exchange theory receive their deserved share of attention, as they model the natural convergence of network structure (graphs) and strategic interaction (games).

The fourth part of the book changes its application domain. This time, the focus of study is information networks and the World Wide Web (WWW). In less than 100 pages, readers learn about the bow-tie structure of the Web, the link analysis algorithms used in Web searches (such as Kleinberg’s HITS algorithms and Google’s PageRank), and the sponsored search markets at the heart of keyword-based advertising.

The fifth and sixth blocks of chapters turn their attention to network dynamics. They study situations in which a person’s behavior and decisions depend on other individuals’ choices. First, they are studied for their aggregate effects, such as information cascades and the rich-get-richer phenomena. For instance, readers will learn that the so-called “wisdom of crowds” does not always produce accurate results, due to network effects. The second set of chapters on network dynamics analyzes how individuals are influenced by their neighbors. Taking a closer look at the fine structure of the network, readers can study social contagion as a rational decision-making process (with the help of threshold models) and epidemics as a probabilistic random process (with the help of standard SIR/SIS models). The small-world phenomenon is also studied in its own chapter, due to its importance for finding short paths and performing decentralized searches.

The final set of chapters deals with key societal institutions. They are not typical network topics, but they are often taught in multiagent systems courses [4]. However, their importance is clear when you take into account how their design can produce different forms of aggregate behavior in connected systems. In particular, the authors discuss the ways in which markets serve to aggregate individual beliefs (information asymmetry in markets), how to reach a single decision (voting mechanisms), and how to allocate resources (property rights).

This unusual range of topics is what makes this book invaluable. Instead of just focusing on abstract mathematical models and their formal properties, it puts models in their proper place within a process that begins with empirical observations, leads to mathematical models, is followed by some predictions, and is then subject to experimental validation that starts the cycle anew. In the meantime, one reasons about the connected world around us, discovers some facts, gets some insight into the behavior of complex systems, and even enjoys some “aha!” moments. The book is a pleasure to read.

Yourdon, Statemate, and the UML

The application of well-known specification techniques to reactive systems is the focus of this book. A reactive system is "a system that, when switched on, is able to create desirable effects in its environment by responding to events." This perspective is not restricted to classical control systems (called directive systems in the book), but is also useful in a broader spectrum of information systems. In fact, this book's approach fits event-driven programming environments perfectly. Such environments are commonly used to develop modern graphical user interfaces.

While traditional transformation systems manifest a predetermined stateless behavior, and analysis of these is focused on how inputs are deterministically transformed into outputs, reactive systems are state-based, and exhibit a dynamic stimulus-response behavior. Basically, the reactive system under development (SUD) interacts with its environment by exchanging messages. Events in the environment arrive as stimuli to the SUD, and system responses are converted into actions in the environment. One of the recurring themes in the book, which is highlighted by the system engineering argument, is the importance of the environment. The argument states that the assumptions about the environment, plus the design specification, determine the properties of the resulting system, once the SUD is introduced. As a consequence, Wieringa advocates a more thorough environment specification than is usually done.

Wieringa focuses on specification techniques, describing their notations, explaining their semantic details, and offering some guidelines for their correct use. These techniques are arranged into four groups:

Function notations are useful for reaching an agreement with the customer, and are, therefore, best written in the customer's language (plain English).

Entity notations describe the subject domain, and are entity-relationship diagrams, complemented by a dictionary of key terms.

Behavior notations focus on the transformation of stimuli into responses, with accompanying state changes in the SUD.

Communication notations are focused on the information exchange between systems, and complement the view offered by behavior notations.

Once these types of notations are thoroughly surveyed, Wieringa wraps up the discussion of specification techniques with a chapter devoted to requirements-level system architectures, similar in spirit to the Object Management Group's model-driven architecture approach.

In the final part of the book, three different specification methodologies are described to illustrate how they combine different notations. Those methodologies are postmodern structured analysis (a Yourdon-style variant of structured analysis), Harel et al.'s Statemate, and a subset of the unified modeling language (UML), where the author introduces communication diagrams to ensure coherence between static structure diagrams (object and class diagrams) and behavior descriptions (statecharts).

Finally, in the last chapter, Wieringa presents "not yet another method" (NYAM), "the gist of existing methods," where he acknowledges that there is no silver bullet, and no single recipe for all specification problems. In fact, not all notations need to be used for all systems. The proper choice depends on the SUD functionality, and the notation's intended use (from informal prototypes to formal model checking).

In short, the author does his best to cover a wide range of specification techniques, and offers valuable insight into their underpinnings, complementing his discussions with case studies, exercises, and an uncommonly well-written glossary. The origins and rationale behind some of Wieringa's ideas can be found in the bibliographic remarks, along with some gems in the bibliography that deserve further reading.

The major shortcoming I found in this book was in its deviation from terminology and notation standards. For example, the author dismisses common terms, such as use cases or nonfunctional requirements, because of their possible connotations. In the first case, he prefers to use the term "service," although his focus on delivered value is akin to Constantine's essential use cases [1]. With respect to nonfunctional requirements, which have "the connotation that whether this property is present cannot be objectively decided" (p. 44), Wieringa misses the opportunity to use the goal analysis technique, which Gilb advocates [2], and about which it is clearly stated in this book that "all critical attributes can be specified in measurable testable terms."

Wieringa introduces his own share of new notations and variants (even the overly complex UML is somewhat expanded). We do not need more new models and notations, however; we certainly need better tools, and more practitioners to effectively apply known techniques [3]. With regard to this need, Wieringa's book is of value for practitioners, and food for thought for thinkers in general, and researchers in particular. If you want to fully understand the details of, and parallelisms between, specification notations, Wieringa is one of the best places to start.

An introduction to object-oriented analysis and design and iterative development

Software development books tend to focus on the details of the particular techniques they address, which makes it easy to forget the big picture. Typical books address each topic as if it belonged to a separate world. This book, in contrast, demonstrates how many different techniques and practices nicely fit together in the software development process.

This book is outstanding because of its peculiar organization. The book unfolds as an actual software project (two parallel projects, actually). The two case studies weave together the concepts covered, which are introduced at the points of the projects when they are most useful, lowering the learning curve. From a pedagogical point of view, the recurring use of the same case studies throughout the book is much better than devising unrelated examples for each topic covered (in spite of the typical, well-understood, fairly unimaginative, and, to some extent, boring point of sale (POS) system). Even though you may find this technique repetitious at times, since it often returns to the same underlying concepts to reinforce explained ideas, every experienced instructor uses this basic teaching technique. In any case, the projects follow an iterative process, so the book just reflects what actually happens in practice.

With respect to the book's contents, Larman demystifies the unified process. He focuses on its inception and elaboration phases, where most of the analysis and design work is done. Even though the book title focuses on unified modeling language (UML) and patterns, the books goes far beyond the use of UML diagrams to communicate ideas, and Gang of Four (GoF) [1] design patterns to codify design best practices. Fortunately, the misleading title may attract the people who can benefit most from the contents of the book, namely, those developers who want to expand their development skills. Larman also addresses analysis techniques, such as use case modeling [2], which are wrongly identified as "object-oriented analysis," when there is nothing object-oriented about them [3]. It is a stretch these days to talk about "object-oriented analysis."

The book mainly focuses on object-oriented design and its underlying principles, which are presented as "general responsibility assignment software principles." These are no more than general heuristics on how responsibilities should be assigned to software classes. Their discussion is noteworthy, but is also harder to understand for novice designers, because it requires a higher abstraction capability, a priceless ability for any self-respecting practitioner. Larman does a great job of introducing basic concepts and patterns, while demonstrating how to use UML to our advantage.

Apart from its in-depth coverage of object-oriented design, the book also presents other techniques that are useful in software development. These include the functionality-usability-reliability-performance-supportability (FURPS+) requirements categorization system; use cases, à la Cockburn; and the application of design by contract ideas, during the early phases of the project, by means of operation contracts. Larman also covers layered architectures, package design guidelines, and the N+1 view model for describing "the big ideas of the system." Some readers may feel that their pet techniques deserve a more in-depth treatment, which is virtually impossible if we take into account the broad scope of the book. For those interested in the details, Larman provides pointers to more information.

In summary, this is probably the best book I have seen on object-oriented design at the introductory level. Although it requires previous object-oriented programming knowledge (preferably in Java), it is easy to follow. The book is an ideal choice for self-learning, because it provides insight beyond the "how" of techniques, and explains the "why" behind them. Use it as a starting point, before attempting to fully understand more expert-oriented titles, if you are relatively new to object orientation. Use it as a refresher, to see how everything fits together, if you are more experienced.

Natural language processing (NLP) is a broad and interesting field of research at the intersection of computer science (CS) and linguistics. It includes many varied practical applications that range from information extraction algorithms that help us improve the performance of traditional information retrieval systems, to speech recognition techniques that are essential for verbal human-computer interaction (HCI).

Jurafsky and Martin’s book is a comprehensive introduction to NLP. The first edition--published in 2000--is an accepted classic in the field. This updated edition covers many recent advances and provides a good perspective on the current state of the art.

Covering a wide range of topics, the book’s ambitious scope addresses language processing at different levels, including phonetics, morphology, syntax, semantics, and even discourse. Obviously, such a broad scope forces the authors to provide just the essential information on a particular topic--something at which they are certainly successful--while precluding a more detailed treatment of each subject.

This lengthy but concise textbook starts with a brief introduction to the field that includes relevant historical notes on computational linguistics, NLP, and speech recognition. The book is divided into five parts: “Words,” “Speech,” “Syntax,” “Semantics and Pragmatics,” and “Applications.” It presents most of what one might want to know to become acquainted to the field and be able to make informed decisions on related issues.

The authors’ writing style is fluid and clear. In their readable discussions, they combine formal discussions on the underlying theoretical models with references to many application domains and good descriptions of the kinds of problems one must solve in practice. While this is an extremely informative book, it’s not the how-to, implementation-oriented type of book some practitioners prefer. The book provides concise algorithm descriptions, useful references to online resources, and discussions of tricky issues. It even proposes many interesting mini-project exercises at the end of each chapter, although it does not provide complete recipes.

Each chapter ends with a “Bibliographical and Historical Notes” section that describes how the field has evolved and includes an extensive list of references. Many of the chapters also include sections on how we, as humans, perform many of the processes involved in NLP. These sections describe the experiments that psychologists have performed to confirm or refute hypotheses related to morphological processing, parsing, speech recognition, and the complexity of natural languages. When describing different algorithmic techniques, the authors also provide short sections that detail the standard evaluation methods that are typically employed to measure the performance of language processing algorithms.

Since most tasks in speech and language processing involve some kind of ambiguity that is hard to predict in advance--due, for example, to the presence of unknown words, repair utterances, or coreferences--many ambiguity resolution techniques employ artificial intelligence models and algorithms. The chapters on semantics present a good overview of knowledge representation techniques, from first-order logic to ontologies and frame-based representations, as well as countless references to machine learning techniques that are required to solve multiple classification problems that arise in language processing and understanding. In fact, the current approach to NLP is often based on statistical learning methods, where hidden Markov models play a key role.

While this textbook is appropriate for both advanced undergraduate and graduate students, it’s more suitable for the latter. The material is not intrinsically difficult, and the authors have made a worthwhile effort to make the book readable for interested readers who have a CS background. However, when reading this textbook, undergraduate students will find many references to unfamiliar topics. To make the most of their time, readers should have a good background in automata theory and machine learning. Although readers without such a background might get confused at times, the book provides an excellent overview of the complex issues that must be resolved when engineering speech recognition and NLP systems. This book is perfect for practicing professionals who are interested in language processing problems, but it might not be the ideal choice for readers with interests that focus more on speech recognition and synthesis.

Fundamental and Frequently Forgotten

As Robert L. Glass points out in his introduction, and his book title
suggests, this book is built around "a laundry list of facts and fallacies about
building software". But there is something special in that laundry list: it
tries to collect what we ought to know about software development but we
frequently forget to remember, as well as some beliefs we give for granted
although they are, at least, misleading (just plain wrong for Mr. Glass).

Given its topic, it is not surprising that the book original title was
"Fifty-Five Frequently Forgotten Fundamental Facts (and a Few Fallacies)
about Software Engineering", alias the F-Book. Somehow, the book title was
shortened for marketing reasons and it lost the emphasis it put on the
importance of the topics discussed.

The book is clearly written and easy to read, full of wisdom and with some
doses of wit, just as the columns "Bob" Glass periodically writes for
Communications of the ACM and IEEE Software. Moreover, the facts it examines are
essential to software development activities and, although their references
might change, their fundamentals will never be outdated. That makes this book a
great book in comparison to the myriad of computer books which are written about
the hottest topic of the day and whose relevance will not last much longer than
trade magazines.

The facts and fallacies in this book cover the whole software life cycle,
although several underlying themes recur throughout the book, such as the
inherent complexity of software development (remember that software systems are
probably the most complex systems ever built by humans) and the irrational hype
which plagues our field (as exemplified by one-size-fit-alls advocates).

While you will find some classic facts such as "Adding people to a late
project makes it later", as well as discussions of poor estimation and unstable
requirements as the most common causes of project failure, you will also find
some shocking facts and all of them will give you food for thought. Here is a
sample of what I found particularly enlightening:

Since estimates are so faulty, there is little reason to be concerned when
software projects do not meet estimated targets. But everyone is concerned
anyway (Fact 12).

The answer to a feasibility study is almost always "yes" (Fact 14).

Eighty percent of software work is intellectual. A fair amount of it is
creative. Little of it is clerical (Fact 22).

One hundred percent [test] coverage is still far from enough (Fact 33).

Better methods lead to more maintenance, not less (Fact 45), since
"enhancements represent roughly 60 percent of maintenance costs" (Fact 42).

Apart from the 55 facts which are dissected in the first part of the book,
the author has chosen ten common misunderstandings in software engineering.
These fallacies include pearls such as "given enough eyeballs, all bugs are
shallow" (Fallacy 8), "the way to predict future maintenance costs and to make
product replacement decisions is to look at past cost data" (Fallacy 9), and "to
estimate cost and schedule, first estimate lines of code" (Fallacy 6). You will
probably find yourself nodding as you read this part of the book and you will
probably get shocked by some of the ideas you will find in this entertaining
book, if not merely disturbed or plainly annoyed.

Why don't we learn to read program before we try to learn how to write them?
That's the usual way we would learn a new language. Moreover, "60 percent of
software's dollar is spent on maintenance, and 60 percent of that maintenance is
enhancement" (the 60/60 rule) and "understanding the existing product consumes
roughly 30 percent of the total maintenance time."

Some people might the book style somewhat irritating, since its contents are
presented as more or less independent sections. Those sections collect Glass'
wisdom in snippets which include a discussion of a particular fact, the
controversy surrounding the fact, and some pointers to further reading. Although
academics might prefer an alphabetical listing of hundreds of references, I have
particularly enjoyed the short annotated bibliographic entries which are
scattered throughout the book, in spite of the duplications which unavoidably
appear when a particular reference is cited in several places. Somehow, almost
every classic reference has its place in the F-Book.

This book is an invaluable resource for those people preparing to be software
engineers in the future and also for those practitioners which want to refresh
what they ought to know or just to reinforce what they believe in spite of
existing controversies (mostly from "hypesters"). Since the book covers topics
which are usually controversial, this book will also give you arguments for the
next time you will find yourself trying to refrain your team of doing things the
wrong way. If you love software development, you'll love this book. Enjoy it!

Without a doubt, this book should be on the short list of indispensable computer science textbooks, along with other classics such as “the dragon book” [1] and Hennessy and Patterson’s computer architecture textbook [2]. Having been let down by the poor Spanish translation of a previous edition that I used in my undergraduate student years, I approached this new edition with the hope of rediscovering a beautifully crafted textbook. I was not disappointed.

This hefty volume contains more than 1,100 pages of information. It is divided into 27 manageable chapters, “each requiring about a week’s worth of lectures.” Detailed bibliographical and historical notes complement its clear explanations and lucid discussions. There are literally thousands of references to virtually every relevant work that has been published in the artificial intelligence (AI) field since the term was coined in 1956.

Like most good stories, this textbook exhibits a circular plot structure. It starts and ends with general issues that surround AI. The first chapters introduce some definitions that have been proposed for AI, as well as its foundations and its historical roots, while the final chapters address ethical and philosophical issues, the state of the art, and future prospects. Russell and Norvig describe AI as the science of agent design--a wide definition that easily accommodates the myriad of techniques that enable computers to mimic humans. Apart from the introductory and final chapters (Parts 1 and 7), the core of the book is divided into five main parts that provide a thorough overview of the current state of the AI field.

Part 2 is devoted to problem solving as a search activity, from blind uninformed search and heuristic informed search to adversarial search and constraint satisfaction problems, with specific sections on local search, online search, and search on partially observable environments.

Part 3 deals with knowledge representation, reasoning (both propositional and first-order logic), and planning. Part 4 expands on the previous section and addresses uncertain knowledge and reasoning. It includes over 100 pages on probabilistic reasoning and scarcely six pages surveying alternative approaches, such as certainty factors, Dempster-Shafer theory, and fuzzy logic. This part also includes a couple of chapters on decision making that takes into account both beliefs (probability theory) and desires (utility theory).

Part 5, on learning, starts with a general overview of well-known machine learning techniques. It continues with learning methods that take advantage of prior knowledge in order to learn logical theories (“a logical formulation of learning”), learning as a form of uncertain reasoning from observation (that is, learning probabilistic models), and learning what to do in the absence of labeled examples of what to do (that is, reinforcement learning using reward and punishment).

Part 6 addresses what we might call the input/output (I/O) subsystem of intelligent agents, which includes natural language processing, perception (in the form of computer vision), and action (that is, robotics).

Taking into account the vast territory that this textbook explores, it should come as no surprise that most of the techniques are described only at a very high level, without delving into too many technicalities. While the authors seem to have an inclination for probabilistic techniques, most existing techniques are given their fair share of attention. Some readers might miss a favorite pet peeve or a more detailed treatment of the most recent advances in a particular field, but they will probably be able to find the most relevant references for these in the endnotes. Despite some minor disagreements on the topics chosen for a given AI course, nobody can deny the book’s incommensurable value or the praiseworthy effort by the authors to keep it up to date. In addition to these praises, it is finally a comprehensible text for advanced undergraduate students.

As is now common practice with leading textbooks, there is an accompanying Web site (http://aima.cs.berkeley.edu/) that includes many relevant links, reusable slides, and an interesting online code repository.

Networks pervade our lives. As graphs representing interconnected systems, they can represent social interactions, economic relationships, power grids, computer networks, Web links, bibliographic citations, or biochemical processes. Whether the networks are social, economic, technological, or biological, their study has spurred a lot of interest over the past decade or so.

The Web established a market for many popular books on networks. Some of these have been entertaining and informative—for example, Duncan Watts's Six Degrees or Albert-Laszlo Barabasi's Linked. However, they aren’t rigorous enough for more demanding readers. Those wishing to plumb the depths of networks have had to make their way through countless research papers, which necessarily offer a fragmented view of any field. Even worse, network research terminology is often confusing, given the youth of this field and the different specialties contributing to it. Hence, Ted G. Lewis's textbook offering a panoramic view of this emerging research area is welcome.

The Mathematics Behind Network Models

According Lewis, network science reflects the combination of graph theory, control theory, and cross-discipline applications. Calling it a science, however, is probably an overstatement—the kind of hype that has made some people dismiss network research as a passing fad or fabrication, ignoring important lessons this field can teach us.

The subtitle might also be misleading. Lewis has written the book with graduate students in mind, so it's more theory than applications. This is partially justified because Lewis has tried to separate the wheat from the chaff to produce a valuable textbook. In this yet-to-mature field, theoretical models are the wheat while particular applications are usually the chaff. This is because new observations and a better understanding of the studied processes often make research results obsolete in a quite short period of time.

After some introductory material on the historical roots of networks and a brief overview of graph theory, Lewis analyzes some of the most popular network models that researchers have proposed to formulate hypotheses about observed phenomena. These range from Watts-Strogatz small worlds and Barabasi-Albert scale-free networks to flow, influence, and netgain networks.

Traditional graph theory has typically focused on network static properties, which Lewis also uses to study different network classes. However, modern network models focus on the dynamic behavior of interconnected systems. Lewis concentrates on four network properties:

emergence — the process whereby a macroscale (global) property emerges as a consequence of the repeated application of microscale (local) modifications.

epidemics — the propagation of a signal (for example, contagion) through a network.

synchrony/stability — the synchronization/stabilization of network nodes under changing conditions, which includes the study of conflicts and group consensus in influence networks, for example.

vulnerability — the potential impact of node and link failures (for example, in the power grid), as well as the protection of the stability in Kirchhoff (flow) networks.

The final chapters turn to economics and biology as promising application domains for network theory. Lewis posits that netgain networks might be useful models for investigating how economic markets behave, that while biological network models show promise as research tools.

Style pros and cons

Lewis has made an extraordinary effort to provide a first textbook in this fascinating field. However, being first also has some disadvantages. Apart from typos that might be unavoidable in a first edition, especially if publishers want to cut proofreading and editing costs, I found some explanations more convoluted than necessary, even misleading at times. For instance, when discussing a classical paper on the Web topology as a directed graph, Web links are mistaken for physical network connections. Web nodes—that is, Web pages—are incorrectly identified as "nodes that send messages such as email" (page 159). Fortunately, such glaring errors are few, but they're unsettling in any textbook because they raise some doubts about its overall rigor and thoroughness.

The text is generally clear, but somewhat wordy and repetitive. The book feels as if it's written from course notes. Some repetition is desirable and even necessary in oral presentation, but it isn't as welcome in written form. For instance, the detailed introductions to each chapter almost summarize all the material in the chapter itself, thus virtually removing any pleasant surprise you might find from delving into the details. I find detailed summaries more useful at the end of chapters, rather than the beginning.

Lewis concludes each chapter with some exercises as well as interesting issues—even open research questions—that are "left as an exercise to the reader." He provides some Java software tools that support the exercises. (He even discusses some code snippets in the text—something I thought often distracted from the main discussion.) The software tools are invaluable for readers to experiment on their own, because many network issues can only be resolved through computer simulations followed by some curve fitting. All in all, I would recommend Lewis's textbook for graduate students and professionals with a keen interest in network models. Those with a more general interest might start with the popular books, then proceed with this book for a more thorough study. Despite its theoretical slant, casual readers can easily skip the mathematics and still glean much from this book.

-- Fernando Berzal is a member of the IEEE Computer Society and a senior member of the ACM. Contact him at berzal@acm.org.

Fernando Berzalfberzal@gmail.com04703318877https://sites.google.com/feeds/content/ikor.org/www/61772686079626900252011-10-01T10:01:35.684Z2016-07-19T01:25:50.533Z2011-10-01T16:39:13.960ZAnalyzing Social Media Networks with NodeXL: Insights from a Connected World

For the last dozen years, networks have attracted the attention of many researchers and practitioners. Some simple network models [1,2] have achieved significant popularity beyond Andy Warhol’s 15 minutes of fame. Such models have spurred the development of a whole new field of research that combines graph theory, computer science, economics, and other social sciences. The generated momentum has led to the recent publication of some outstanding textbooks on networks [3,4,5].

More than a classical textbook, this book is a well-written educational handbook that describes how we can apply part of the so-called science of networks to the analysis of medium-size networks. The authors impose the size constraint because of the book’s reliance on visual inspection and interactive visualization techniques (sometimes referred to as visual analytics). Since the available space on a screen is severely limited, one cannot expect to analyze a billion-node network using the tool described in this book.

The book also provides a nice overview of the field of social media networks. (Social media corresponds to Web 2.0 technologies.)

A surprising feature of this book, especially when compared with its more formal counterparts, is that the authors avoid any kind of mathematical formalization of the topics they discuss. They seem to have followed Stephen Hawking’s advice: “Someone told me that each equation I included in the book would halve the sales” [6]. In fact, many readers will be grateful to learn that the authors do not include a single mathematical equation, not even to define important network metrics from an intuitive point of view. (Stephen Hawking did include a single equation: Einstein’s famous E=mc2.) However, some chapters include “Advanced Topics” sidebars that describe how to get the most out of Excel when using the NodeXL tool.

NodeXL is a social network analysis open-source plug-in for Excel 2007/2010. It lowers the barrier of entry that is typical of many other network analysis tools; anyone with some experience using spreadsheets can use it. NodeXL computes some of the best-known network metrics, and, with the help of some Excel features, makes network filtering and visualization a breeze. It also implements different network layout algorithms and clustering techniques to discover natural groups of nodes within a complex network. The book only mentions one clustering technique, but more alternatives are available by downloading the latest version of the software from the NodeXL homepage (http://nodexl.codeplex.com/).

The introductory part of the book goes through some of the history and core concepts of social media and social network analysis, always with an eye to social network visualization and for a general audience--it omits technical details. Later, it proposes a framework for categorizing different collaboration technologies and describes 11 categories as examples.

The second part of the book features a variety of tool details. It presents an eight-hour tutorial that surveys NodeXL’s main features.

The bulk of the book, however, is the third part, which contains eight chapters on as many different case studies. These chapters, which are often by international researchers on social media, focus on different kinds of social networks and follow a more or less standard structure. They cover email, threaded communications, Twitter, Facebook, organizational World Wide Web (WWW) networks, Flickr, YouTube, and wikis.

The chapters describe the particularities of each technology and present information on the types of networks one can analyze, from Facebook ego networks to the interplay between content and community networks on Flickr or YouTube (that is, the content provided by tag clouds and video networks versus the structure provided by user networks, where you can explore each user’s followers and/or friends). Each chapter concludes with some observations for practitioners, an agenda for researchers, and a good selection of relevant bibliographic references for each case study. Ideally, these analyses should provide some useful insights and a good idea of what types of questions one can ask (and answer using social network analysis) about individuals, groups, temporal evolution, and structural patterns in social media networks.

In summary, Hansen, Shneiderman, and Smith, along with their collaborators, have written a readable introduction to the field of social media network analysis. Furthermore, the book is a nice tutorial on an interesting tool that readers can experiment with on their own. For example, the readers can simply use the Facebook application provided by Bernie Hogan, one of the book’s collaborators, to analyze the ego networks that they know best: their own network of friends, family, and acquaintances. This book offers a sure way to understand some of the basic concepts of network analysis.

A new language... for talking about proper designs

In software development, reuse is The Holy Grail. Reusing existing software
artifacts is the most cost-effective way to reduce development time and effort.
But code snippets and finished software components are not the only artifacts
which can be reused. I am sure you already reuse your prior development
experience when facing new challenges. This book is just about that. The Gang of
Four (GoF) - as the authors are popularly known - try to record experience in
object-oriented design to help developers improve their programming skills. As
the book preface says...

This book isn't an introduction to object-oriented technology or design.
Many books already do a good job of that. This book... describes simple and
elegant solutions to specific problems in object-oriented software design. ...
Once you understand the design patterns and have had an "Aha!" (and not just a
"Huh?") experience with them, you won't ever think about object-oriented design
in the same way. Design patterns try to capture common design problems and then
they study different solutions and analyze their trade-offs. Their purpose is to
document good designs that solve problems you will certainly find in almost any
serious software development project.

As other software development best practices, design patterns help us develop
more flexible and maintainable software through the use of well-designed
interfaces which encapsulate particular implementations. This book proposes a
modular approach which encourages the use of object composition and delegation
over class inheritance in order to reduce coupling among classes.

The GoF's book is an essential catalog of object-oriented design templates.
Each template or pattern can be used as a starting point to develop new
object-oriented software, and also in the process of refactoring (i.e.
reorganizing and redesigning) existing software systems. Each pattern in this
book abstracts key issues of common design structures, is analyzed in depth and
is labeled with a short name in order to facilitate communication among
developers. Pattern names broaden our technical vocabulary and make easier for
us to discuss possible solutions and their trade-offs.

This book discusses each design pattern in self-contained chapters. Each
chapter labels the design pattern, presents the problem it intends to solve,
describes its solution, and addresses the consequences which could derive from
the use of the design pattern in real systems. Some code snippets (in C++ and
Smalltalk) illustrate the inner details of each pattern and references to known
uses of each pattern are also included, although you will find that you have
probably used most patterns in your best projects.

As stated above, patterns are studied separately, although they are organized
into three main categories:

Creational patterns make a system independent of how its objects are
created, composed, and represented (e.g. object factories).

Structural patterns present ways to organize objects: how classes and
objects are composed to form larger structures (e.g. wrappers, composites, and
proxies).

Last, but nor least, behavioral patterns are concerned with the
assignment of responsibilities among objects (e.g. chains of responsibility,
publisher/subscribers, etc.).

The book organization, its quick index, and its diagrammatic roadmaps make it
a worthwhile reference to keep at hand on your favorite shelf. This -now famous-
book is the flagship publication of a growing community whose interest in
well-designed software complements the traditionally academic focus on software
development techniques and methodologies. Methodologies teach us how to solve
development projects, design patterns show us elegant solutions to those
problems.

Once this book is read, and probably re-read, it acts as a real eye-opener.
As the authors claim, you will never see your designs in the same way. Design patterns are here to stay. Stay tuned!

P.S.: Many of the design patterns which are described in this book are now part of the mainstream programming culture, so you will probably find many design patterns you are already aware of.