| Search | About | Preferences | Interact | Help | |
| 150 million books. 1 search engine. | ||

› Find signed collectible books: 'Applying Rcs and Sccs: From Source Control to Project Control'
More editions of Applying Rcs and Sccs: From Source Control to Project Control:
› Find signed collectible books: 'The Benchmark Handbook: For Database and Transaction Processing Systems'
More editions of The Benchmark Handbook: For Database and Transaction Processing Systems:

› Find signed collectible books: 'Blondie24: Playing at the Edge of Ai'
More editions of Blondie24: Playing at the Edge of Ai:

› Find signed collectible books: 'C for Rookies'
More editions of C for Rookies:
› Find signed collectible books: 'C++: The Core Language'
C++ is an object-oriented enhancement of the C programming language and is becoming the language of choice for serious software development.
C++ has crossed the Single Book Complexity Barrier. The individual features are not all that complex, but when put together in a program they interact in highly non-intuitive ways. Many books discuss each of the features separately, giving readers the illusion that they understand the language. But when they try to program, they're in for a painful surprise (even people who already know C).
C++: The Core Language is for C programmers transitioning to C++. It's designed to get readers up to speed quickly by covering an essential subset of the language.
The subset consists of features without which it's just not C++, and a handful of others that make it a reasonably useful language. You can actually use this subset (using any compiler) to get familiar with the basics of the language.
Once you really understand that much, it's time to do some programming and learn more from other books. After reading this book, you'll be far better equipped to get something useful out of a reference manual, a graphical user interface programming book, and maybe a book on the specific libraries you'll be using. (Take a look at our companion book, Practical C++ Programming.)
C++: The Core Language includes sidebars that give overviews of all the advanced features not covered, so that readers know they exist and how they fit in. It covers features common to all C++ compilers, including those on UNIX, Windows NT, Windows, DOS, and Macintosh.
Comparison: C++: The Core Language vs. Practical C++ Programming
O'Reilly's policy is not to publish two books on the same topic for the same audience. We'd rather spend twice the time on making one book the industry's best. So why do we have two C++ tutorials? Which one should you get?
The answer is they're very different. Steve Oualline, author of the successful book Practical C Programming, came to us with the idea of doing a C++ edition. Thus was born Practical C++ Programming. It's a comprehensive tutorial to C++, starting from the ground up. It also covers the programming process, style, and other important real-world issues. By providing exercises and problems with answers, the book helps you make sure you understand before you move on.
While that book was under development, we received the proposal for C++: The Core Language. Its innovative approach is to cover only a subset of the language -- the part that's most important to learn first -- and to assume readers already know C. The idea is that C++ is just too complicated to learn all at once. So, you learn the basics solidly from this short book, which prepares you to understand some of the 200+ other C++ books and to start programming.
These two books are based on different philosophies and are for different audiences. But there is one way in which they work together. If you are a C programmer, we recommend you start with C++: The Core Language, then read about advanced topics and real-world problems in Practical C++ Programming.
More editions of C++: The Core Language:
› Find signed collectible books: 'Cgi Programming on the World Wide Web'
O'Reilly has done it again! This is my favorite book yet on writing CGI scripts with Perl (5.0). The extensive use of real world applications you can try while learning, and the great examples of how to have CGI interact with databases are especially useful. I suspect I shall order several copies for some of our staff who are new to CGI. Although the book has a UNIX bias, it has much to offer scripters on all platforms.
Note that many competitors cram a CD-ROM into their books to give greater "shelf appeal". Don't be fooled. O'Reilly continues its economically and ecologically sensible approach of pointing you to their FTP site to obtain the example code used in the book. (Thanks, Tim!) Highly Recommended. [via]
More editions of Cgi Programming on the World Wide Web:
› Find signed collectible books: 'CGI Programming with Perl'
The appearance of the second edition of CGI Programming with Perl heralds the beginning of the neoclassical era of Web service. CGI--or common gateway interface--is the original back end for client-driven, dynamic Web-page service and deserves consideration as the Romulus of the Internet Empire. But, where first-edition author Gundavaram described the lonely Romulus laying the brick foundation of dynamic Web-page service in 1996, second-edition collaborators Guelich and Birznieks have pitched in to resurrect Romulus amid the crowded streets of modern Rome. Why bother? Surely four years have brought technological revolutions (Java, PHP, ASP, ColdFusion) that render CGI's original brick-by-brick approach as obsolete as, say, Roman mythology--or bricks and mortar.
And yet not. It is an ambiguous blessing that the original CGI persists, adhering to the underside of Web service by the duct tape that is Perl. This point is not missed by Guelich, Gundavaram, and Birznieks, whose advocacy of CGI is both bolstered by the growing applications module base of Perl and tempered by their awareness of CGI's structural limitations. Both new and returning readers of CGI Programming with Perl should browse the last chapter first in order to appreciate the proposed solutions to CGI's greatest sin: its impractical slowness in a world of a million-hits-per-day Web service. The chapter describes CGI-compatible FastCGI and mod_perl technologies that circumvent the process-spawning slowness of the simple CGI. Advanced users might want to skip directly to O'Reilly's fine mod_perl tome, Writing Apache Modules with Perl and C, by Lincoln Stein and Doug MacEachern.
The authors' second pass at CGI pedagogy is a lucid, honest, and expanded account that develops functionality of dynamic Web pages in a rational progression--from HTML client-server and CGI syntax basics to general input/output, forms, e-mail, graphics, and simple database applications, including maintaining client state and data persistence under the otherwise stateless HTTP protocol. The authors offer synopses of cookies, JavaScripting, server security, and XML, all of which are described in detail in other books.
Whether or not neoclassical CGI is fast enough for your purposes--perhaps for guarded intranets--bear in mind that CGI is the standard to which every other Web server has had to respond. The second edition of CGI Programming with Perl is still the best introduction to the classics. --Peter Leopold, Amazon.com [via]
More editions of CGI Programming with Perl:

› Find signed collectible books: 'Computer Animation: Algorithms and Techniques'
More editions of Computer Animation: Algorithms and Techniques:
› Find signed collectible books: 'Computer Organization and Design: The Hardware/Software Interface'
This textbook provides a basic introduction to the fundamentals of current computer designs. As the title suggests, the text skirts the border between hardware and software. After an overview of the subject and a discussion of performance, the book launches into technical matter such as instruction sets, how they are constrained by the underlying processor hardware, the constraints on their design, and more. An excellent critique of computer arithmetic methods leads to a high-level discussion on processor design. Following is a great introduction to pipelining, nice coverage of memory issues, and solid attention to peripherals. The book concludes with a brief discussion of the additional issues inherent in multiprocessing machines. The extremely lucid description is grounded in real-world examples. Interesting exercises help reinforce the material, and each section contains a write-up of the historical background of each idea. Computer Organization and Design is accessible to the beginner, but also offers plenty of valuable knowledge for experienced engineers. [via]
More editions of Computer Organization and Design: The Hardware/Software Interface:

› Find signed collectible books: 'Curves and Surfaces in Geometric Modeling : Theory and Algorithms'
More editions of Curves and Surfaces in Geometric Modeling : Theory and Algorithms:

› Find signed collectible books: 'Data Warehousing: Using the Wal-Mart Model'
More editions of Data Warehousing: Using the Wal-Mart Model:
› Find signed collectible books: 'Database Modeling & Design'
This new edition of Database Modeling & Design continues to focus on the techniques for relational database design introduced in previous editions, starting with the entity-relationship (ER) approach for data requirements specification and conceptual modeling. Author Toby Teorey then looks ahead to the common properties in data modeling and operations shared among the relational model and advanced database technologies such as the object-oriented, temporal, and multimedia models. A full chapter is devoted to database design techniques for data warehousing and online analytical processing (OLAP).
Teorey covers the database life cycle from requirements analysis and logical design to physical design for local, distributed, and multidatabases. The discussion of basic principles is supplemented with a common, running example: a company personnel and project database based on real-life experiences and classroom testing.
Written for both the novice and the professional database designer, this book is the essential resource for database modeling, including the building of standard SQL data definitions. The design rules set forth in this book are applicable to any SQL-based system, including IBM DB2, Oracle V8.0, Informix IDS-UDO, Microsoft Access, Microsoft SQL Server, and Sybase Adaptive Server Enterprise.
* Continued focus on relational model
* Integration of information about data warehouse and OLAP, plus other advanced database technologies, including object oriented, multimedia, and temporal database
* Discussion of basic principles is supplemented by examples based on real life cases
[via]
More editions of Database Modeling & Design:

› Find signed collectible books: 'Database Modeling & Design: The Fundamental Principles'
More editions of Database Modeling & Design: The Fundamental Principles:

› Find signed collectible books: 'Database Programming With Jdbc and Java'
O'Reilly & Associates has made its name publishing gritty documentation of Unix innards, especially application programming interface (API) references. Database Programming with JDBC and Java follows this heritage in the excellent roadmap of the java.sql.* package, which fills a solid quarter of this thin book. All the variables and methods have clear annotations that will help you solve problems. The rest of the book is a mixed bag.
Reese opens with a discussion of SQL, then proceeds to explain client-server architecture and three-tier database access. In describing JDBC, he provides clear program listings on how to connect to a database, get information from it, add information to it, and delete parts of it. While Reese does a fine job of explaining these critical tasks, the book doesn't come with a disc to save you from typing them manually (though you can get them by FTP from the O'Reilly site). This book continues to guide the reader through query optimization and interface design. The book focuses a lot of attention on Remote Method Invocation (RMI), walking the reader through the creation of a "banking" application that illustrates all the important JDBC operations. This book has the best JDBC application programming interface (API) reference around, which alone is worth the price of the book. However, you will probably want to supplement this book with a better JDBC tutorial. [via]
More editions of Database Programming With Jdbc and Java:

› Find signed collectible books: 'The Design of Children's Technology'
More editions of The Design of Children's Technology:
› Find signed collectible books: 'Developing Asp Components'
Developing ASP Components offers comprehensive instruction for creating and implementing server-side components for the Microsoft Web server platform. You can build Microsoft components with different languages, and author Shelley Powers covers the bases with equal coverage of Visual Basic, Visual C++, and Visual J++ development.
The first part of the book offers a very readable introduction to Active Server Pages (ASP) components, the Component Object Model (COM), thread implementation, and transactions. This section explains how the elements of the ASP processing environment work together and forms the foundation for the remainder of the book. Inside this overview, the author is careful to point out differences among the trio of featured programming languages.
The next section covers Visual Basic component building, access to ActiveX Data Objects (ADO), and building multiple-tier ASP components. This section illustrates how an easy-to-use language like VB can offer great productivity. C++ is then covered, with a focus on the language's additional control and, in particular, possibilities for object linking and embedding database (OLE DB) data access. For Java, the author includes coverage of JavaBeans and data access with the Windows Framework Classes (WFC).
With proper focus on the key aspects of each language and plenty of practical examples, this title squarely hits the mark as a guide for budding ASP developers. --Stephen Plain [via]
More editions of Developing Asp Components:
› Find signed collectible books: 'Director in a Nutshell: A Desktop Quick Reference'
Director in a Nutshell: A Desktop Quick Reference helps Director users uncover little-known but vitally important details about using Macromedia's multimedia program effectively. It supplies ample guidance on troubleshooting common difficulties and insight on avoiding the most common problems.
This is a well-organized book--progressing from developing your understanding of how Director works, which should enrich your productivity, to showing you how to best handle audio and video. In particular, you learn how to use the Score and create animations tools as well as work with Cast members, libraries, and the Stage. You get to set up coordinates, alignment, and registration points; tackle cross-platform delivery issues; and create projectors and runtime files. Those out to optimize their system performance will find sections on managing memory.
You get plenty of help using Lingo and Director's scripting tool, as well as in working with limitations in the various versions of Director. (The book covers versions 6, 6.5, and 7 for both Windows and Macintosh.) Users of every level should be able to glean a lot of useful tips from this book, though most parts are of a technical level best suited to proficient users rather than newcomers to the program. --Kathleen Caster [via]
More editions of Director in a Nutshell: A Desktop Quick Reference:

› Find signed collectible books: 'Disappearing Cryptography: Information Hiding Steganography & Watermarking'
More editions of Disappearing Cryptography: Information Hiding Steganography & Watermarking:

› Find signed collectible books: 'Distributed Algorithms'
More editions of Distributed Algorithms:

› Find signed collectible books: 'Dns and Bind'

› Find signed collectible books: 'Dns and Bind'
More editions of Dns and Bind:

› Find signed collectible books: 'Enterprise Java Beans'
More editions of Enterprise Java Beans:
› Find signed collectible books: 'Essential System Administration'
Essential System Administration takes an in-depth look at the fundamentals of Unix system administration in a real-world, heterogeneous environment. Whether you are a beginner or an experienced administrator, you'll quickly be able to apply its principles and advice to your everyday problems.
The book approaches Unix system administration from the perspective of your job -- the routine tasks and troubleshooting that make up your day. Whether you're dealing with frustrated users, convincing an uncomprehending management that you need new hardware, rebuilding the kernel, or simply adding new users, you'll find help in this book. You'll also learn about back up and restore and how to set up printers, secure your system, and perform many other system administration tasks. But the book is not for full-time system administrators alone. Linux users and others who administer their own systems will benefit from its practical, hands-on approach.
This second edition has been updated for all major Unix platforms, including SunOS 4.1, Solaris 2.4, AIX 4.1, Linux 1.1, Digital Unix, OSF/1, SCO Unix Version 3, HP/UX Versions 9 and 10, and IRIX Version 6. The entire book has been thoroughly reviewed and tested on all of the platforms covered. In addition, networking, electronic mail, security, and kernel configuration topics have been expanded substantially.
Topics covered include:
More editions of Essential System Administration:

› Find signed collectible books: 'Ethernet: The Definitive Guide'
More editions of Ethernet: The Definitive Guide:
› Find signed collectible books: 'Fundamentals of the Theory of Computation'
This innovative textbook presents the key foundational concepts that can be covered in a one semester undergraduate course in the theory of computation. It offers the most accessible and motivational course material available for undergraduate computer theory classes and is directed at the typical undergraduate who may have difficulty understanding the relevance of the course to their future careers. The text helps make students more comfortable with techniques required for the deeper study of computer science.
This text is a bridge between theory and practice. It shows how theory is motivated by practical problems, and in turn how theory influences the practice of computing. Simple tools like string matchers, complex tools like compilers, and general notions like cryptographic security all lie at the interface between principles and practice.
* Contains coverage of contemporary topics: languages and problems, machine models, grammars, reductions, resource consumption, syntax vs. semantics, sequential vs. parallel computation, feasible vs. intractable problems
* Motivates students by clarifying complex theory with many examples, exercises, and detailed proofs
* Offers an integrated review of discrete math concepts, defining each concept where it is first used
* Unifies notation for describing machine models
* Emphasizes computational complexity [via]
More editions of Fundamentals of the Theory of Computation:

› Find signed collectible books: 'Fuzzy Thinking: The New Science of Fuzzy Logic'
More editions of Fuzzy Thinking: The New Science of Fuzzy Logic:
› Find signed collectible books: 'Gui Bloopers: Don'ts and Do's for Software Developers and Web Designers'
In GUI Bloopers, consultant Jeff Johnson uses 550+ pages to illustrate common pitfalls in user interface design, the all-important iceberg tip that end users confuse with applications and that developers confuse with end users. Reporting on 82 incidents of bad design, Johnson manages to cover the essential point of his message: software designers should think of their user interfaces from the user's point of view. Not profound, but profoundly overlooked in most low-end to mid-range development efforts. His codification of GUI design in eight predictable principles will help GUI newbies realize that the customer must be pleased with the product. Of course, the customer doesn't always understand what he or she wants. Hence, GUI development is iterative. When the customer is not at hand, a surrogate will do, so usability testing is essential.
The bloopers include mistakes in window design, labeling consistency, visual/grammatical parallel construction, coherence of look and feel, and clarity. Most perceptively, Johnson observes that CPU speed in the development group hides many design mistakes. Moreover, context-scoping, already a subtle problem in software design, must be implemented in GUI design. Input error handling is the most psychologically sensitive of all GUI design characteristics. User error messages can easily be too vague or too specific, and diagnostic error messages should be user-manageable, if not actually user-interpretable.
Like the Hollywood outtakes that gave us the "blooper," the entertainment quotient here is measured in mistakes, not successes. Teaching by counter example rather than by example at an estimated ratio of three to one, Johnson panders to our invertebrate instinct to measure our own successes by someone else's failure. To his credit, he recognizes that user interfaces include pedestrian texts (like his) as well as graphical interfaces for computer applications. His self-referential style gives the book an egocentric slant, but he is both priest and practitioner: he submitted a draft to usability testers and reports the results in an appendix. One criticism was that there were too many negative examples. Hmmm.
Thanks to other tester comments, GUI Bloopers is a browsable book, allowing the few nuggets of wisdom to be located. For the most part, the book's value can be captured by reading the seven-page table of contents carefully. --Peter Leopold [via]
More editions of Gui Bloopers: Don'ts and Do's for Software Developers and Web Designers:

› Find signed collectible books: 'High Performance Communication Networks'
More editions of High Performance Communication Networks:

› Find signed collectible books: 'High Performance Computing'
The computing power that's available on the average desktop has exploded in the past few years. A typical PC has performance exceeding that of a multi-million dollar supercomputer a mere decade ago. To some people, that might mean that it's time to sit back and watch computers get faster: performance is no longer an issue, we'll let hardware do the work. But if you're looking at this book, you're not one of them. Performance is always an issue. Even with the fastest computers, there's a need to harness the processing power and get more work done in a limited amount of time.
If you're a software developer, you probably know that getting the most out of a modern workstation or PC can be tricky. Paying closer attention to memory reference patterns and loop structure can have a huge payoff. High Performance Computing discusses how modern workstations get their performance and how you can write code that makes optimal use of your hardware. You'll learn what the newest buzzwords really mean, how caching and other memory design features affect the way your software behaves, and where the newest "post-RISC" architectures are headed.
If you're involved with purchasing or evaluating workstations, this book will help you make intelligent comparisons. You'll learn how to interpret the commonly quoted industry benchmarks, what vendors do to show their machines in the best possible light, and how to run your own benchmarks.
Whether you're using the latest Pentium PC or a highly specialized multiprocessor, you'll find High Performance Computing an indispensable guide. Topics covered include:

› Find signed collectible books: 'Higher-order Perl: A Guide To Program Transformation'
More editions of Higher-order Perl: A Guide To Program Transformation:
› Find signed collectible books: 'Html Pocket Reference'
In this pocket reference, Jennifer Niederst, the author of the best-selling Web Design in a Nutshell, delivers a concise guide to every HTML tag.
Each tag entry includes:
In addition to tag-by-tag descriptions, you'll find useful charts on such topics as:
Niederst also provides context for the tags, indicating which tags are grouped together and bare-bones examples of how standard web page elements are constructed.
This pocket reference is targeted at web designers and web authors and is likely to be the most dog-eared book on every web professional's desk.
More editions of Html Pocket Reference:

› Find signed collectible books: 'I Hate Unix'
More editions of I Hate Unix:
![[???]: IEEE Standard Portable Operating System Interface for Computer Environments 1003.1 [???]: IEEE Standard Portable Operating System Interface for Computer Environments 1003.1](http://ecx.images-amazon.com/images/P/1559370033.01._SL160_SCLZZZZZZZ__.jpg)
More editions of IEEE Standard Portable Operating System Interface for Computer Environments 1003.1:

› Find signed collectible books: 'Implicit Parallel Programming in PH'
More editions of Implicit Parallel Programming in PH:

› Find signed collectible books: 'The Internet and Its Protocols: A Comparative Approach'
More editions of The Internet and Its Protocols: A Comparative Approach:

› Find signed collectible books: 'An Introduction to Nurbs: With Historical Perspective'
More editions of An Introduction to Nurbs: With Historical Perspective:
› Find signed collectible books: 'Introduction to UNIX'
More editions of Introduction to UNIX:
› Find signed collectible books: 'Java Enterprise in a Nutshell: A Desktop Quick Reference'
Java Enterprise in a Nutshell gives advanced Java developers a one-stop resource for programming with the disparate APIs required for today's enterprise development, including JDBC, RMI, servlets and EJBs. Beginning with JDBC database programming, the book gives a chapter-by-chapter tour of various enterprise development APIs, including program strategies for each API. For JDBC, the book includes new Java 2 JDBC enhancements like batch and recordsets.
Next comes Java's Remote Method Invocation (RMI) classes for calling remote code. Then it's on to using Java IDL and CORBA basics. A chapter on Java servlets will get you started delivering dynamically generated HTML using Java on Web servers, including useful material on cookies and session management. After coverage of the Java Naming and Directory Interface (JNDI) comes a solid exploration of EJBs with material on both session and entity beans. Specifics here include home and remote interfaces, EJB containers, stateless vs stateful session beans, and entity beans for accessing corporate databases.
Overall, this handy and readable guide to the latest in Java APIs can be truly invaluable to the developer bringing Java to the corporate enterprise for the first time. --Richard Dragan [via]
More editions of Java Enterprise in a Nutshell: A Desktop Quick Reference:

› Find signed collectible books: 'Java Examples in a Nutshell: A Tutorial Companion to Java in a Nutshell'
More editions of Java Examples in a Nutshell: A Tutorial Companion to Java in a Nutshell:

› Find signed collectible books: 'Java Foundation Classes in a Nutshell: A Desktop Quick Reference'
More editions of Java Foundation Classes in a Nutshell: A Desktop Quick Reference:

› Find signed collectible books: 'Java I/O'
More editions of Java I/O:

› Find signed collectible books: 'Java Servlet Programming'
More editions of Java Servlet Programming:
› Find signed collectible books: 'Java Swing'
Java Swing is an excellent introduction to the latest developments in Java-interface technology. The authors explain how (and why) to use Swing components, and meanwhile proceed to document the entire Swing API with the thoroughness and accuracy programmers have come to expect from O'Reilly & Associates.
Eckstein, Loy, and Wood start with an architectural overview of Swing and its relationship to the Abstract Window Toolkit (AWT) and the rest of Java. They talk a little bit about converting programs from the old AWT to the Swing-enhanced AWT, and explain how Swing manages components' "look and feel" characteristics. There's also coverage of actions, which are among Swing's handiest new features.
From that point, they proceed to guide readers through the Swing forest, pointing out all the important stuff along the way. Mostly, this tour takes the form of graphical user interface (GUI) component documentation, with chapters devoted to buttons, lists, tables, panes, and the other thingamajigs you can put on-screen with Swing. All the classes in each category get entries, many of which include good commentary and some examples. The authors give some attention to the Accessibility API and its associated utilities, too.
A detailed chapter that walks the reader through the process of creating a custom look and feel distinguishes Java Swing from its competitors--this potentially confusing process is explained clearly and thoroughly. --David Wall [via]
More editions of Java Swing:

› Find signed collectible books: 'Java Threads'
More editions of Java Threads:
› Find signed collectible books: 'JavaScript Pocket Reference'
At 4.5 by 7 inches in size and only 89 pages long, the aptly named JavaScript Pocket Reference will really almost fit in your pocket. Use this guide as a companion to turn to when in doubt about that function syntax or on drawing a blank on the JavaScript object model.
The book concisely packs together the syntax of the scripting language, including summaries of expression and statement style. The real meat of the tiny title is an alphabetical listing of JavaScript objects, along with their associated methods, properties and events. One nice feature of this section is the attention to the varying support between Microsoft and Netscape browser versions. However, this listing is useful only if you know what object you want to work with. Missing from the reference is a solutions-based reference to let you refresh your memory about how to do a particular task, such as validate a form field or roll over a graphic when the user moves the mouse.
One drawback is the book's illustration of the object model--done only in a small diagram. This is a bit of a shame since this is one of the key topics most developers need help with. If you are rather familiar with JavaScript, this pocket reference will be helpful. New coders, however, will likely find it insufficient. --Stephen W. Plain [via]
More editions of JavaScript Pocket Reference:
› Find signed collectible books: 'Jim Blinn's Corner: A Trip Down the Graphics Pipeline'
Jim Blinn presents an eclectic collection of 20 articles he originally wrote for Computer Graphics and Applications, an IEEE (Institute of Electrical and Electronics Engineers) magazine aimed at graphics professionals. It's unapologetic about being a programmer's book, and it won't make much sense if you're not one (even less if you've forgotten your algebra). But if the shoe fits, and if you're going to be writing your own graphics routines, you stand to learn a lot from an acknowledged master.
Topics include a tour through the author's collection of circle-drawing algorithms, an introduction to animation concepts through a character called Blobby Man, musings on rendering platonic solids, detailed discussions of shadows, clipping and viewports, and investigations into the nature of pixel space. Many algorithms are presented in a generalized pseudo-code that could be easily translated into other languages. In addition to learning practical techniques, you'll also benefit from seeing Blinn's intelligent and offbeat approach to solving problems. [via]
More editions of Jim Blinn's Corner: A Trip Down the Graphics Pipeline:
› Find signed collectible books: 'Jim Blinn's Corner: Dirty Pixels'
"All problems in computer graphics can be solved with a matrix inversion."-Jim Blinn
Jim Blinn is Back!
Dirty Pixels is Jim's second compendium of articles selected from his award-winning column, "Jim Blinn's Corner," in IEEE Computer Graphics and Applications. Here he addresses topics in image processing and pixel arithmetic and shares the tricks he's uncovered through years of experimentation.
Writing in the inimitable, engaging style for which he's famous, Jim's easy-to-understadn explanations and solutions make abstract concepts accessible to a broad audience. Dirty Pixels is an invaluable resource for anyone in the computer graphics field.
Teapots and More
Jim's contributions to computer graphics include the Voyager Fly-by animations of space missions to Jupiter, Saturn, and Uranus; The Mechanical Universe, a 52-part telecourse of animated physics; and the computer animation of Carl Sagan's PBS series Cosmos. Jim developed many graphics techniques now in widespread use, among them bump mapping, environment mapping, and blobby modeling. [via]
More editions of Jim Blinn's Corner: Dirty Pixels:

› Find signed collectible books: 'Jim Blinn's Corner: Notation, Notation, Notation'
More editions of Jim Blinn's Corner: Notation, Notation, Notation:
› Find signed collectible books: 'Ldap System Administration'
Be more productive and make your life easier. That's what LDAP System Administration is all about.
System administrators often spend a great deal of time managing configuration information located on many different machines: usernames, passwords, printer configurations, email client configurations, and network filesystem configurations, to name a few. LDAPv3 provides tools for centralizing all of the configuration information and placing it under your control. Rather than maintaining several administrative databases (NIS, Active Directory, Samba, and NFS configuration files), you can make changes in only one place and have all your systems immediately "see" the updated information.
Practically platform independent, this book uses the widely available, open source OpenLDAP 2 directory server as a premise for examples, showing you how to use it to help you manage your configuration information effectively and securely. OpenLDAP 2 ships with most Linux® distributions and Mac OS® X, and can be easily downloaded for most Unix-based systems. After introducing the workings of a directory service and the LDAP protocol, all aspects of building and installing OpenLDAP, plus key ancillary packages like SASL and OpenSSL, this book discusses:
More editions of Ldap System Administration:
› Find signed collectible books: 'Learning Perl on Win32 Systems'
In this smooth, carefully paced course, leading Perl trainers and a Windows NT practitioner teach you to program in the language that promises to emerge as the scripting language of choice on NT. With a foreword by Larry Wall, the creator of Perl, this book is the "official" guide for both formal (classroom) and informal learning. Based on the "llama book," Learning Perl on Win32 Systems features tips for PC users and new NT-specific examples.
Perl for Win32 is a language for easily manipulating text, files, user and group profiles, performance and event logs, and registry entries, and a distribution is available on the Windows NT Resource Kit. Peer-to-peer technical support is now available on the perl.win32.users mailing list.
The contents include:
Erik Olson is director of advanced technologies for Axiom Technologies, LC, where he specializes in providing Win32 development solutions. Randal L. Schwartz and Tom Christiansen have also written Programming Perl, co-authored with Larry Wall and published by O'Reilly & Associates.
More editions of Learning Perl on Win32 Systems:

› Find signed collectible books: 'Learning the Bash Shell'
More editions of Learning the Bash Shell:
› Find signed collectible books: 'Learning the vi Editor'
For many users, working in the Unix environment means using vi, a full-screen text editor available on most Unix systems. Even those who know vi often make use of only a small number of its features.
Learning the vi Editor is a complete guide to text editing with vi. Topics new to the sixth edition include multiscreen editing and coverage of four viclones: vim, elvis, nvi, and vile and their enhancements to vi, such as multi-window editing, GUI interfaces, extended regular expressions, and enhancements for programmers. A new appendix describes vi's place in the Unix and Internet cultures.
Quickly learn the basics of editing, cursor movement, and global search and replacement. Then take advantage of the more subtle power of vi. Extend your editing skills by learning to use ex, a powerful line editor, from within vi. For easy reference, the sixth edition also includes a command summary at the end of each appropriate chapter.
Topics covered include:
More editions of Learning the vi Editor:
› Find signed collectible books: 'Lex and Yacc'
This book shows you how to use two Unix utilities, lex and yacc, in program development. These tools help programmers build compilers and interpreters, but they also have a wider range of applications.
The second edition contains completely revised tutorial sections for novice users and reference sections for advanced users. This edition is twice the size of the first and has an expanded index.
The following material has been added:
More editions of Lex and Yacc:
› Find signed collectible books: 'The Lifebox, the Seashell, And the Soul: What Gnarly Computation Taught Me About Ultimate Reality, the Meaning of Life, And How to Be Happy'
More editions of The Lifebox, the Seashell, And the Soul: What Gnarly Computation Taught Me About Ultimate Reality, the Meaning of Life, And How to Be Happy:
› Find signed collectible books: 'Linux Device Drivers'
Updated to cover version 2.4.x of the Linux kernel, the second edition of Linux Device Drivers remains the best general-purpose, paper-bound guide for programmers wishing to make hardware devices work under the world's most popular open-source operating system. The authors take care to show how to write drivers that are portable--that is, that compile and run under all popular Linux platforms. That, along with the fact that they're careful to explain and illustrate concepts, makes this book very well-suited to any programmer familiar with C but not with the hardware-software interface. It's worth noting that the emphasis in the title is on "device drivers" as much as "Linux". This book will make sense to you if you've never written a driver for any platform before. It helps if you have some Linux or UNIX background, but even that is secondary as a prerequisite to C skill.
For a programming text--and one concerned with low-level instructions and data structures, at that--this book is remarkably rich in prose. You'll typically want to read this book straight through, more or less skipping the code samples, before sketching out your plan for the driver you need to write. Then, go back and pay closer attention to the sections on specific details you need to implement, such as custom task queues. For coding-time details about specific system calls and programming techniques, count on the index to point you to the right passages. --David Wall
Topics covered: Techniques for writing hardware device drivers that run under Linux kernels 2.0.x through 2.2.x. Sections show how to manage memory, time, interrupts, ports and other details of the hardware-software interface. [via]
More editions of Linux Device Drivers:
› Find signed collectible books: 'Observing the User Experience: A Practioner's Guide for User Research'
The gap between who designers and developers imagine their users are, and who those users really are can be the biggest problem with product development. Observing the User Experience will help you bridge that gap to understand what your users want and need from your product, and whether they'll be able to use what you've created.
Filled with real-world experience and a wealth of practical information, this book presents a complete toolbox of techniques to help designers and developers see through the eyes of their users. It provides in-depth coverage of 13 user experience research techniques that will provide a basis for developing better products, whether they're Web, software or mobile based. In addition, it's written with an understanding of how software is developed in the real world, taking tight budgets, short schedules, and existing processes into account.
·Explains how to create usable products that are still original, creative, and unique
·A valuable resource for designers, developers, project managers-anyone in a position where their work comes in direct contact with the end user.
·Provides a real-world perspective on research and provides advice about how user research can be done cheaply, quickly and how results can be presented persuasively
·Gives readers the tools and confidence to perform user research on their own designs and tune their software user experience to the unique needs of their product and its users [via]
More editions of Observing the User Experience: A Practioner's Guide for User Research:
› Find signed collectible books: 'Opensources: Voices from the Open Source Revolution'
Open Sources: Voices from the Open Source Revolution is a fascinating look at the raging debate that is its namesake. Filled with writings from the central players--from Linux creator Linus Torvalds to Perl creator Larry Wall--the book convinces the reader of the overwhelming merits of freeing up the many iterations of software's source code.
The open-source movement has become a cause célèbre in light of the widespread adoption of Linux, Perl, and Apache as well as its corporate support from Netscape, IBM, and Oracle--and strongly felt opposition from Microsoft. Open Sources doesn't address why these Microsoft foes are throwing their weight behind the movement. Instead, it focuses on the history and philosophy of open-source software (previously referred to as freeware) as an argument for shaping the future of programming. Open Sources is much larger than just a fight with any one company. Instead, it is a revolutionary call to release software development from the vested interests that label new directions in software development as threatening.
This is not to say that opening the source code is an entirely egalitarian and communistic endeavor. These are programmers and startup owners; they want to be able to continue to program for a living. To that end, Open Sources contains strong business profiles from entrepreneurs such as Apache's--and now, O'Reilly & Associates'--Brian Behlendorf, who discusses how to give away software in order to lure customers in for specialized versions. In many ways, this is a hands-on guide, displaying an insider's view of the development process and providing specifics on testing details and altering licensing agreements. However, interspersed with tech talk is a reader-friendly guide for those interested in the future of software development. --Jennifer Buckendorff [via]
More editions of Opensources: Voices from the Open Source Revolution:

› Find signed collectible books: 'Oracle Database Administration: The Essential Reference'
More editions of Oracle Database Administration: The Essential Reference:

› Find signed collectible books: 'Palmpilot: The Ultimate Guide'
More editions of Palmpilot: The Ultimate Guide:
› Find signed collectible books: 'Perl 5 Desktop Reference'
This "official" quick-reference guide to the Perl programming language has been enlarged to provide a summary of Perl syntax rules, a complete list of standard library modules with brief descriptions, and a precedence table for Perl operators. The guide is current with Perl version 5.003.
Perl, having previously established itself as the UNIX scripting tool of choice, is establishing itself as the tool of choice in numerous programming spheres, ranging from the World Wide Web to general-purpose programming. Perl combines in one language virtually all the functionality of the C, sed, and awk programming languages, as well as many functions of a shell.
The Perl 5 Desktop Reference provides a complete overview of Perl, from variables to input and output, from flow control to regular expressions -- all packaged into a convenient, carry-around guide that can easily be inserted into your favorite Perl programming manual.
More editions of Perl 5 Desktop Reference:

› Find signed collectible books: 'Perl in a Nutshell: A Desktop Quick Reference'
More editions of Perl in a Nutshell: A Desktop Quick Reference:

› Find signed collectible books: 'Perl/Tk Pocket Reference'
More editions of Perl/Tk Pocket Reference:

› Find signed collectible books: 'Practical File System Design With the Be File System'
More editions of Practical File System Design With the Be File System:
› Find signed collectible books: 'Practical Unix and Internet Security'
Practical Unix & Internet Security is on its second edition, and its maturity shows. To call this highly readable book comprehensive is an understatement. The breadth is vast, from fundamentals (definitions of computer security; the history of Unix) and commonsense but little-observed security basics (making backups; physical and personnel security; buggy software) to modern software (NFS, WWW, firewalls) and the handling of security incidents. The section on users and passwords alone is 21 pages long--and worth every page. Useful appendices include a Unix security checklist, a list of emergency response organisations, and many references to electronic and paper resources.
The Internet covers too much and moves too quickly for any book to cover every security aspect of every piece of software, but this book comes close. More importantly, it gives you an exceptional grounding in the fundamental issues of security and teaches the right questions to ask--something that will stay with you long after today's software is obsolete. --Jake Bond [via]
More editions of Practical Unix and Internet Security:

› Find signed collectible books: 'Principles of Transaction Processing'
More editions of Principles of Transaction Processing:

› Find signed collectible books: 'Programming Php'
More editions of Programming Php:

› Find signed collectible books: 'The Puzzler's Elusion: A Tale of Fraud, Pursuit, and the Art of Logic'
More editions of The Puzzler's Elusion: A Tale of Fraud, Pursuit, and the Art of Logic:
› Find signed collectible books: 'Qbasic by Example'
This Special Edition provides beginning programmers with a helpful format that simplifies the programming learning experience.
[via]› Find signed collectible books: 'Readings in Computer Architecture'
Thanks to the continued exponential advances in semiconductor design and the demands of evolving and emerging application domains, the field of computer architecture has never been more dynamic. This, the first major book of computer architecture readings in over two decades, captures this dynamism and reveals Computer Architecture's rich history of practice.
This is much more than a simple collection of papers. The editors have carefully selected the most influential primary sources in specific areas of inquiry that, taken together, present the critical issues of the entire discipline. These include issues in technology, implementation, economics, evaluation methods, instruction set design, instruction level parallelism, dataflow/multithreading, memory systems, input/output systems, single-instruction multiple data parallelism, and multiple-instruction multiple data parallelism. In addition, you'll find the editors' thoughtful, focused introductions to each area, providing the context and background necessary for understanding the significance and lasting impact of these papers.
The primary sources and insightful commentary contained in this book provide foundational knowledge for computer architects as well as for those who design supporting system software and compilers. This is an excellent resource for practitioners, instructors, students, and researchers.
More editions of Readings in Computer Architecture:

› Find signed collectible books: 'Readings in Intelligent User Interfaces'
More editions of Readings in Intelligent User Interfaces:
› Find signed collectible books: 'Sed & Awk'
sed & awk describes two text processing programs that are mainstays of the UNIX programmer's toolbox.
sed is a "stream editor" for editing streams of text that might be too large to edit as a single file, or that might be generated on the fly as part of a larger data processing step. The most common operation done with sed is substitution, replacing one block of text with another.
awk is a complete programming language. Unlike many conventional languages, awk is "data driven" -- you specify what kind of data you are interested in and the operations to be performed when that data is found. awk does many things for you, including automatically opening and closing data files, reading records, breaking the records up into fields, and counting the records. While awk provides the features of most conventional programming languages, it also includes some unconventional features, such as extended regular expression matching and associative arrays. sed & awk describes both programs in detail and includes a chapter of example sed and awk scripts.
This edition covers features of sed and awk that are mandated by the POSIX standard. This most notably affects awk, where POSIX standardized a new variable, CONVFMT, and new functions, toupper() and tolower(). The CONVFMT variable specifies the conversion format to use when converting numbers to strings (awk used to use OFMT for this purpose). The toupper() and tolower() functions each take a (presumably mixed case) string argument and return a new version of the string with all letters translated to the corresponding case.
In addition, this edition covers GNU sed, newly available since the first edition. It also updates the first edition coverage of Bell Labs nawk and GNU awk (gawk), covers mawk, an additional freely available implementation of awk, and briefly discusses three commercial versions of awk, MKS awk, Thompson Automation awk (tawk), and Videosoft (VSAwk).
More editions of Sed & Awk:
› Find signed collectible books: 'Smileys'
From the people who put an armadillo on the cover of a system administrator book comes this collection of the computer underground hieroglyphs called "smileys." Originally inserted into email messages to denote "said with a cynical smile":-), smileys now run rampant throughout the electronic mail culture. They include references to politics 7:^] (Ronald Reagan), entertainment C]:-= (Charlie Chaplin), history 4:-) (George Washington), and mythology @-) (cyclops). They can laugh out loud %-(I) wink ;-) yell :-(0) frown :-( and even drool :-)~
More editions of Smileys:

› Find signed collectible books: 'Software Portability With Imake'
Imake is a utility that works with make to enable code to be compiled and installed on different UNIX machines. Imake makes possible the wide portability of the X Window System code and is widely considered an X tool, but it's also useful for any software project that needs to be ported to many UNIX systems.
This Nutshell Handbook®--the only book available on imake--is ideal for X and UNIX programmers who want their software to be portable. The book is divided into two sections. The first section is a general explanation of imake, X configuration files, and how to write and debug an Imakefile. The second section describes how to write configuration files and presents a configuration file architecture that allows development of coexisting sets of configuration files. Several sample sets of configuration files are described and are available free over the Net.
More editions of Software Portability With Imake:
› Find signed collectible books: 'Solaris Advanced System Administrator's Guide'
Written in a task-oriented, no-nonsense style, this authorized guide is designed to help the Solaris system administrator handle tough projects with a minimal amount of fuss. The reader is first presented with conceptual and background information on each topic and then given step-by-step instructions to perform the task. [via]
More editions of Solaris Advanced System Administrator's Guide:

› Find signed collectible books: 'Subdivision Methods for Geometric Design: A Constructive Approach'
More editions of Subdivision Methods for Geometric Design: A Constructive Approach:

› Find signed collectible books: 'Tcl/Tk in a Nutshell'
More editions of Tcl/Tk in a Nutshell:
› Find signed collectible books: 'Tcp/Ip Network Administration'
This book will be indispensable to Unix system administrators. It describes how to set up and administer a network of Unix systems using the TCP/IP protocols, taking a thoroughly practical approach. Topics covered include basic system configuration, routing, common network applications, and many others. [via]
More editions of Tcp/Ip Network Administration:

› Find signed collectible books: 'Texturing & Modeling: A Procedural Approach'
More editions of Texturing & Modeling: A Procedural Approach:

› Find signed collectible books: 'Transactional Information Systems: Theory, Algorithms, and the Practice of Concurrency Control and Recovery'
More editions of Transactional Information Systems: Theory, Algorithms, and the Practice of Concurrency Control and Recovery:

› Find signed collectible books: 'Understanding Japanese Information Processing'
More editions of Understanding Japanese Information Processing:
› Find signed collectible books: 'Understanding Networked Applications: A First Course'
Designed for use in undergraduate and graduate courses in Information/Library Science, Telecom, Business, Engineering and Medical Infomatics programs, this textbook offers nonexperts an accessible, thoughtful introduction to the applications and infrastructure in networked computing, providing information to make the right technological and organizational decisions in working with developers to design or acquire effective computing solutions.
Understanding the rich conjunction of networking and computing is essential for anyone involved in the formulation and implementation of new application ideas, whether in business, education, or government. Most non-computer science students entering the IT profession today have not been adequately prepared to work with, let alone take advantage of the computing infrastructures they'll encounter in the real world. The only courses that currently discuss aspects of this environment in any detail are in Computer Science departments, and are at a level that is considerably too advanced for their needs and backgrounds. And these courses are not likely to cover the economic, societal, and governmental issues that are also important for them to understand.
This is probably the first book in computing that takes a top-down approach, starting with applications. The focus is on explaining core concepts and terminology, getting into technical detail only where necessary. Example and analogies from everyday life help students to better understand concepts such as object-oriented programming, data mining, encryption, firewalls, etc. which might otherwise seem intimidating. Peppered throughout are sidebars that contain anecdotes, more detailed explanations, and additional examples that give students a refreshing break from the running text.
* Takes a functional, top-down approach, moving from application opportunities to a forward-looking view of the possibilities and limitations of networking and computing technologies.
* Uses plain English to explain important networked computing terminology and concepts, such as security, middleware, and electronic payments.
* Offers frank and enlightening discussions of general application categories, hardware and software infrastructure, up-and-coming communication technologies, and policy issues--social, economic, and governmental--affecting the future of networked computing. [via]
More editions of Understanding Networked Applications: A First Course:

› Find signed collectible books: 'Understanding Your Users: A Practical Guide to User Requirements, Methods, Tools and Techniques'
More editions of Understanding Your Users: A Practical Guide to User Requirements, Methods, Tools and Techniques:

› Find signed collectible books: 'Unix Quick Reference'
More editions of Unix Quick Reference:

› Find signed collectible books: 'Using Microsoft Project 4 for Windows'
More editions of Using Microsoft Project 4 for Windows:

› Find signed collectible books: 'Virtual Private Networks'
More editions of Virtual Private Networks:
› Find signed collectible books: 'Web Client Programming With Perl'
If you've ever wanted to learn more about Web protocols so you could build custom client-side tools to automate tasks--or just so you have a better understanding of what's happening behind the scenes--then Web Client Programming with Perl is the book for you. Wong explains HTTP (Hypertext Transfer Protocol) requests and socket calls, then shows how you can use the LWP library for Perl to retrieve Web pages, parse HTML, check whether a server is responding, and more. [via]
More editions of Web Client Programming With Perl:

› Find signed collectible books: 'Windows 95 Registry Troubleshooting'
More editions of Windows 95 Registry Troubleshooting:
› Find signed collectible books: 'Writing Apache Modules With Perl and C'
Writing Apache Modules with Perl and C will allow you to enhance your Apache HTTP server in just about any way you'd like. Overall, it is an excellent book, and it has a lot of good information and terrific examples on everything from "Content Handlers" to customizing the Apache server configuration process.
It's quickly apparent that Lincoln Stein and Doug MacEachern spent valuable time writing this book considering the breadth of their subject and the depth they devote to it. The only downside to the book is that it's kind of hard to explain all of the API functionality without assuming a minimum level of competence from the audience. For that reason, this book might be a bit intimidating to novice programmers, but it really rewards you if you put time into it and tinker with things.
The book also works well as a source of ideas and inspiration for when you have to write your own server modules, and I'd recommend it if you want to customize your Apache server or speed up your Perl CGI programs. --Doug Beaver [via]
More editions of Writing Apache Modules With Perl and C:

› Find signed collectible books: 'X Protocol Reference Manual for Version 11 of the X Window System'
More editions of X Protocol Reference Manual for Version 11 of the X Window System:

› Find signed collectible books: 'X Toolkit Intrinsics Programming Manual for X11, Release 5'
More editions of X Toolkit Intrinsics Programming Manual for X11, Release 5:
› Find signed collectible books: 'X Toolkit Intrinsics Reference Manual for Version 11 of the Window System'
The X Toolkit Intrinsics Reference Manual is a complete programmer's reference for the X Toolkit. It provides reference pages for each of the Xt functions as well as the widget classes defined by Xt and the Athena widgets.
This volume is based on Xt documentation from the X Consortium and has been re-edited, reorganized, and expanded. Contents include:
The third edition of Volume 5 has been completely revised. In addition to covering Release 4 and Release 5 of X, all the man pages have been completely rewritten for clarity and ease of use, and new examples and descriptions have been added throughout the book.
This manual is a companion to Volume 4M, X Toolkit Intrinsics Programming Manual.
More editions of X Toolkit Intrinsics Reference Manual for Version 11 of the Window System:

› Find signed collectible books: 'Xlib Programming Manual : For R4-R5'
More editions of Xlib Programming Manual : For R4-R5:
