C Interfaces and Implementations: Techniques for Creating Reusable Software

1st Edition

ISBN-13: 978-0201498417, ISBN-10: 0201498413

(52)

4.1 on Goodreads

(74)

Paperback
$35.88 $54.99

$54.99

FREE Returns

FREE delivery Sunday, July 6

Or Prime members get FREE delivery Thursday, July 3. Order within 13 hrs 56 mins.

Only 11 left in stock (more on the way).

$$54.99 () Includes selected options. Includes initial monthly payment and selected options. Details

Price

Subtotal

$$54.99

Subtotal

Initial payment breakdown

Shipping cost, delivery date, and order total (including tax) shown at checkout.

Enhancements you chose aren't available for this seller. Details

To add the following enhancements to your purchase, choose a different seller.

%cardName%

${cardName} not available for the seller you chose

${cardName} unavailable for quantities greater than ${maxQuantity}.

Shipped & Sold by

Payment

Secure transaction

Your transaction is secure

We work hard to protect your security and privacy. Our payment security system encrypts your information during transmission. We don’t share your credit card details with third-party sellers, and we don’t sell your information to others. Learn more

Send as a gift. Include custom message

$35.88

FREE Returns

FREE delivery Sunday, July 6

Or Prime members get FREE delivery Thursday, July 3. Order within 10 hrs 41 mins.

Only 1 left in stock - order soon.

$$54.99 () Includes selected options. Includes initial monthly payment and selected options. Details

Price

Subtotal

$$54.99

Subtotal

Initial payment breakdown

Shipping cost, delivery date, and order total (including tax) shown at checkout.

Access codes and supplements are not guaranteed with used items.

Enhancements you chose aren't available for this seller. Details

To add the following enhancements to your purchase, choose a different seller.

%cardName%

${cardName} not available for the seller you chose

${cardName} unavailable for quantities greater than ${maxQuantity}.

Sold by Carta Diem and Fulfilled by Amazon.

We are sorry. Amazon has encountered an error. Please try again.

Item couldn't be saved. Please try again later. This item could not be removed from your list. Please try again later

{"mobile_buybox_group_1":[{"displayPrice":"$54.99","priceAmount":54.99,"currencySymbol":"$","integerValue":"54","decimalSeparator":".","fractionalValue":"99","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"BnyR%2FDRhkrslW7RQ8poyQ7fVuAPu0r7k6MzNLMSFpAUVJIYgYym66j1Zl9bI0FBSXozzngMCAcohnez0X6buPWA1WWfJmRf2qCdcIRl5fDUHeuLa2w4wCiuvK5M%2FNUgE%2B8%2FuscQo06s%3D","locale":"en-US","buyingOptionType":"NEW","aapiBuyingOptionIndex":0}, {"displayPrice":"$35.88","priceAmount":35.88,"currencySymbol":"$","integerValue":"35","decimalSeparator":".","fractionalValue":"88","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"BnyR%2FDRhkrslW7RQ8poyQ7fVuAPu0r7kGLgR54F8%2FKUswB8T0KgqHho5UOzwMywLUwS2u8X407shY3aCKVOMQ1lTqmxJShjrfWc5ofklzZ0r67c9Rrbs3UVhhuo%2Fwe%2BG9%2B2VugNPN538VjAeWwe7PgQDmwV4pHOKlEkAzdEosJt4ihWvlH6qag%3D%3D","locale":"en-US","buyingOptionType":"USED","aapiBuyingOptionIndex":1}]}

Brief content visible, double tap to read full content.

Full content visible, double tap to read brief content.

Brief content visible, double tap to read full content.

Full content visible, double tap to read brief content.

Book details

ISBN-10

0201498413
ISBN-13

978-0201498417
Edition

1st
Publisher

Addison-Wesley Professional
Publication date

August 20, 1996
Language

English
Dimensions

9.26 x 7.41 x 1.11 inches
Print length

544 pages

See all details

Brief content visible, double tap to read full content.

Full content visible, double tap to read brief content.

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/

From the Back Cover

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

About the author

Follow authors to get new release updates, plus improved recommendations.

David R. Hanson

Brief content visible, double tap to read full content.

Full content visible, double tap to read brief content.

