Ebook Free C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson
To overcome the issue, we now offer you the modern technology to download the book C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson not in a thick published data. Yeah, checking out C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson by on the internet or obtaining the soft-file simply to review can be among the means to do. You could not feel that reviewing an e-book C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson will work for you. However, in some terms, May individuals effective are those which have reading routine, included this sort of this C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson
Ebook Free C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson
C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson. Exactly what are you doing when having extra time? Talking or searching? Why don't you attempt to review some book? Why should be checking out? Reviewing is among fun and also delightful activity to do in your leisure. By reading from many resources, you could locate brand-new details and experience. Guides C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson to check out will certainly many beginning with scientific books to the fiction e-books. It suggests that you can review the publications based upon the requirement that you wish to take. Of training course, it will be different and also you could check out all book kinds at any time. As below, we will show you a publication need to be reviewed. This book C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson is the choice.
There is no doubt that publication C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson will always offer you inspirations. Also this is just a publication C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson; you could find numerous styles as well as types of books. From entertaining to experience to politic, and scientific researches are all provided. As just what we state, here we provide those all, from popular writers and author in the world. This C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson is one of the compilations. Are you interested? Take it currently. Just how is the method? Find out more this write-up!
When somebody needs to go to guide shops, search establishment by establishment, shelf by rack, it is extremely frustrating. This is why we give the book collections in this internet site. It will certainly ease you to search guide C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson as you like. By browsing the title, publisher, or authors of the book you really want, you can find them rapidly. Around the house, office, or even in your method can be all finest place within net connections. If you want to download and install the C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson, it is extremely easy then, since currently we extend the connect to acquire and make deals to download and install C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson So simple!
Curious? Of course, this is why, we suppose you to click the web link page to visit, and then you could delight in the book C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson downloaded till completed. You can save the soft file of this C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson in your gizmo. Certainly, you will bring the gizmo almost everywhere, will not you? This is why, every single time you have leisure, every single time you could take pleasure in reading by soft copy publication C Interfaces And Implementations: Techniques For Creating Reusable Software, By David R. Hanson
creating reusable software modules; they are the building blocks of large, reliable applications. 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
- Sales Rank: #209927 in Books
- Published on: 1996-08-30
- Original language: English
- Number of items: 1
- Dimensions: 9.00" h x 1.20" w x 7.30" l, 2.03 pounds
- Binding: Paperback
- 544 pages
From the Back Cover
Every programmer and software project manager must master the art of creating reusable software modules; they are the building blocks of large, reliable applications. 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 chapter's interface tp help those modifying or extending an interface or designing related interfaces.
- In-depth focus on "algorithm engineering:" how to package data structures and related algorithms into reusable modules.
- Source code for 24 APIs and 8 sample applications is examined, with each presented as a "literate program" in which a thorough explanation is interleaved with the source code.
- Rarely documented C programming tricks-of-the-trade.
- Convenient access to all source code in the book via the World Wide Web at http://www.cs.princeton.edu/software/cii/
0201498413B04062001
About the Author
David R. Hanson is a Professor of Computer Science at Princeton University with more than 20 years of research experience in programming languages. He has conducted research in conjunction with Bell Laboratories and is the co-author of lcc, a production quality, research compiler for the C language that is popular with the Unix community. lcc is presented and analyzed in the book A Retargetable C Compiler: Design and Implementation , by Christopher Fraser and David Hanson (c) 1995, Addison-Wesley.
0201498413AB04062001
Excerpt. � Reprinted by permission. All rights reserved.
Programmers are inundated with information about application programming interfaces, or APIs. Yet, while most programmers use APIs and the libraries that implement them in almost every application they write, relatively few create and disemminate new, widely applicable, APIs. Indeed, programmers seem to prefer to "roll their own" instead of searching for a library that might meet their needs, perhaps because it is easier to write application-specific code than to craft well-designed APIs.
I'm as guilty as the next programmer: lcc, a compiler for ANSI/ISO C written by Chris Fraser and myself, was built from the ground up. (lcc is described in A Retargetable C Compiler: Design and Implementation, Addison-Wesley, 1995.) A compiler exemplifies the kind of application for which it is possible to use standard interfaces and to create interfaces that are useful elsewhere. Examples include interfaces for memory management, string and symbol tables, and list manipulation. But lcc uses only a few routines from the standard C library, and almost none of its code can be used directly in other applications.
This book advocates a design methodology based on interfaces and their implementations, and it illustrates this methodology by describing 24 interfaces and their implementations in detail. These interfaces span a large part of the computing spectrum and include data structures, arithmetic, string processing, and concurrent programming. The implementations aren't toys - they're designed for use in production code. As described below, the source code is freely available.
There's little support in the C programming language for the interface-based design methodology. Object-oriented languages, like C++ and Modula-3, have language features that encourage the separation of an interface from its implementation. Interface-based design is independent of any particular language, but it does require more programmer willpower and vigilance in languages like C, because it's too easy to pollute an interface with implicit knowledge of its implementation and vice versa.
Once mastered, however, interface-based design can speed development time by building upon a foundation of general-purpose interfaces that can serve many applications. The foundation class libraries in some C++ environments are examples of this effect. Increased reuse of existing software - libraries of interface implementations - reduces initial development costs. It also reduces maintenance costs, because more of an application rests on well-tested implementations of general-purpose interfaces.
The 24 interfaces come from several sources, and all have been revised for this book. Some of the interfaces for data structures - abstract data types - originated in lcc code, and in implementations of the Icon programming language done in the late 1970s and early 1980s (see R. E. Griswold and M. T. Griswold, The Icon Programming Language, Prentice Hall, 1990). Others come from the published work of other programmers; the "Further Reading" sections at the end of each chapter give the details.
Some of the interfaces are for data structures, but this is not a data structures book, per se. The emphasis is more on algorithm engineering - packaging data structures for general use in applications - than on data-structure algorithms. Good interface design does rely on appropriate data structures and efficient algorithms, however, so this book complements traditional data structure and algorithms texts like Robert Sedgewick's Algorithms in C (Addison-Wesley, 1990).
Most chapters describe one interface and its implementation; a few describe related interfaces. The "Interface" section in each chapter gives a concise, detailed description of the interface alone. For programmers interested only in the interfaces, these sections form a reference manual. A few chapters include "Example" sections, which illustrate the use of one or more interfaces in simple applications.
The "Implementation" section in each chapter is a detailed tour of the code that implements the chapter's interface. In a few cases, more than one implementation for the same interface is described, which illustrates an advantage of interface-based design. These sections are most useful for those modifying or extending an interface or designing related interfaces. Many of the exercises explore design and implementation alternatives. It should not be necessary to read an "Implementation" section in order to understand how to use an interface.
The interfaces, examples, and implementations are presented as literate programs; that is, the source code is interleaved with its explanation in an order that best suits understanding the code. The code is extracted automatically from the text files for this book and assembled into the order dictated by the C programming language. Other book-length examples of literate programming in C include A Retargetable C Compiler and The Stanford GraphBase: A Platform for Combinatorial Computing by D. E. Knuth (Addison-Wesley, 1993).
Organization
The material in this book falls into the following broad categories:
Most readers will benefit from reading all of Chapters 1 through 4, because these chapters form the framework for the rest of the book. The remaining chapters can be read in any order, although some of the later chapters refer to their predecessors.
Chapter 1 covers literate programming and issues of programming style and efficiency. Chapter 2 motivates and describes the interface-based design methodology, defines the relevant terminology, and tours two simple interfaces and their implementations. Chapter 3 describes the prototypical Atom interface, which is the simplest production-quality interface in this book. Chapter 4 introduces exceptions and assertions, which are used in every interface. Chapters 5 and 6 describe the memory management interfaces used by almost all the implementations. The rest of the chapters each describe an interface and its implementation.
Instructional Use
I assume that readers understand C at the level covered in undergraduate introductory programming courses, and have a working understanding of fundamental data structures at the level presented in texts like Algorithms in C. At Princeton, the material in this book is used in systems programming courses from the sophomore to first-year graduate levels. Many of the interfaces use advanced C programming techniques, such as opaque pointers and pointers to pointers, and thus serve as nontrivial examples of those techniques, which are useful in systems programming and data structure courses.
This book can be used for courses in several ways, the simplest being in project-oriented courses. In a compiler course, for example, students often build a compiler for a toy language. Substantial projects are common in graphics courses as well. Many of the interfaces can simplify the projects in these kinds of courses by eliminating some of the grunt programming needed to get such projects off the ground. This usage helps students realize the enormous savings that reuse can bring to a project, and it often induces them to try interface-based design for their own parts of the project. This latter effect is particularly valuable in team projects, because that's a way of life in the "real world."
Interfaces and implementations are the focus of Princeton's sophomore-level systems programming course. Assignments require students to be interface clients, implementors, and designers. In one assignment, for example, I distribute Section 8.1's Table interface, the object code for its implementation, and the specifications for Section 8.2's word frequency program, wf. The students must implement wf using only my object code for Table. In the next assignment, they get the object code for wf, and they must implement Table. Sometimes, I reverse these assignments, but both orders are eye-openers for most students. They are unaccustomed to having only object code for major parts of their program, and these assignments are usually their first exposure to the semiformal notation used in interfaces and program specification.
Initial assignments also introduce checked runtime errors and assertions as integral parts of interface specifications. Again, it takes a few assignments before students begin to appreciate the value of these concepts. I forbid "unannounced" crashes; that is, crashes that are not announced by an assertion failure diagnostic. Programs that crash get a grade of zero. This penalty may seem unduly harsh, but it gets the students' attention. They also gain an appreciation of the advantages of safe languages, like ML and Modula-3, in which unannounced crashes are impossible. (This grading policy is less harsh than it sounds, because in multipart assignments, only the offending part is penalized, and different assignments have different weights. I've given many zeros, but none has ever caused a course grade to shift by a whole point.)
Once students have a few interfaces under their belts, later assignments ask them to design new interfaces and to live with their design choices. For example, one of Andrew Appel's favorite assignments is a primality testing program. Students work in groups to design the interfaces for the arbitrary-precision arithmetic that is needed for this assignment. The results are similar to the interfaces described in Chapters 17 through 19. Different groups design interfaces, and a postassignment comparison of these interfaces, in which the groups critique one anothers' work, is always quite revealing. Kai Li accomplishes similar goals with a semester-long project that builds an X-based editor using the Tcl/Tk system (J. K. Ousterhout, Tcl and the Tk Toolkit, Addison-Wesley, 1994).
0201498413P04062001
Most helpful customer reviews
14 of 14 people found the following review helpful.
Excellent, useful, timeless
By ThomasH
I second the many positive reviews about this book. If you architect and/or make software for a living, this book will give you a life long of useful ideas and provide with real running and working generic solutions. Foremost I was personally stunned by the implementation of the exception handler emulator, which I adopted ever since. Now I can look back at it's respectable 12 years of service with exemplary low "bug rate" and hundreds of millions in revenue gathered from products using this style of coding.
One issue was not mentioned by the most of other reviewers: This book is one of the now rare examples of "Literate Programming," a term coined by Donald Knuth, who implemented the "web system" with two programs Tangle and Weave. From the same source the one program generates code for a compiler, the other generates a book text for a text processing system. This way code and the literature about it are in perfect sync. Most importantly, the code showed in the book is a real tested and running implementation, not a mere pseudo code used by others so often, which may or may not be correct. See section 1.1 for a description of the system and typographical convention used by Prof. Hanson in his book.
For me this book is a classic. Timeless, even now 12 years since its date of release it is highly recommended for every practitioner at any level.
7 of 7 people found the following review helpful.
An embedded developer point of view
By Amazon Customer
A very good book also for the embedded field; you can't use much of the code in small 8bit microcontroller environments, but if you work with bigger 16/32bit microcontrollers many of the abstract data types (ADTs) described here can be useful. Maybe the "threads" interface can even be used as a base to develop a tiny cooperative embedded OS, too.
The title of the book is not exactly true: this is not a generic text on "C interfaces an implementation", it's a complete and detailed documentation of a well-projected C user level generic library, implementing a lot of ADTs that are not available in the C standard library but are available in many other high(er?) level languages.
You may like or not the semantic details and coding style, probably depending on your background: unix/linux programmers may not like it, as they may not like the ADTs prefix-verbosity...
It's a way to add modularity to a not-object-oriented language as C is; the same for the "typedef struct T *T" (opaque pointers) in headers: modularity and encapsulation.
Pseudocode notation (literate programming) is clear, as long as you read chapter 1.
5 of 5 people found the following review helpful.
Why overcomplicate things.
By Burak Selcuk Soyer
It is almost impossible to make everbody happy when presenting a book for the public. This one is a good example for making things more diffilcult than it is normally. Separating interface from implementation is not an ardous problem in C; there are a few techniques for doing this, like opaque pointers or the piml idiom. What is actually exhibited in this work is more or less the piml idiom implemented in the C language.
The author seems to have prefered a more academic and consequently a scientific style of writing and explanation of things around interfaces and its implementations. Really, the coding style is not easily accessible, hence at times troublesome to follow and crasp. The using of the letter T for the uncomplete types or abstract data types might make the reader somewhat uncomfortable in absorbing the examples given.
But as a whole, this book clearly and systematically demonstrates the plan how to implement abstract data types in C, which requires some patience and discipline to work them out.
See all 24 customer reviews...
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson PDF
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson EPub
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson Doc
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson iBooks
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson rtf
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson Mobipocket
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson Kindle
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson PDF
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson PDF
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson PDF
C Interfaces and Implementations: Techniques for Creating Reusable Software, by David R. Hanson PDF
![, by Steven C. Ender - Students Helping Students : A Guide for Peer Educators on College (2000-03-16) [Paperback], by Steven C. Ender](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_sIacO00WQ6TBE0wwGjPxl33d-tgN60NNEYserDMDAeyOVoexCMiIGS124N9kG_61DTszQ2c5JA93sGpjP6tFCPRaN25iAnWsCtre4c8kcrt2udlsQ08saG=s0-d ", by Steven C. Ender - Students Helping Students : A Guide for Peer Educators on College (2000-03-16) [Paperback], by Steven C. Ender")
![, by Steven C. Ender - Students Helping Students : A Guide for Peer Educators on College (2000-03-16) [Paperback], by Steven C. Ender](https://lh3.googleusercontent.com/blogger_img_proxy/AEn0k_tlxND17ZwP9QPeLnJRP1QQw5H4Gfowm0UhUlhFexm4xMRvxFRXgXpwmewWZuXKcXLKh0rzyh-fXwJTmADXXQ24Zv1KLQ=s0-d ", by Steven C. Ender - Students Helping Students : A Guide for Peer Educators on College (2000-03-16) [Paperback], by Steven C. Ender")
