With adoptions at over 225 colleges, the first edition was one of the leading C textbooks of the last ten years. The second edition maintains all the book's popular features and brings it up to date with coverage of the C99 standard. The new edition also adds a significant number of exercises and longer programming projects, and includes extensive revisions and updates.

    However, data structures for these languages do not always translate well to functional languages such as Standard ML, Haskell, or Scheme. This book describes data structures from the point of view of functional languages, with examples, and presents design techniques that allow programmers to develop their own functional data structures. The author includes both classical data structures, such as red-black trees and binomial queues, and a host of new data structures developed exclusively for functional languages. All source code is given in Standard ML and Haskell, and most of the programs are easily adaptable to other functional languages. This handy reference for professional programmers working with functional languages can also be used as a tutorial or for self-study.

    This book explains key design decisions, and also details the concepts, data structures, and algorithms used in implementing the system's facilities.

    This author presents a set of patterns that organize all the informal experience successful Smalltalk programmers have learned the hard way. When programmers understand these patterns, they can write much more effective code. The concept of Smalltalk patterns is introduced, and the book explains why they work. Next, the book introduces proven patterns for working with methods, messages, state, collections, classes and formatting. Finally, the book walks through a development example utilizing patterns. For programmers, project managers, teachers and students -- both new and experienced. This book presents a set of patterns that organize all the informal experience of successful Smalltalk programmers. This book will help you understand these patterns, and empower you to write more effective code.

    It describes 11 interpreters and 2 compilers, including very recent techniques of interpretation and compilation. The book is in two parts. The first starts from a simple evaluation function and enriches it with multiple name spaces, continuations and side-effects with commented variants, while at the same time the language used to define these features is reduced to a simple lambda-calculus. Denotational semantics is then naturally introduced. The second part focuses more on implementation techniques and discusses precompilation for fast interpretation: threaded code or bytecode; compilation towards C. Some extensions are also described such as dynamic evaluation, reflection, macros and objects. This will become the new standard reference for people wanting to know more about the Lisp family of languages: how they work, how they are implemented, what their variants are and why such variants exist. The full code is supplied (and also available over the Net). A large bibliography is given as well as a considerable number of exercises. Thus it may also be used by students to accompany second courses on Lisp or Scheme.

    Aimed at the beginner/intermediate C++ programmer who wants to understand the semantic implications of the C++ object model and how the model affects their programs, Inside the C++ Object Model explains where overhead costs reside, and what they actually consist of.

    Beginners will find that its careful explanations and interesting examples make Lisp programming easy to learn. Professional programmers will appreciate its thorough, practical approach.FEATURES:• An up-to-date reference manual for ANSI Common Lisp.• An in-depth look at object-oriented programming. Explains the Common Lisp Object System (CLOS), and also shows how to write your own object-oriented language.• Over 20 substantial examples, including programs for ray-tracing, text generation, pattern-matching, logical inference, generating HTML, sorting and searching, file I/O, compression, and date arithmetic.• Special attention to critical concepts, including prefix syntax, code vs. data, recursion, functional programming, types, implicit pointers, dynamic allocation, closures, macros, class precedence, and generic functions vs. message-passing.• A complete guide to optimization.• The clearest and most thorough explanation of macros in any introductory book.• Examples that illustrate Lisp programming styles, including rapid prototyping, bottom-up programming, object-oriented programming, and embedded languages.• An appendix on debugging, with examples of common errors.

    Thread programming enables developers to design applications that are more responsive to user demands, faster, and more easily controlled. This book offers comprehensive coverage of this vital aspect of the Java language. The book is completely up-to-date with the new thread model that is now incorporated into the most recent version of the Java Virtual Machine. All Java programmers interested in doing concurrent programming must understand these new concepts. The book approaches the topic from a design pattern point of view. It introduces and summarizes Java's concurrency support, shows readers how to initiate, control, and coordinate concurrent activities, and offers numerous recipe-like techniques for designing and implementing Java structures that solve common concurrent programming challenges. Specifically, the book presents important strategies for avoiding the inconsistencies that can crop up in multi-threaded programs, addresses the concept of liveness-how to ensure that all threads in use are kept active simultaneously, examines state-dependent action, and demonstrates effective methods for handling user requests in a multi-threaded environment.

    This book offers insight into object-oriented design improvement. The more than sixty guidelines presented in this book are language-independent and allow you to rate the integrity of a software design.

     It integrates numerous programming examples--750 total--to demonstrate a variety of applications.

    It also describes a number of advanced programming techniques that are largely undocumented in eixisting books. These techniques go beyond the mere mechanics of programming and cover topics such as robustness, seamless integration with the rest of the system, and performance tuning. At the same time, the book does not skip over the fundamentals, so it is accessible to persons who are just getting their feet wet in Mathematica programming.

    This book is both an example-driven programmer's guide and a keep-on-your-desk reference, with new chapters that explain everything you need to know to get the most out of JavaScript, including:Scripted HTTP and Ajax XML processing Client-side graphics using the canvas tag Namespaces in JavaScript--essential when writing complex programs Classes, closures, persistence, Flash, and JavaScript embedded in Java applicationsPart I explains the core JavaScript language in detail. If you are new to JavaScript, it will teach you the language. If you are already a JavaScript programmer, Part I will sharpen your skills and deepen your understanding of the language.Part II explains the scripting environment provided by web browsers, with a focus on DOM scripting with unobtrusive JavaScript. The broad and deep coverage of client-side JavaScript is illustrated with many sophisticated examples that demonstrate how to:Generate a table of contents for an HTML document Display DHTML animations Automate form validation Draw dynamic pie charts Make HTML elements draggable Define keyboard shortcuts for web applications Create Ajax-enabled tool tips Use XPath and XSLT on XML documents loaded with Ajax And much morePart III is a complete reference for core JavaScript. It documents every class, object, constructor, method, function, property, and constant defined by JavaScript 1.5 and ECMAScript Version 3.Part IV is a reference for client-side JavaScript, covering legacy web browser APIs, the standard Level 2 DOM API, and emerging standards such as the XMLHttpRequest object and the canvas tag.More than 300,000 JavaScript programmers around the world have made this their indispensable reference book for building JavaScript applications."A must-have reference for expert JavaScript programmers...well-organized and detailed."-- Brendan Eich, creator of JavaScript

    Unlike some modern object-oriented languages, C provides little linguistic support or motivation for creating reusable application programming interfaces (APIs). While most C programmers use APIs and the libraries that implement them in almost every application they write, relatively few programmers create and disseminate new, widely applicable APIs. C Interfaces and Implementations shows how to create reusable APIs using interface-based design, a language-independent methodology that separates interfaces from their implementations. This methodology is explained by example. The author describes in detail 24 interfaces and their implementations, providing the reader with a thorough understanding of this design approach. Features of C Interfaces and Implementations: * Concise interface descriptions that comprise a reference manual for programmers interested in using the interfaces. * A guided tour of the code that implements each chapters interface tp help those modifying or extending an interface or designing related interfaces. * In-depth focus on algorithm engineering: how to packag

    This book is organized into three parts. Part One: Background introduces the reader to the problems faced by a multitasking operating system. Part Two: Register Set and Real Mode provides an overview of Real Mode operation. Part Three: Protected Mode takes a building-block approach to explaining the protection mechanisms and multitasking capabilities of the post-286 Intel processors, including segmentation, virtual paging, the flat model, and virtual 8086 mode. Protected Mode Software Architecture extends MindShares coverage of x86 processor architecture to the software environment and complements the previously published 80486 System Architecture and Pentium Processor System Architecture (both from Addison-Wesley). If you design or test multitasking operating systems, real-time operating systems, or device drivers for these systems, Protected Mode Software Architecture is an essential, time-saving tool. The PC System Architecture Series is a crisply written and comprehensive set of guides to the most important

    The articles that will appear in this column will focus on the use of C++ and OOD, and will address issues of software engineering. I will strive for articles that are pragmatic and directly useful to the software engineer in the trenches. In these articles I will make use of Booch's and Rumbaugh's new unified notation (Version 0.8) for documenting object oriented designs. The sidebar provides a brief lexicon of this notation.My last column (Jan, 96) talked about the Open-Closed principle. This principle is the foundation for building code that is maintainable and reusable. It states that well designed code can be extended without modification; that in a well designed program new features are added by adding new code, rather than by changing old, already working, code. The primary mechanisms behind the Open-Closed principle are abstraction and polymorphism. In statically typed languages like C++, one of the key mechanisms that supports abstraction and polymorphism is inheritance. It is by using inheritance that we can create derived classes that conform to the abstract polymorphic interfaces defined by pure virtual functions in abstract base classes.What are the design rules that govern this particular use of inheritance? What are the characteristics of the best inheritance hierarchies? What are the traps that will cause us to create hierarchies that do not conform to the Open-Closed principle? These are the questions that this article will address.FUNCTIONS THAT USE POINTERS OR REFERENCES TO BASE CLASSES MUST BE ABLE TO USE OBJECTS OF DERIVED CLASSES WITHOUT KNOWING IT.

    Garbage collection eliminates many of these bugs. This reference presents each of the most important algorithms in detail, often with illustrations of its characteristic features and animations of its use.

    Fully updated and revised, this sixth edition is more than an engaging overview of Java 2 Standard Edition (J2SE 1.5) and its libraries: it's also a practical introduction to today's best enterprise and server-side programming techniques. Just Java(TM) 2, Sixth Edition, reflects both J2SE 1.5 and the latest Tomcat and servlet specifications. Extensive new coverage includes:New chapters on generics and enumerated typesNew coverage of Web services, with practical examples using Google and Amazon Web servicesSimplified interactive I/O with printf()Autoboxing and unboxing of primitive typesStatic imports, foreach loop construct, and other new language features Peter van der Linden delivers expert advice, clear explanations, and crisp sample programs throughout--including dozens new to this edition. Along the way, he introduces:The core language: syntax, objects, interfaces, nested classes, compiler secrets, and much moreKey libraries: date and calendar, pattern matching, network software, mapped I/O, utilities and generic collectionsServer-side technology: network server systems, a complete tiny HTML Web server, and XML in JavaEnterprise J2EE: Sql and JDBC(TM) tutorial, servlets and JSP and much moreClient-side Java: fundamentals of JFC/Swing GUI development, new class data sharing details Companion Web Site All the book's examples and sample programs are available at http: //afu.com.

    It is the only book that teaches the strategies of C++ API development, including interface design, versioning, scripting, and plug-in extensibility. Drawing from the author's experience on large scale, collaborative software projects, the text offers practical techniques of API design that produce robust code for the long term. It presents patterns and practices that provide real value to individual developers as well as organizations.API Design for C++ explores often overlooked issues, both technical and non-technical, contributing to successful design decisions that product high quality, robust, and long-lived APIs. It focuses on various API styles and patterns that will allow you to produce elegant and durable libraries. A discussion on testing strategies concentrates on automated API testing techniques rather than attempting to include end-user application testing techniques such as GUI testing, system testing, or manual testing. Each concept is illustrated with extensive C++ code examples, and fully functional examples and working source code for experimentation are available online.This book will be helpful to new programmers who understand the fundamentals of C++ and who want to advance their design skills, as well as to senior engineers and software architects seeking to gain new expertise to complement their existing talents. Three specific groups of readers are targeted: practicing software engineers and architects, technical managers, and students and educators.

    The articles that will appear in this column will focus on the use of C++ and OOD, and will address issues of software engineering. I will strive for articles that are pragmatic and directly useful to the software engineer in the trenches. In these articles I will make use of Booch's notation for documenting object oriented designs. The sidebar provides a brief lexicon of Booch's notation.There are many heuristics associated with object oriented design. For example, "all member variables should be private", or "global variables should be avoided", or "using run time type identification (RTTI) is dangerous". What is the source of these heuristics? What makes them true? Are they always true? This column investigates the design principle that underlies these heuristics—the open-closed principle.As Ivar Jacobson said: "All systems change during their life cycles. This must be borne in mind when developing systems expected to last longer than the first version." How can we create designs that are stable in the face of change and that will last longer than the first version? Bertrand Meyer gave us guidance as long ago as 1988 when he coined the now famous open-closed principle. To paraphrase him:SOFTWARE ENTITIES (CLASSES, MODULES, FUNCTIONS, ETC.) SHOULD BE OPEN FOR EXTENSION, BUT CLOSED FOR MODIFICATION.

    While it stresses the essentials of software engineering including in-depth coverage of the Capability Maturity Model,CASE,and metrics,it does so using the language Java instead of C++. This text is appropriate for junior,senior,or first-year graduate courses in Software Engineering,Software Analysis and Design,Software Development,Advanced Programming,and Systems Analysis.

    Thus it is more than a guide to the language; it also examines Smalltalk in its technical and historical setting, and along the way addresses the questions that every Smalltalk developer sooner or later naturally wonders about. Assuming nothing more than general programming experience, it begins with what objects and classes are, and eventually progresses to subtle matters such as the distinction between types and classes. Going beyond typical programming language books, it also covers the most important design patterns and how to write them in Smalltalk. The thrust then is not merely programming in Smalltalk with objects, but thinking and designing effectively with objects. This edition is a reprint of the original 1996 edition. Although the intervening years have brought the accustomed rapid changes in the computing industry, the principles presented here remain as relevant now as then. "Three of my favorite topics are Smalltalk, objects, and design. Chamond Liu's book is the perfect blend of these topics. I heartily recommend this book to practitioners who don't want to read a dry treatment on design methodology or yet another programming book. You will be treated to elements of good design, a historical perspective, design patterns demystified and coded in Smalltalk, and just the right mix of Smalltalk programming and object concepts."?Rebecca Wirfs-Brock, author of Designing Object-Oriented Software "Well-written and well-thought-out. . . . The chapter on design patterns especially is first-rate."?Doug Lea, author of Concurrent Programming in Java, and Object-Oriented System Development "One of those rare books that rewards both beginners and experts with insights appropriate to their levels. In addition, the writing style?combining incisiveness and grace?makes it a real pleasure to read."?Dave Collins, author of Designing Object-Oriented

    Partial ContentsChapter 1: What Does It Mean to Be Object-Oriented, Anyway?1.1 Encapsulation1.2 Information/Implementation Hiding1.3 State Retention1.4 Object Identity1.5 Messages1.6 Classes1.7 Inheritance1.8 Polymorphism1.9 GenericityChapter 2: Object-Orientation--Who Ordered That?Chapter 3: The Basic Notation for Classes and MethodsChapter 4: Inheritance and Aggregation DiagramsChapter 5: The Object-Communication DiagramChapter 6: State-Transition DiagramsChapter 7: Additional OODN DiagramsChapter 8: Encapsulation and ConnascenceChapter 9: Domains, Encumbrance, and CohesionChapter 10: Properties of Classes and SubclassesChapter 11: The Perils of Inheritance and PolymorphismChapter 12: Class InterfacesAppendix A: Checklist for an Object-Oriented Design WalkthroughAppendix B: The Object-Oriented Design Owner's ManualAppendix C: Blitz Guide to Object-Oriented Terminology

    The articles that will appear in this column will focus on the use of C++ and OOD, and will address issues of software engineering. I will strive for articles that are pragmatic and directly useful to the software engineer in the trenches. In these articles I will make use of Booch's and Rumbaugh's new unified Modeling Langage (UML Version 0.8) for documenting object oriented designs. The sidebar provides a brief lexicon of this notation.My last column (Mar, 96) talked about the Liskov Substitution Principle (LSP). This principle, when applied to C++, provides guidance for the use of public inheritance. It states that every function which operates upon a reference or pointer to a base class, should be able to operate upon derivatives of that base class without knowing it. This means that the virtual member functions of derived classes must expect no more than the corresponding member functions of the base class; and should promise no less. It also means that virtual member functions that are present in base classes must also be present in the derived classes; and they must do useful work. When this principle is violated, the functions that operate upon pointers or references to base classes will need to check the type of the actual object to make sure that they can operate upon it properly. This need to check the type violates the Open-Closed Principle (OCP) that we discussed last January.In this column, we discuss the structural implications of the OCP and the LSP. The structure that results from rigorous use of these principles can be generalized into a principle all by itself. I call it "The Dependency Inversion Principle" (DIP). A. HIGH LEVEL MODULES SHOULD NOT DEPEND UPON LOW LEVEL MODULES. BOTH SHOULD DEPEND UPON ABSTRACTIONS.B. ABSTRACTIONS SHOULD NOT DEPEND UPON DETAILS. DETAILS SHOULD DEPEND UPON ABSTRACTIONS.

    * Teaches the principles of programming to those who are just beginning in the field of computer science * Horstmann highlights common mistakes throughout, realizing that one of the toughest points to teach is how to avoid mistakes * New includes a new chapter on pointers, expanded GUI coverage, with platform-specific material on the Web Wiley Higher Education

    The book details the importance of planning a successful measurement program with a complete discussion of why, what, where, when, and how to measure and who should be involved. Each chapter addresses these significant questions and provides the essential answers in building an effective measurement program. The book differs from others on the market by focusing on the application of the metrics rather than the metrics themselves. The author's provide information based on actual experience with successful metrics programs. Each chapter includes a case study focusing on technology transfer and a set of recommended references. The book serves as a guide on the use and application of software metrics in industrial environments. It is specially designed for managers, product supervisors, and quality assurance personnel who want to know how to implement a metrics program.

    

    The emphasis is on practical methods of measurement, simulation, and analytical modeling. David Lilja discusses performance metrics and provides detailed coverage of the strategies used in benchmark programs. In addition to intuitive explanations of key statistical tools, he describes the general design of experiments technique and shows how the maximum amount of information can be obtained with minimum effort. Features include appendices listing common probability distributions and statistical tables and a glossary of important technical terms.

    The articles that will appear in this column will focus on the use of C++ and OOD, and will address issues of software engineering. I will strive for articles that are pragmatic and directly useful to the software engineer in the trenches. In these articles I will make use of Booch's and Rumbaugh's new unified Modeling Langage (UML Version 0.8) for documenting object oriented designs. The sidebar provides a brief lexicon of this notation.My last column (May 96) I discussed the principle of Dependency Inversion (DIP). This principle states that modules that encapsulate high level policy should not depend upon modules that implement details. Rather, both kinds of modules should depend upon abstractions. To be more succinct and simplistic, abstract classes should not depend upon concrete classes; concrete classes should depend upon abstract classes. A good example of this principle is the TEMPLATE METHOD pattern from the GOF book. In this pattern, a high level algorithm is encoded in an abstract base class and makes use of pure virtual functions to implement its details. Derived classes implement those detailed virtual functions. Thus, the class containing the details depend upon the class containing the abstraction.In this article we will examine yet another structural principle: the Interface Segregation Principle (ISP). This principle deals with the disadvantages of "fat" interfaces. Classes that have "fat" interfaces are classes whose interfaces are not cohesive. In other words, the interfaces of the class can be broken up into groups of member functions. Each group serves a different set of clients. Thus some clients use one group of member functions, and other clients use the other groups.The ISP acknowledges that there are objects that require non-cohesive interfaces; however it suggests that clients should not know about them as a single class. Instead, clients should know about abstract base classes that have cohesive interfaces. Some languages refer to these abstract base classes as "interfaces", "protocols" or "signatures". In this article we will discuss the disadvantages of "fat" or "polluted" interfaces. We will show how these interfaces get created, and how to design classes which hide them. Finally we will present a case study in which the a "fat" interface naturally occurs, and we will employ the ISP to correct it.CLIENTS SHOULD NOT BE FORCED TO DEPEND UPON INTERFACES THAT THEY DO NOT USE.

    The text also includes a variety of multithreading examples.

    It is not a how-to book--it is a how does it work book. --Dean McCrory, MFC Development Lead Finally, a book on MFC that fills the gap between Using the Wizards Visual C++ books, product documentation and MFC source code. MFC Internals is a guide to what goes on inside the Microsoft Foundation Classes, giving you unique and in-depth information on undocumented MFC classes, utility functions and data members, useful coding techniques, and critical analysis of the way various MFC classes work and how they all fit together. The first half of the book covers core Windows graphical user interface classses and their supporting classes; the second half covers subjects like OLE that are extensions to the basic Windows support. Youll become an expert at understanding MFC implementation details by: exploring under the hood of MFCs document/view architecture to learn about view synchronization, printing and even print preview diving deep into undocumented aspects of MFC serialization and undocumented classes like CPreview, CPreviewDC, CMirrorFile, CDockBar, etc. finally learning how MFC and OLE work together under the hood, and h

    An innovative and important approach to the subject for researchers and graduates.

    Spells of Fury: Building Games in Windiws 95 shows both game programming beginners and veterans how to use the Windows 95 Game SDK, DirectX to build visually electrifying Windows games.-- Demonstrates the astounding game development capabilities of Microsoft's new APIs-- CD-ROM includes fully operational Windows 95 games complete with source code and art

    This book provides users with the tools they need to connect HTML based content to Java applets. The user-friendly format takes the fear out of learning--even programming languages. (Communications/Networking)

    "The Internet Protocols Handbook" is the ultimate guide to understanding and using all of the most common, and some not-so-common, Internet protocols scattered across the Internet. It's an essential encyclopedia for anyone who writes Internet applications, such as developers, network designers, system administrators, and communication specialists. Inside this handbook are detailed descriptions of protocols for mail, data links, network news, transport, file transfer, Web communications, remote terminals, and directory services.Covers over 30 protocols, including new and forthcoming ones.Describes packet and message formats for the most popular protocols.Is easily accessed and cross-referenced; you'll quickly find exactly what you

    The exercises are broken into three types of activities: Pre-Lab: Reading review and paper-and-pencil exercises designed to ensure understanding of the material to be covered in the exercises In-Lab: Individual lessons broken into exercises specifically mapped to the concepts covered in the chapter Post-Lab: Programming assignments which can be done independently and cover the important topics from the chapter Checklist cover sheets allow students and instructors to track the assignments, output, and grading for each exercise. Perforated pages aid in submission and grading of exercises and homework assignments.

    Choose from a range of applications and technologies, including Java, SGML, VRML and the newest HTML and Netscape extensions.-- Teaches how to convey information on the Web using the latest technology -- including Java-- Readers learn how to Integrate multimedia and interactivity into their Web publications-- The CD-ROM contains software, templates and examples to help you become a successful Web publisher

    The new volume includes coverage of various paradigms of programming, including logic programming, high-order functions, combinatorial algebras, and Turing machines. Also covered is scientific visualization, including animated algorithms, function iteration, uniform polyhedra, stellated icosahedra, ray tracing, and single-image stereograms. The book includes many new programming techniques, and will be an indispensable reference for anyone interested in high-level programming. The volume also includes a CD-ROM compatible with both Macintosh and Windows which contains updated programs from the first and second volumes, as well as HTML documents with links to all relevant information. * Continues where The Mathematica Programmer left off* Completely compatible with the latest Mathematica release, Version 3.0* Includes coverage of various paradigms of programming, including logic programming, higher-order functions, combinatory algebras, and turing machines* Coverage of visualization including Animated Algorithms, Function Iteration, Uniform Polyhedra, Stellated Icosahedra, Ray Tracing, and Single-Image Stereograms* Includes dual mode CD-ROM with updated programs from the first volume and notebooks, as well as HTML documents with external links to all relevant information* Includes a 16 page, four color insert

    The sample programs included in the book can be used with any popular Pascal compiler. This second edition provides an expanded selection of examples and chapter drills including answers ideally suited for self-study for beginners and intermediates.

    The book explores the options for design-time property and component editors and experts. The companion CD-ROM contains all the code in the book.