David R. Hanson is a retired computer scientist. Most recently, he was a Software Engineer at Google. Before joining Google in 2004, he was a Senior Researcher at Microsoft Research from 1997-2004 and Professor of Computer Science at Princeton University from 1986-97. He was on the faculty at Yale and the University of Arizona, and he was Dept. Head at Arizona from 1981-86. His visiting appointments include the University of Utah, the Institute for Defense Analyses, Adobe Systems, and Digital's System Research Center. He was co-editor of Software--Practice and Experience from 1980-88 and continues to serve on its editorial board, and he is co-editor of the Princeton University Press Series in Computer Science. He has published many journal and conference papers and two books: A Retargetable C Compiler: Design and Implementation (with Chris Fraser), which describes lcc, a widely used compiler for Standard C, and C Interfaces and Implementations: Techniques for Creating Reusable Software. He earned a PhD in Computer Science in 1976 from the University of Arizona.

Report an issue with this product or seller

Frequently bought together

C Interfaces and Implementations: Techniques for Creating Reusable Software

21st Century C: C Tips from the New School

This item: C Interfaces and Implementations: Techniques for Creating Reusable Software

$54.99

C Programming Language, 2nd Edition

$60.30

21st Century C: C Tips from the New School

$37.58

Brief content visible, double tap to read full content.

Full content visible, double tap to read brief content.

Total price: $00

Try again!

Details

Added to Cart

Some of these items ship sooner than the others.

Product information

Publisher	Addison-Wesley Professional
Publication date	August 20, 1996
Edition	1st
Language	‎English
Print length	544 pages
ISBN-10	0201498413
ISBN-13	978-0201498417
Item Weight	‎2.05 pounds
Dimensions	9.26 x 7.41 x 1.11 inches
Best Sellers Rank	#637,545 in Books (See Top 100 in Books) #2 in Software Reuse #70 in C Programming Language #1,561 in Computer Software (Books)
Customer Reviews	3.9 out of 5 stars 52Reviews

Customers who bought this item also bought

Related books

Customer reviews

52 global ratings

Reviews with images

1 1

Top reviews from the United States

There was a problem filtering reviews. Please reload the page.

Falco Girgis
Verified Purchase
The best C programming book I have EVER seen, hands down.
Reviewed in the United States on September 18, 2022
Format: Paperback

I don't normally leave reviews, but I cannot believe how good this book really is. I'm a power C++20 developer who recently has become fascinated with cross-language interoperability and as such have sought to build my own C runtime framework and utility library...

I don't normally leave reviews, but I cannot believe how good this book really is. I'm a power C++20 developer who recently has become fascinated with cross-language interoperability and as such have sought to build my own C runtime framework and utility library from scratch (libGimbal), influenced by GLib's GObject and Microsoft COM. I've personally implemented my own C17-based versions of C++'s containers, standard algorithms, multiple types of custom strings, custom allocators, and a meta type system providing uniform object representation across languages.

I cannot believe the fact that this book is an almost complete, beautifully architected collection of what amounts to a general-purpose C framework and set of standard containers and algorithms, similar to C++'s STL. If you were to release the examples in the book as a framework, you'd have something similar to GNOME's GLib, which powers all of GTk and the GNOME stack.

Is this book still relevant today? 100% absolutely. It's timeless. It should be a must-have for any C programmer--especially with the breadth of subjects it covers. There is pretty much something in here for every type of developer at every skill level. Even for a C++ developer, you can still learn a lot and "C++-itize" a lot of these data structures and concepts. His programming style is concise, easy to read, and unlike most C texts, is not an bunch of small, abstract, academic snippets. These are production-ready and useful in the real world. Also unlike a lot of the esteemed C classic texts, even though the book was written in '97, this feels like how modern C is written today.

I only wish I had found this book sooner. I cannot recommend it enough.

9 people found this helpful

Helpful

Share
Report
Mick Charles Beaver
Verified Purchase
Examples of how to write large-scale C programs
Reviewed in the United States on April 7, 2015
Format: Paperback

A number of years ago, I asked more experienced programmers about how to write larger programs in C and was recommended to read "C Interfaces and Implementations." I can definitely say I was not disappointed, as the book does a good job of showing how to structure a...

A number of years ago, I asked more experienced programmers about how to write larger programs in C and was recommended to read "C Interfaces and Implementations." I can definitely say I was not disappointed, as the book does a good job of showing how to structure a large code base. In fact, if you look at large, open source C code bases such as the Python interpreter or Quake 3 Arena, you will find a number of the principles at work. So, in that regard, the book does a fantastic job.

The book also excels at showing how more advanced and/or less used parts of the language and standard library can augment the capabilities of your programs. The chapter on Exceptions using setjmp() and longjmp() is worth the price of entry alone. While especially dry, the multiple and extended precision arithmetic chapters also present a topic that is not found in many other places.

If I had to point out one thing that drove me crazy during my reading, it would have to be the overuse of one- and two-letter variable names. While space is at a premium on the page, using names such as "dest" instead of "z" or "sign_of_x" instead of "sx" would have been more elucidating. I found myself losing track of which variable was which in functions that had as many as six one-letter variable names (I'm looking at you XP_div()!).

13 people found this helpful

Helpful

Share
Report
Amazon Customer
Verified Purchase
Good starting place for writing your own C utility library or new API
Reviewed in the United States on June 18, 2014
Format: Paperback

This book has implementations for lots of C interfaces, and uses the literate programming style. Literate programming looks strange at first, but it is very easy to learn to read it. Once you get past that, this book is a swiss army knife of utilities that some of us have...

This book has implementations for lots of C interfaces, and uses the literate programming style. Literate programming looks strange at first, but it is very easy to learn to read it. Once you get past that, this book is a swiss army knife of utilities that some of us have implemented from scratch a dozen times. This time someone took a lot of care and effort to implement small little libraries that have a big impact.

If you're not interested in the implementation in the book, that's fine. I think the APIs presented can inspire people to design better software interfaces. And the concise style is something that we should all work harder to imitate. Most functions are only a half page of text in the book. And the literate programming means those functions are cross referenced and easy for the reader to find.

Really just a joy to read.

7 people found this helpful

Helpful

Share
Report
Brian Candido
Verified Purchase
The Kindle Version is Quite Bad
Reviewed in the United States on August 31, 2023
Whatever method they used to create the ebook resulted in the ISBN and related content being repeated constantly throughout the pages which is incredibly annoying. Even if you get over that, the code formatting is completely broken. This is a shame and an effort should...

Whatever method they used to create the ebook resulted in the ISBN and related content being repeated constantly throughout the pages which is incredibly annoying. Even if you get over that, the code formatting is completely broken. This is a shame and an effort should really be made to either fix this or stop selling it as an ebook.

Helpful

Share
Report
Brian Sorahan
Verified Purchase
This is the best book to read after learning the fundamentals of C ...
Reviewed in the United States on April 24, 2014
Format: Paperback

This is the best book to read after learning the fundamentals of C programming. The patterns drilled into your head by Mr. Hanson (concealing implementation behind opaque pointers, documenting which runtime errors an implementation will check vs. which ones client code must...

This is the best book to read after learning the fundamentals of C programming. The patterns drilled into your head by Mr. Hanson (concealing implementation behind opaque pointers, documenting which runtime errors an implementation will check vs. which ones client code must guard against, ...) will make your C programs more robust, maintainable, and reusable. Can't recommend this book highly enough!!

2 people found this helpful

Helpful

Share
Report
faumarz
Verified Purchase
An embedded developer point of view
Reviewed in the United States on December 13, 2009
Format: Paperback

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...

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.

18 people found this helpful

Helpful

Share
Report
Claire Jones
Verified Purchase
An API reference and tutorial
Reviewed in the United States on April 29, 2015
Format: Paperback

Working in any business or industrial setting and you will need to write APIs. This book contains wonderful examples of many types of APIs for the unacquainted reader.

Helpful

Share
Report
Kenneth O'Brien
Verified Purchase
Excellent
Reviewed in the United States on June 29, 2014
Format: Paperback

This book made me a better C programmer. I still look to it for guidance. If followed, it saves you time as your code becomes better structured.

Helpful

Share
Report

Top reviews from other countries

Pau Fernández

Verified Purchase
Este libro hay que aprendérselo de memoria...
Reviewed in Spain on March 14, 2017

El contenido me parece buenísimo, para estudiar a fondo. La copia del libro que me llegó no es óptima, porque las página estan un poco onduladas, pero merece 5 estrellas igualmente.

El contenido me parece buenísimo, para estudiar a fondo. La copia del libro que me llegó no es óptima, porque las página estan un poco onduladas, pero merece 5 estrellas igualmente.

Report

Translate review to English

How customer reviews and ratings work

Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.Learn more how customers reviews work on Amazon

C Interfaces and Implementations: Techniques for Creating Reusable Software

Return this item for free

Return this item for free

Other sellers on Amazon