Core Python Programming, Second Edition
By Wesley J. Chun
Publisher: Prentice Hall
Pub Date: September 18, 2006
Print ISBN-10: 0-13-226993-7
Print ISBN-13: 978-0-13-226993-3
Pages: 1120

Praise for Core Python Programming

"The long-awaited second edition of Wesley Chun's Core Python Programming proves to be well worth the waitits deep and broad coverage and useful exercises will help readers learn and practice good Python."

Alex Martelli, author of Python in a Nutshell and editor of Python Cookbook

"There has been lot of good buzz around Wesley Chun's Core Python Programming. It turns out that all the buzz is well earned. I think this is the best book currently available for learning Python. I would recommend Chun's book over Learning Python (O'Reilly), Programming Python (O'Reilly), or The Quick Python Book (Manning)."

David Mertz, Ph.D., IBM DeveloperWorks®

"I have been doing a lot of research [on] Python for the past year and have seen a number of positive reviews of your book. The sentiment expressed confirms the opinion that Core Python Programming is now considered the standard introductory text."

Richard Ozaki, Lockheed Martin

"Finally, a book good enough to be both a textbook and a reference on the Python language now exists."

Michael Baxter, Linux Journal

"Very well written. It is the clearest, friendliest book I have come across yet for explaining Python, and putting it in a wider context. It does not presume a large amount of other experience. It does go into some important Python topics carefully and in depth. Unlike too many beginner books, it never condescends or tortures the reader with childish hide-and-seek prose games. [It] sticks to gaining a solid grasp of Python syntax and structure."

http://python.org bookstore Web site

"[If ] I could only own one Python book, it would be Core Python Programming by Wesley Chun. This book manages to cover more topics in more depth than Learning Python but includes it all in one book that also more than adequately covers the core language. [If] you are in the market for just one book about Python, I recommend this book. You will enjoy reading it, including its wry programmer's wit. More importantly, you will learn Python. Even more importantly, you will find it invaluable in helping you in your day-to-day Python programming life. Well done, Mr. Chun!"

Ron Stephens, Python Learning Foundation

"I think the best language for beginners is Python, without a doubt. My favorite book is Core Python Programming."

s003apr, MP3Car.com Forums

"Personally, I really like Python. It's simple to learn, completely intuitive, amazingly flexible, and pretty darned fast. Python has only just started to claim mindshare in the Windows world, but look for it to start gaining lots of support as people discover it. To learn Python, I'd start with Core Python Programming by Wesley Chun."

Bill Boswell, MCSE, Microsoft Certified Professional Magazine Online

"If you learn well from books, I suggest Core Python Programming. It is by far the best I've found. I'm a Python newbie as well and in three months time I've been able to implement Python in projects at work (automating MSOffice, SQL DB stuff, etc.)."

ptonman, Dev Shed Forums

"Python is simply a beautiful language. It's easy to learn, it's cross-platform, and it works. It has achieved many of the technical goals that Java strives for. A one-sentence description of Python would be: 'All other languages appear to have evolved over time--but Python was designed.' And it was designed well. Unfortunately, there aren't a large number of books for Python. The best one I've run across so far is Core Python Programming."

Chris Timmons, C. R. Timmons Consulting

"If you like the Prentice Hall Core series, another good full-blown treatment to consider would be Core Python Programming. It addresses in elaborate concrete detail many practical topics that get little, if any, coverage in other books."

Mitchell L Model, MLM Consulting

"Core Python Programming is an amazingly easy read! The liberal use of examples helps clarify some of the more subtle points of the language. And the comparisons to languages with which I'm already familiar (C/C++/Java) get you programming in record speed."

Michael Santos, Ph.D., Green Hills Software

The Complete Developer's Guide to PythonFully Updated for Python 2.5

New to Python? The definitive guide to Python development for experienced programmers

Covers core language features thoroughly, including those found in the latest Python releases

Learn advanced topics such as regular expressions, networking, multithreading, GUI, and Web/CGI

Includes brand-new chapters on database, Internet, Jython, and COM Client programming

Presents hundreds of code samples and practical exercises to strengthen your Python skills

Python is an agile, robust, expressive, fully object-oriented, extensible, and scalable programming language. It combines the power of compiled languages with the simplicity and rapid development of scripting languages. In Core Python Programming, Second Edition, leading Python developer and trainer Wesley Chun helps you learn Python quickly and comprehensively so that you can immediately succeed with any Python project.

Using practical code examples, Chun introduces all the fundamentals of Python programming: syntax, objects and memory management, data types, operators, files and I/O, functions, generators, error handling and exceptions, loops, iterators, functional programming, object-oriented programming and more. After you learn the core fundamentals of Python, he shows you what you can do with your new skills, delving into advanced topics, such as regular expressions, networking programming with sockets, multithreading, GUI development, Web/CGI programming and extending Python in C.

This edition reflects major enhancements in the Python 2.x series, including 2.5 as well as capabilities set for future versions. It contains new chapters on database and Internet client programming, plus coverage of many new topics, including new-style classes, Java and Jython, Microsoft Office (Win32 COM Client) programming, and much more.

Learn professional Python style, best practices, and good programming habits

Gain a deep understanding of Python's objects and memory model as well as its OOP features, including those found in Python's new-style classes

Build more effective Web, CGI, Internet, and network and other client/server applications

Learn how to develop your own GUI applications using Tkinter and other toolkits available for Python

Improve the performance of your Python applications by writing extensions in C and other languages, or enhance I/O-bound applications by using multithreading

Learn about Python's database API and how to use a variety of database systems with Python, including MySQL, Postgres, and SQLite

Core Python Programming delivers

Systematic, expert coverage of Python's core features

Powerful insights for developing complex applications

Easy-to-use tables and charts detailing Python modules, operators, functions, and methods

Dozens of professional-quality code examples, from quick snippets to full-fledged applications

Download the free chm ebook: Core Python Programming, Second Edition

Chris Crawford on Game Design
By Chris Crawford
   
Publisher : New Riders Publishing
Pub Date : June 10, 2003
ISBN : 0-13-146099-4
Pages : 496

Chris Crawford on Game Design is all about the foundational skills behind the design and architecture of a game. Without these skills, designers and developers lack the understanding to work with the tools and techniques used in the industry today. Chris Crawford, the most highly sought after expert in this area, brings an intense opinion piece full of personality and flare like no other person in this industry can. He explains the foundational and fundamental concepts needed to get the most out of game development today. An exceptional precursor to the two books soon to be published by New Riders with author Andrew Rollings, this book teaches key lessons; including, what you can learn from the history of game play and historical games, necessity of challenge in game play, applying dimensions of conflict, understanding low and high interactivity designs, watching for the inclusion of creativity, and understanding the importance of storytelling. In addition, Chris brings you the wish list of games he'd like to build and tells you how to do it. Game developers and designers will kill for this information! 

Twenty years have passed since I wrote my first book, The Art of Computer Game Design. Much has transpired during that time: Games have grown up. Twenty years ago, one programmer working for less than a year could produce a top-quality game. Nowadays, a team of a dozen specialists labors for several years to give birth to a commercial product. A dozen narrow specialties have sprung up: game designer, level designer, sound effects designer, 3D programmer, AI programmer, music designer, writer, and more. Budgets for games have risen from about $25K in 1980 to several million dollars today—a hundredfold increase! And the hardware on which we work has improved by at least a thousandfold.

Yet games haven't become a thousandfold or even a hundredfold better. Today's games are unquestionably more impressive than the games of 1982, but the advances we have seen aren't commensurate with the progress of the hardware or the budgets. Indeed, some people who nostalgically play the old-time games aver that modern games are no more fun. Games are bigger, splashier, more impressive, but not much more fun, they claim.

LESSON 1
Game design is not at all the same as game programming.
 

De gustibus non est disputandem—you can't argue about taste. We'll never agree on just how much more fun the new games are. But we can agree that the games have not improved commensurately with the technology. Clearly, technological progress does not automatically make games more fun. There's something else at work here, something that can't be nailed down in program code. It's often called the fun factor, but I don't like the term—it suggests that fun is a standard component that can be stuffed into a game somewhere between the mouse input code and the 3D graphics engine. I prefer to think of it as simply good game design: a soft, fuzzy concept involving a great deal of expertise, some rules of thumb, and strong intuition.

Game design shares nothing with game programming; they are completely separate fields of endeavor. True, a game designer must understand programming just as a game programmer must know something of game design. Yet as these two fields have progressed, they have diverged; master game designers focus their energies on mental challenges utterly different from those that bedevil master game programmers. This book is about the problems of game design; it has no truck with technical problems, for which a plethora of books await the reader.

Since game design is so soft and fuzzy, this book cannot offer simple answers with the directness and clarity that a technical work could provide. Alas, we must struggle with vague theories instead of precise formulations; rough guidelines instead of polished specifications; abstract concepts instead of direct rules. In many cases we must accept mutually incompatible concepts, uncertain where the dividing line between them lies. It comes with the job.

LESSON 2
It's easier to learn from turkeys than from masterworks.
 

Fortunately, we have a vast array of experience on which to draw. In the last twenty years, some twenty thousand games have been published. Most of these were pretty lousy; some were good; and a handful were excellent. We can learn from all of these games. Indeed, the turkeys are the most instructive, because often a turkey fails for a single, easily identified reason. A thousand factors make a great game; it's impossible to evaluate them separately when they all sing together in perfect harmony. But when just one factor sings off-key, it stands out with terrible clarity.

My first book, The Art of Computer Game Design, was still being read and recommended twenty years after its publication; I intend for this book to be similarly long-lived. Therefore, I shall not be citing the current popular games. I shall limit my commentary to the great classics, milestones that should be available to any prospective designer. Occasionally, I will pick out some special turkey that beautifully illustrates a design blunder, but when I do so, I shall attempt to describe the game adequately.

Download the free chm ebook: Chris Crawford on Game Design

PUBLISHED BY
Microsoft Press
A Division of Microsoft Corporation
One Microsoft Way
Redmond, Washington 98052-6399
ISBN 0-7356-1127-0
"Microsoft is not retiring COM." -MS Press Release, August 28, 2000

If you were hoping the recent announcements about the Microsoft .NET Framework would prevent you from having to learn the COM+ programming development model, you will be disappointed.

COM+ has gone through many evolutions since the introduction of OLE technology in the early releases of Microsoft Windows. The alphabet soup of OLE, OLE2, ActiveX, COM, and COM+ has even inspired highly sought-after T-Shirts at most Microsoft-focused technical conferences. But underlying all of this change in marketing message is a core component development technology that every serious Windows developer should be intimately familiar with.

This book will help lay the foundation for a serious understanding of the programming model underlying the .NET Framework recently introduced by Microsoft. COM+ programming techniques will be essential for solutions built today as well as for architectural solutions of the future.

Microsoft has stated that it will continue to enhance COM+ with future versions of its operating systems. It has already announced the inclusion of Application Partitioning, Application Pooling and Recycling, Last Resource Manager for two phase commits, COM+ applications that can execute as Services, and Configurable Transaction Isolation Level for complex transacted environments in Windows .NET (code-named Whistler). Microsoft has also stated that few features of the .NET Framework behave differently from existing COM components. Two examples include the .NET Framework's automatic memory management vs. COM's reference counting and the .NET Framework's XCOPY deployment vs. COM's registration. Taking full advantage of some of these features will require modifying existing COM components, but core concepts embodied by these technologies will not be new to COM+ developers.

COM+ understanding is essential if you want to create XML-enabled applications as well as leverage the SOAP protocols to develop a new generation of Web Services. With .NET, Microsoft is making COM+ much easier and more productive, as well as enabling the kind of software that will be as revolutionary to software development as the introduction of the graphical user interface.

It is worth noting the credentials of the people who wrote this book.

Ray Brown created the majority of the material covered in this book, and he is without doubt the driving force behind it. Ray has over 10 years of industry experience and has used everything.

Wade Brown wrote Chapter 11 about the four-tier enterprise application architecture. Wade has over 12 years of industry experience. He has developed applications exclusively in Microsoft-centered technologies for the last 7 years and is currently a Principal Consultant at Magenic Technologies. He has developed everything from MRP systems to bond calculators for the insurance industry. He brings a strong business perspective to the technology in his chapter.

Chad Chadwick is the baby of the group with 9 years of development experience, most of it in Microsoft technology. His chapter about the newly introduced SOAP protocols (Chapter 12) will give you valuable insights into some of the key underpinnings of Microsoft's .NET strategy. Chad is currently a Practice Lead for e-commerce development at Magenic Technologies.

This book will give you a great foundation for levering the COM+ technologies presented and a great leg up on the emerging .NET Framework.

Greg Frankenfield
CEO & MSDN Regional Director
Magenic Technologies, Inc.

Download the free chm ebook: C++ Signing Solutions With Com+ Technologies

 
C++ for Programmers: Deitel® Developer Series
by Paul J. Deitel - Deitel & Associates, Inc.; Harvey M. Deitel - Deitel & Associates, Inc.

--------------------------------------------------------------------------------
 
Publisher: Prentice Hall
Pub Date: January 23, 2009
Print ISBN-10: 0-13-700130-4
Print ISBN-13: 978-0-13-700130-9
Web ISBN-10: 0-13-701849-5
Web ISBN-13: 978-0-13-701849-9
 
Pages: 1056

Welcome to C++ for Programmers! At Deitel & Associates, we write programming language professional books and textbooks for publication by Prentice Hall, deliver programming languages corporate training courses at organizations worldwide and develop Internet businesses. This book is intended for programmers who do not yet know C++, and may or may not know object-oriented programming.

Features of C++ for Programmers
The Tour of the Book section of this Preface will give you a sense of C++ for Programmers' coverage of C++ and object-oriented programming. Here's some key features of the book:

Early Classes and Objects Approach. We present object-oriented programming, where appropriate, from the start and throughout the text.

Integrated Case Studies. We develop the GradeBook class in Chapters 3–7, the Time class in several sections of Chapters 9–10, the Employee class in Chapters 12–13, and the optional OOD/UML ATM case study in Chapters 1–7, 9, 13 and Appendix E.

Unified Modeling Language™ 2 (UML 2). The Unified Modeling Language (UML) has become the preferred graphical modeling language for designers of object-oriented systems. We use UML class diagrams to visually represent classes and their inheritance relationships, and we use UML activity diagrams to demonstrate the flow of control in each of C++'s control statements. We emphasize the UML in the optional OOD/UML ATM case study

Optional OOD/UML ATM Case Study. We introduce a concise subset of the UML 2, then guide you through a first design experience intended for the novice object-oriented designer/programmer. The case study was reviewed by a distinguished team of OOD/UML industry professionals and academics. The case study is not an exercise; rather, it's a fully developed end-to-end learning experience that concludes with a detailed walkthrough of the complete 877-line C++ code implementation. We take a detailed tour of the nine sections of this case study later in the Preface.

Function Call Stack Explanation. In Chapter 6, we provide a detailed discussion (with illustrations) of the function call stack and activation records to explain how C++ is able to keep track of which function is currently executing, how automatic variables of functions are maintained in memory and how a function knows where to return after it completes execution.

Class string. We use class string instead of C-like pointer-based char * strings for most string manipulations throughout the book. We include discussions of char * strings in Chapters 8, 10, 11 and 19 to give you practice with pointer manipulations, to illustrate dynamic memory allocation with new and delete, to build our own String class, and to prepare you for working with char * strings in C and C++ legacy code.

Class Template vector. We use class template vector instead of C-like pointer-based array manipulations throughout the book. However, we begin by discussing C-like pointer-based arrays in Chapter 7 to prepare you for working with C and C++ legacy code and to use as a basis for building our own customized Array class in Chapter 11.

Treatment of Inheritance and Polymorphism. Chapters 12–13 include an Employee class hierarchy that makes the treatment of inheritance and polymorphism clear and accessible for programmers who are new to OOP.

Discussion and Illustration of How Polymorphism Works "Under the Hood." Chapter 13 contains a detailed diagram and explanation of how C++ can implement polymorphism, virtual functions and dynamic binding internally. This gives you a solid understanding of how these capabilities really work. More importantly, it helps you appreciate the overhead of polymorphism—in terms of additional memory consumption and processor time. This helps you determine when to use polymorphism and when to avoid it.

Standard Template Library (STL). This might be one of the most important topics in the book in terms of software reuse. The STL defines powerful, template-based, reusable components that implement many common data structures and algorithms used to process those data structures. Chapter 20 introduces the STL and discusses its three key components—containers, iterators and algorithms. Using STL components provides tremendous expressive power, often reducing many lines of non-STL code to a single statement.

ISO/IEC C++ Standard Compliance. We have audited our presentation against the most recent ISO/IEC C++ standard document for completeness and accuracy. [Note: A PDF copy of the C++ standard (document number INCITS/ISO/IEC 14882-2003) can be purchased at webstore.ansi.org/ansidocstore/default.asp.]

Future of C++. In Chapter 21, which considers the future of C++, we introduce the Boost C++ Libraries, Technical Report 1 (TR1) and C++0x. The free Boost open source libraries are created by members of the C++ community. Technical Report 1 describes the proposed changes to the C++ Standard Library, many of which are based on current Boost libraries. The C++ Standards Committee is revising the C++ Standard. The main goals for the new standard are to make C++ easier to learn, improve library building capabilities, and increase compatibility with the C programming language. The last standard was published in 1998. Work on the new standard, currently referred to as C++0x, began in 2003. The new standard is likely to be released in 2009. It will include changes to the core language and, most likely, many of the libraries in TR1. We overview the TR1 libraries and provide code examples for the "regular expression" and "smart pointer" libraries.

Debugger Appendices. We include two Using the Debugger appendices—Appendix G, Using the Visual Studio Debugger, and Appendix H, Using the GNU C++ Debugger.

Code Testing on Multiple Platforms. We tested the code examples on various popular C++ platforms. For the most part, the book's examples port easily to standard-compliant compilers.

Errors and Warnings Shown for Multiple Platforms. For programs that intentionally contain errors to illustrate a key concept, we show the error messages that result on several popular platforms.

All of this was carefully reviewed by distinguished industry developers and academics. We believe that this book will provide you with an informative, interesting, challenging and entertaining C++ educational experience.

Download the free chm ebook:  C++ for Programmers: Deitel® Developer Series

Beginning Cryptography with Java  
by David Hook  
Wrox Press ?2005 (480 pages)
ISBN:0764596330
For Java developers who want to use cryptography in their applications or to understand how cryptography is being used in Java applications, this book enables you to create and implement secure Java applications and make use of standard protocols.

 Introduction
This book is about using cryptography with Java.

Depending on who you are, you may think of cryptography as a great menace or as a very useful tool. The truth is that in some ways it is neither, in other ways it is both. It's neither because, if you choose, you could easily reduce it to an interesting mathematical game, with no application. It's both because it most definitely gets applied, not always well, and not always for purposes that everyone agrees with. Whichever side of the fence you are on, the one thing everyone agrees with is that the politics surrounding cryptography and access to the technology that allows you to use it have been intense.

Java, on the other hand, is simply a programming language. It arrived on the popular scene in 1995 and has become very popular as a language for writing applications involving the Internet, electronic commerce, or a combination of the two. Other than the odd, often "religious," issue between programmers or companies, the language itself has carried none of the political problems that have accompanied cryptography. However, a language by itself won't allow you to develop secure Internet applications, so it quickly became apparent that it would be necessary to introduce into Java APIs that allowed people to make use of cryptography. When this happened the politics arrived and, for some, using Java suddenly got intense as well. Finally, the politics subsided and we arrived where we are now, with a rich set of APIs that allow developers to use cryptography effectively in application development—providing they know how.

This brings me to why this book was written. People will still wax lyrically about key sizes and PKI (Public Key Infrastructure), but what does it all mean, and what does it mean when you are using Java? The Java APIs afford you a great deal of flexibility, and although this will allow you to implement an application using cryptography at a fundamental level, it will also allow you to tie yourself into some terrible knots. You can avoid this if you understand a few principals about the way the APIs are put together. Furthermore, by understanding the relationships between the high-level APIs and the more fundamental ones, debugging becomes easier and you can recognize when it is not necessary to build things from scratch, as, in some cases, the hard work has already been done. In short, with the right understanding, you can save yourself a lot of work. This book has been written with the aim of providing that understanding.

Who This Book Is For
This book is written for people who are Java developers and are trying to make use of cryptography in their applications and for people who simply want to understand what's going on when cryptography is being used in Java applications. It does assume you are familiar with the Java language, but it does not assume you have any familiarity with any of the APIs it discusses, such as the JCA, JCE, the Bouncy Castle APIs, and JavaMail.

If you are already very familiar with the JCE and the JCA, you might want to skim the first four chapters quickly and start reading thoroughly from Chapter 5 onward; otherwise, I would recommend you start at the beginning. If you do skim the first four chapters, you should pay attention to the development of the utilities class that is added at the start of most chapters. The reason is that the utilities class used in Chapter 5 and onward builds on the work done in the first four chapters.

What This Book Covers
This book has been written to provide you with a basic understanding of how cryptography is done in Java, what some of the issues are in using cryptography in Java, and the higher-level APIs that can save you from both having to reinvent the wheel and also save you from rediscovering mistakes that others have already made.

Of course, discussion is generally not as useful as experience, and the book has been written with numerous examples, each of which should allow you to investigate a specific issue and learn about specific parts of the various Java APIs available to you for implementing cryptography and PKI. In it, you will see how to make use of the APIs available to allow you to

q Do symmetric encryption, asymmetric encryption, and integrity checking.

q Create, validate, and revoke certificates.

q Create and process secured messages and mail.

q Create and use secured channels using SSL.

Naturally, implementing anything in any language always leaves the door open to shooting oneself in the foot, and cryptography is definitely no exception. With this in mind, where possible, examples and their associated explanations have been written to help you avoid some of the common pitfalls, and as this is a beginning book, further reading has also been suggested to allow you to take the concepts further if you need to.

The book has been written to allow you to take full advantage of recent updates in the security APIs with J2SE 5.0; however, you will also find that almost all the examples can be used, with minor modifications, with older JDKs. Barring some specific uses of J2SE 5.0, the minimum version of Java you need to be using to use every API described in the book is JDK 1.3. If you are using an earlier JDK, you can still use this book, but you will find that you will not be able to use all of the examples, such as those dealing with secure mail and SSL.

Download the free chm ebook: Beginning Cryptography with Java 

Enterprise Java for SAP
by Austin Sincock   ISBN:1590590988
Apress © 2003

After many years and several technological near misses, SAP has positioned Enterprise Java to become a key development technology and to play an important role in mission-critical Internet integration. SAP views Enterprise Java as a strong platform that can be used to deploy robust, scalable applications that provide integration with SAP and non-SAP systems. Through a comprehensive set of tutorials and code reviews, this book introduces the latest Java technologies and the techniques you need to start building robust, scalable applications today.

Beginning JSP 2: From Novice to Professional
by Peter den Haan, Lance Lavandowska, Sathya Narayana Panduranga and Krishnaraj Perrumal   ISBN:1590593391
Apress © 2004 (480 pages)

Welcome to Beginning JSP 2: From Novice to Professional. This book is for novices and teaches JavaServer Pages (JSP) 2 using basic principles. You don't need to know any Java to use this book because JSP 2 is a significant development of the JSP technology that has greatly reduced JSP's reliance on Java knowledge. However, to get the most out of supporting technologies and maximize your JSP applications, you need to know some basic Java techniques. We'll teach you these techniques and show you when and where to use the Java language.

The JSP 2 specification is the biggest revision of JSP since its creation. It's now easier for nonprogrammers to build powerful, dynamic Web applications. The authors of this book realize that JSP 2 is a tremendously powerful tool but that it's also a daunting prospect for many nonprogrammers. In response to this, the authors have written an easily accessible guide for those who are beginning their career in Web programming. This book introduces all the important concepts without fuss or overcomplication and always keeps the readers' best interests at heart.

Chapter 1 takes you through the Java and JSP installation processes so you're ready for the rest of the book. Chapter 2 is a Hypertext Markup Language (HTML) recap, which will act as a useful reference for those who already know a little HTML. After running through the basics, the book moves through simple JSP pages in Chapter 3 to working with data in Chapter 4, probably the most common and important task you'll have to undertake when using JSP. After all, what's the point of using dynamic Web pages if you have no dynamic data on which to work?

Chapters 5 and 6 introduce your first Java and show you how to use simple Java utility code to enhance your JSP pages. The emphasis is always on JSP and how Java fits into the new JSP 2 framework. Throughout these chapters you'll slowly build and incrementally improve an application that uses HTML forms, databases, and validation. The book explains each stage and introduces good practice as you learn new techniques.

Chapters 7 and 8 introduce more advanced JSP techniques and use the newly incorporated JSP Tag Library (JSTL) tags to work with dates, times, and formatting. Chapter 8 introduces Extensible Markup Language (XML), the ubiquitous data description specification, and JSP's tools for dealing with it. XML is such an important part of modern Web applications that it's essential in any beginner's handbook. You'll soon find that XML is an inescapable part of today's Web.

Chapters 9 and 10 cover topics that will ensure your applications are well designed and flexible. Specifically, Chapter 9 covers servlets and filters, both of which are Java classes that run alongside JSP pages and add robust functionality to any Web application. Chapter 10 introduces the Model-View-Controller design concept and the Struts framework, which implements it for JSP pages. By using Struts you instantly add good design and flexibility without any of the hard work usually associated with scalable Web applications.

By the time you've finished the book, you'll have an example Web application for taking data, validating it, storing it in a database, and reporting back to the user. However, the real benefit will be in the design under the covers. Your application will use good practice throughout and can form the basis for many similar applications in the future.

I hope you enjoy reading this work and that you have every success in the future.

Matthew Moodie, Editor

Download the free chm ebook: Beginning JSP 2: From Novice to Professional

Automating UNIX and Linux Administration
by Kirk Bauer   ISBN:1590592123
Apress © 2003

Admit it. You are reading this book because you are lazy. Lazy system administrators are wonderful people—who else is willing to spend so much time now in order to do nothing later? We all dream of waking up in the morning, grabbing the laptop from the bedside table, checking our email, and then heading off to the lake for the day.

Using the techniques in this book, you can get closer to the ideal world of fully automated system administration. Although unexpected things always go wrong, we can at least delegate all of the mundane and repetitive tasks to the computer (whose purpose, of course, was to make our lives easier). I will leave it up to you to convince your boss that you only need to come in to work one day per week.

Pro JSP, Third Edition
by Simon Brown et al.   ISBN:1590592255

Welcome to the third edition of Pro JSP, designed to help new and experienced Java developers alike discover the power (and even the joy) of creating Java-based server-side solutions for the Web. If you've programmed with JSP before you'll find that the new features in JSP 2.0 make developing JSP pages easier then ever before and if you only know a little Java then this is your chance to add JSP to your toolbox skills.

JavaServer Pages, or JSP for short, is a server-side technology that takes the Java language, with its inherent simplicity and elegance, and uses it to create highly interactive and flexible web applications. In today's unsure economic climate, having the Java language behind it makes JSP particularly compelling for business: Java is an open language, essentially meaning it doesn't require expensive licenses and thus JSP solutions can be highly cost-effective.

The founding premise of JSP is that HTML can be used to create the basic structure of a web page, and Java code can be mixed in with it to provide the dynamic components of the page that modern web users expect. If you have an understanding of the concepts of HTML and web pages, JSP provides an unbeatable way to learn about creating innovative, interactive content as well as coming to grips with the popular language of Java. This book will be your guide as you step into this exciting new world.

Agile Project Management: How to Succeed in the Face of Changing Project Requirements
by Gary Chin   ISBN:0814471765
AMACOM © 2004 (229 pages)

Today's innovative minds are constantly pushing the envelope: New and often disruptive technologies are filling the product development pipelines of both large and small companies. The business landscape is fast-paced and competitive, and product lifecycles are shorter. Naturally, product development and launch times are also shortening as companies aggressively develop new products and services to compete. This emphasis on speed forces teams to make quick decisions with incomplete information or in an environment of uncertainty. This, in turn, leads to frequent changes in project requirements and direction. Teams need to be light on their feet … they need to be agile!

The need for agility is magnified in highly innovative businesses that are pushing the limits of current technology and thinking, and where key parts of projects often involve discovery or problem solving never encountered before. These types of projects have an inherent uncertainty and involve multiple paths, decision points, and iterations before they can be successfully completed. Technical teams know that it is impossible to precisely plan new discoveries far in advance. Consequently, they only use project management for administrative support, if they use it at all. Their resistance to using project management is, in fact, often valid. The classical project management technique that they have experienced is cumbersome and not as effective in a fast-paced and uncertain environment. Additionally, project management is more often than not perceived as bureaucratic overhead that will probably slow the team down rather than make it more agile. While I don't fully agree with this viewpoint, I see that many of the commonly known PM practices and tools are geared toward large and relatively slow-moving projects.

On a broader scale, companies realize that they must continue to change and remake themselves to remain competitive—to hit their financial targets and drive the business forward. These business-level changes include not only developing new products and services, but also creating the innovative HR practices, marketing messages, partnerships, acquisitions, and reorganizations that will keep them ahead of the competition. In all of these cases, projects are the engines that power the business transformation and, in turn, enable the organizational flexibility necessary to survive in today's world. To this end, most companies recognize that effective and agile project management is essential for their survival. The problem is getting there!

Modern project management, as developed in the post–World War II era, was initially employed to manage large government projects for the military and construction and space industries. It has subsequently evolved and been widely adopted in some form by most large commercial companies. Nowadays, these same project management techniques are well on their way into many medium and small companies. However, as you may guess, what works well for a huge government project may not be the optimal solution for an innovative startup or even a smaller entrepreneurial group within a large company. Those early projects had many unique challenges, such as efficiently managing hundreds of subcontractors, that project management was able to address. The ability to meet these challenges created the momentum that carried project management into the mainstream.

While many of these original characteristics are still present in today's projects, most have evolved along with business in general, and some have changed radically. For the most part, the science of project management has kept pace with the evolution of business over the past few decades. However, in certain areas, project management has not evolved in step with business and therefore cannot effectively address its challenges. It is some of these areas that are the focus of this book.

If we fast-forward from 1950 to 2004, we will notice a dramatic economic shift in business—an increase in the number of small companies versus large companies. This shift was driven largely by the advent of the knowledge-based economy. At one time, only large companies with significant financial capital controlled the resources required to compete in business. Their resources were physical assets, such as buildings, material, and equipment. As knowledge and intellectual property became increasingly more valuable assets, entrepreneurs with little financial capital but significant intellectual capital were able to start small businesses and carve out niches in this new market space.

In their quest to grow and compete, these smaller businesses are looking to PM as a possible competitive advantage. They realize that good PM can add tremendous value to their projects; however, they also recognize that the familiar, classic PM approach is not quite right for them. Yet, they press on, with the understanding that their PM processes will have to undergo optimization over time.

The organizations that need new ideas in (agile) project management the most are likely to be investing the least in developing them.

There are a few subtle points related to this evolution that are worth noting. First, the sponsors and managers of projects generally know that one-size project management does not fit all, so they look to tailor classic PM processes to their particular situation. This approach will address some, but not all, of their challenges. Second, specialized and dedicated process development resources are required to develop, implement, and maintain robust project management processes, especially ones tuned to a unique and dynamic environment. Third, these process development resources quickly dwindle as company size shrinks, yet this is where customized project management processes have perhaps the biggest impact.

In some ways, project management has become a more or less rote mechanical process because it has been proven to work effectively on more or less rote mechanical projects. However, when applied to the more creative, uncertain, and urgent projects, classic PM practices often falter and need assistance. It is in these situations where we will explore various new thinking that will supplement the current body of knowledge on project management and, hopefully, extend its effectiveness into agile environments.

Download the free chm ebook: Agile Project Management: How to Succeed in the Face of Changing Project Requirements

Test-Driven Development By Example
By Kent Beck
    
Publisher : Addison Wesley
Pub Date : November 08, 2002
ISBN : 0-321-14653-0
Pages : 240

Clean code that works - now. This is the seeming contradiction that lies behind much of the pain of programming. Test-driven development replies to this contradiction with a paradox-test the program before you write it.

A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it with modern languages and programming environments, and cooks up a tasty stew guaranteed to satisfy your appetite for clean code that works-now.

Developers face complex programming challenges every day, yet they are not always readily prepared to determine the best solution. More often than not, such difficult projects generate a great deal of stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean tasks, programmers should look to test-driven development (TDD), a proven set of techniques that encourage simple designs and test suites that inspire confidence.

By driving development with automated tests and then eliminating duplication, any developer can write reliable, bug-free code no matter what its level of complexity. Moreover, TDD encourages programmers to learn quickly, communicate more clearly, and seek out constructive feedback.

Readers will learn to:

Solve complicated tasks, beginning with the simple and proceeding to the more complex.

Write automated tests before coding.

Grow a design organically by refactoring to add design decisions one at a time.

Create tests for more complicated logic, including reflection and exceptions.

Use patterns to decide what tests to write.

Create tests using xUnit, the architecture at the heart of many programmer-oriented testing tools.

This book follows two TDD projects from start to finish, illustrating techniques programmers can use to easily and dramatically increase the quality of their work. The examples are followed by references to the featured TDD patterns and refactorings. With its emphasis on agile methods and fast development strategies, Test-Driven Development is sure to inspire readers to embrace these under-utilized but powerful techniques.

Clean code that works, in Ron Jeffries' pithy phrase, is the goal of Test-Driven Development (TDD). Clean code that works is a worthwhile goal for a whole bunch of reasons.

It is a predictable way to develop. You know when you are finished, without having to worry about a long bug trail.

It gives you a chance to learn all of the lessons that the code has to teach you. If you only slap together the first thing you think of, then you never have time to think of a second, better thing.

It improves the lives of the users of your software.

It lets your teammates count on you, and you on them.

It feels good to write it.

But how do we get to clean code that works? Many forces drive us away from clean code, and even from code that works. Without taking too much counsel of our fears, here's what we do: we drive development with automated tests, a style of development called Test-Driven Development (TDD). In Test-Driven Development, we

Write new code only if an automated test has failed

Eliminate duplication

These are two simple rules, but they generate complex individual and group behavior with technical implications such as the following.

We must design organically, with running code providing feedback between decisions.

We must write our own tests, because we can't wait 20 times per day for someone else to write a test.

Our development environment must provide rapid response to small changes.

Our designs must consist of many highly cohesive, loosely coupled components, just to make testing easy.

The two rules imply an order to the tasks of programming.

Red?/span> Write a little test that doesn't work, and perhaps doesn't even compile at first.

Green?/span> Make the test work quickly, committing whatever sins necessary in the process.

Refactor?/span> Eliminate all of the duplication created in merely getting the test to work.

Red/green/refactor梩he TDD mantra.

Assuming for the moment that such a programming style is possible, it further might be possible to dramatically reduce the defect density of code and make the subject of work crystal clear to all involved. If so, then writing only that code which is demanded by failing tests also has social implications.

If the defect density can be reduced enough, then quality assurance (QA) can shift from reactive work to proactive work.

If the number of nasty surprises can be reduced enough, then project managers can estimate accurately enough to involve real customers in daily development.

If the topics of technical conversations can be made clear enough, then software engineers can work in minute-by-minute collaboration instead of daily or weekly collaboration.

Again, if the defect density can be reduced enough, then we can have shippable software with new functionality every day, leading to new business relationships with customers.

So the concept is simple, but what's my motivation? Why would a software engineer take on the additional work of writing automated tests? Why would a software engineer work in tiny little steps when his or her mind is capable of great soaring swoops of design? Courage.

Download the free chm ebook: Test-Driven Development By Example

Executable UML: A Foundation for Model-Driven Architecture
By Stephen J. Mellor, Marc J. Balcer
    
Publisher : Addison Wesley
Pub Date : May 14, 2002
ISBN : 0-201-74804-5
Pages : 416 

Executable UML is a major innovation in the field of software development. It is designed to produce a comprehensive and understandable model of a solution independent of the organization of the software implementation. It is a highly abstract thinking tool that aids in the formalization of knowledge, and is also a way of describing the concepts that make up abstract solutions to software development problems.

This timely new book, Executable UML: A Foundation for Model-Driven Architecture, thoroughly introduces, documents, and explains this important new technology. The authors show how UML can formalize requirements and use cases into a rich set of verifiable diagrams, how it can be used to produce executable and testable models, and how these models can be translated directly into code. In addition, the book explains how individual system domains are woven together by an executable UML model compiler.

The book is full of tips and techniques to help you:

Partition a system into subject matters based on individual aspects

Pick the right level for use case modeling to speed subject matter comprehension

Model classes and focus on relationships to capture subject matter semantics precisely

Express behavior using the newly adopted UML action semantics and action languages

Specify constraints using tags specified in OCL (Object Constraint Language)


In addition, this book tackles topics of particular importance in execution, such as how to:

Synchronize objects by building lifecycles using statechart diagrams

Model relationships and contention safely

Distribute dynamics to avoid unmaintainable controller objects

Verify the models by executing test cases against the statechart diagrams and constraints

Frequently Asked Questions
Is this the only possible Executable UML?

No. This rendition views each object as potentially having a state machine that can execute asynchronously and concurrently. We view this approach as necessary for today's distributed computing environments. However, one could define an executable UML that relies on synchronous method calls between objects to produce a completely synchronous model of the subject matter. Similarly, our particular use of the statechart diagram is not the only possible one.
Is Executable UML a standard?

Yes and No. The notational elements you see in this book conform to UML, and so qualify as a profile of that standard. In addition, the execution semantics defined here conform to UML, though we do both subset UML and impose certain rules to link the elements together. What is not yet a standard is the exact content of what can and should be interchanged so that we can guarantee that any and all model compilers, irrespective of vendor, can compile any arbitrary executable UML model.

Throughout this book, we use standards as much as they are established. In some areas, the book is intended to provide a basis for discussion of what should ultimately become a standard.
Will there be a standard one day, and how might it differ?

Yes, we hope so. Work has begun informally to define a standard and we will encourage and support it. We expect the standard to define an underlying semantics quite similar to that outlined here, and to layer increasingly rich syntax on top.
Does that mean I should wait?

Not at all. This technology is taking off, and the basic elements are already established. Get ahead of the learning curve.
I know hardly anything about UML. Is this book too advanced for me?

We assume you have an intuitive understanding of the goals behind UML, but nothing more. We will show you all the elements you need to build an executable UML model.
I'm a long-time UML user. Do I need this book?

If you want to garner the benefits of Executable UML, then you'll have to learn the elements that make it up. Focus on the definitions we use and the chapters that show how to build and execute models. Skip the notational stuff. Be prepared to unlearn some UML and habits of mind required to model software structure, but not required to specify an executable model.
What happened to adornments such as aggregation or composition?

We don't need them for Executable UML. UML enables you to model software structure, but that's not our purpose here, so those adornments, and many others, are not in our profile.
Some of this seems familiar. Is this just Shlaer-Mellor in UML clothing?

Shlaer-Mellor focused on execution and specification of an abstract solution, not on specifying software structure. UML can be used for both the expression of software structure and the abstract model. Executable UML brings Shlaer-Mellor and UML together by using UML notation and incorporating concepts of execution. We hope this will make execution accessible to a broader community.
I've used Shlaer-Mellor before. Is this any different?

A lot can happen in this industry in ten weeks, let alone the ten years since the publication of Object Lifecycles. First of all, of course, we all now use UML notation and vocabulary. (Resistance was futile.) Executable UML takes a more object-oriented perspective, no longer requiring identifiers or referential attributes, or other traces of Shlaer-Mellor's relational roots.

The addition of an action semantics to the UML is a major step forward. We hope the action semantics, and the very concept of an executable and translatable UML may one day be seen as a significant contribution of the Shlaer-Mellor community.

Progress in tools has also made certain conventions, such as event numbering, less critical to model understanding, though they are still helpful in keeping our minds clear.
Why do you say "Action Semantics?"

Because UML defines only the semantics of actions, it does not define a language.
But how can you execute without an action language?

We use an action semantics朿onforming language that is executable today. We show several other action languages to illustrate that syntax is unimportant.
You use an Online Bookstore case study. Can I use this if I'm a real-time developer?

Yes. We chose a more IT-oriented case study to increase the reach of the approach. You can find a completely worked out real-time case study in Leon Starr's book Executable UML: The Elevator Case Study.
How can I get an Executable UML tool?

All of the examples in this book were developed using Project Technology's tool, BridgePoint. A copy of BridgePoint can be downloaded from the book's website, www.executableUMLbook.com.
How is this different from the old "draw the pictures, get some code" CASE tools?

There are two main differences. First, compiling models produces the whole system, not just interfaces or frameworks. Second, there are many different model compilers available to buy, and even more that can be built, to meet exacting software architecture needs.
Where has Executable UML been used?

Executable UML has been used to generate systems as large as two million lines of C++, and as small as handheld drug delivery devices. Executable UML has also been used in lease-origination, web-enabled executive reporting, and intermodal transportation logistics systems.
Why did you write this book?

Because we had nothing better to do? No: There are lots of books out there that tell you about UML notation, but few of them focus on the subset you need for executability. Many books use UML to describe software structure. We explicitly spurn this usage.
Why should I buy this book?

Because it describes completely everything you need to know about executable UML: It's the Executable UML handbook.

Download the free chm ebook: Executable UML: A Foundation for Model-Driven Architecture

Python Programming on Win32
by Mark Hammond, Andy Robinson
ISBN: 1-56592-621-8
652 pages.

Python is an interpreted, interactive, object-oriented programming language, first developed in 1990 by Guido van Rossum. By the end of 1998, it had grown to an estimated user base of 300,000, and it's beginning to attract wide attention in the industry.

Python doesn't offer revolutionary new features. Rather, it combines many of the best design principles and ideas from many different programming languages. It's simple and powerful. More than any other language, it gets out of the way so that you can think about the problem, not the language. Programming in Python just feels right.

Language Features
Here are some of Python's distinctive features:

Interpreted to bytecodes
Python code lives in text files ending in .py. The program compiles the text files to a machine-independent set of bytecodes in a way similar to Java, which are usually saved in files ending in .pyc; these can then later be imported and run quickly. The source is recompiled only when necessary. Python's speed is of a similar order of magnitude to Java or Perl.

Very high level
All languages support basic types such as strings, integers, and floating-point numbers. Python has higher-level built-in types such as lists and dictionaries, and high-level operations to work on them. For example, you can load a file into a string with one line and split it into chunks based on a delimiter with another line. This means writing less code. It also means that the speed is better than you might suppose: the built-in functions have been written in C and extensively optimized by a lot of smart people, and are faster than C or C++ code you might write yourself.

Interactive mode
You can use Python interactively, entering expressions one line at a time. This mode allows you to try ideas quickly and cheaply, testing each function or method as you write it. This style of programming encourages experimentation and ideas. As with Smalltalk (with which it has much in common), the intera`tive mode is perhaps the major reason your productivity will increase with Python.

The interpreter is always available
Every Python program has the ability to compile and execute text files while running; there is no distinction between the runtime and development environments. This makes it a great macro language for other programs.

Clean syntax
The syntax is straightforward and obvious, and there are no cryptic special characters to learn. Indentation delimits blocks, so the visual structure of a chunk of code mirrors its logical structure; it's easy to read and learn. Eric Raymond, one of the leaders of the Open Source movement, now recommends Python as the ideal first language to learn. (See his essay, "How to Become a Hacker," located at http://www.tuxedo.org/~esr/faqs/hacker-howto.html.)

Advanced language features
Python offers all the features expected in a modern programming language: object-oriented programming with multiple inheritance, exception handling, overloading of common operators, default arguments, namespaces, and packages.

Introspection
Python can introspect to an uncanny degree. You can ask an object what attributes it has at runtime and give it new ones. Hooks are provided to let you control how functions are applied and what to, and when attributes are set and fetched. Magic Methods let you define the meaning of operators, so that you can define the + operation for a matrix class or trap what happens when someone accesses an item in a list. Features from other languages can often be easily implemented in Python itself.

Platform independence
Python is written in ANSI C and is available for a wide range of platforms including Windows, Unix, and Macintosh. The core language and standard libraries are identical on all platforms, although each platform offers its own dedicated extensions.

Extensible
Python is written in C in a modular architecture. It can be extended easily to add new features or APIs. If you want a new feature, you can add it and find plenty of help to do so.

Extensive libraries
The Python library, included in the standard installation, includes over 200 modules, covering everything from operating-system functions and data structures to full-blown web servers. The main Python web site provides a comprehensive index to the many Python projects and third-party libraries. Whatever your problem domain, you will probably find someone else working on it and a good base of code to start with.

Support
Python has a large and enthusiastic user community; it's currently doubling in size every two years. So far, there are four books by O'Reilly alone and several by other publishers, eight annual Python conferences have been held, the comp.lang.python newsgroup on Usenet attracts well over 100 posts a day, and there are a growing number of consultants and small firms offering commercial support.

Download the free chm ebook: Python Programming on Win32

Operating Systems Internals and Design Principles 6th Edition

William Stallings is an author with a mission. He wants both students and seasoned professionals to have a comprehensive text that explains the concepts, structure and mechanisms of operating systems. In this fifth edition of his award-winning book, Stallings provides a thorough discussion of the fundamentals of operating systems design and relates those fundamentals to contemporary design issues and to current directions in the development of operating systems.

Features and Benefits

·Expands the treatment of Linux 2.6 as a case study.

·Includes Microsoft Windows and Unix to illustrate and teach real-world design choices.

·Adds two new major programming projects, one to build a shell or command line interpreter and one to build a process dispatcher.

·Discusses in-depth unique sections on SMP design and multithreading,microkernels and OS support for clusters as well as for real-time scheduling.

·Emphasizes design issues and fundamental principles in contemporary systems, giving students a solid understanding of the key structures and mechanisms of operating systems.

·Revises and expands the material on concurrency.

Download the free pdf ebook: Operating Systems Internals and Design Principles 6th Edition

Advanced Software Testing Vol. 1
by Rex Black
 
Publisher: Rocky Nook
Pub Date: October 15 2008
Print ISBN: 978-1-933952-19-2
Web ISBN: 1-933952-19-9
Pages: 488

Introduction
This is a book on advanced software testing for test analysts. By that I mean that I address topics that a practitioner who has chosen software testing as a career should know. I focus on those skills and techniques related to test analysis, test design, test execution, and test results evaluation. I assume that you know the basic concepts of test engineering, test design, test tools, testing in the software development lifecycle, and test management. You are ready to mature your level of understanding of these concepts and to apply these mature, advanced concepts to your daily work as a test professional.

This book follows the International Software Testing Qualifications Board's (ISTQB) Advanced Level Syllabus, with a focus on the material and learning objectives for the advanced test analyst. As such, this book can help you prepare for ISTQB Advanced Level Test Analyst exam. You can use this book to self-study for those exams or as part of an e-learning or instructor-lead course on the topics covered in those exams. If you are taking an ISTQB-accredited Advanced Level Test Analyst training course, this book is an ideal companion text for that course.

However, even if you are not interested in the ISTQB exams, you will find this book useful to prepare yourself for advanced work in software testing. If you are a test manager, test director, test analyst, technical test analyst, automated test engineer, manual test engineer, programmer, or in any other field where a sophisticated understanding of software testing is needed, then this book is for you.

This book focuses on test analysis. The book consists of 11 chapters, addressing the following material:

Basic aspects of software testing

Testing processes

Test management

Test techniques

Testing of software characteristics

Reviews

Incident (defect) management

Standards and test process improvement

Test tools and automation

People skills (team composition)

Preparing for the exam

Since that structure follows the structure of the ISTQB Advanced Syllabus, some of the chapters address the material in great detail, as they are central to the test analyst role. Some of the chapters address the material in less detail, as the test analyst need only be familiar with it. For example, I cover test techniques in detail in this book because that is central to what a test analyst does, while I spend less time on test management.

If you also read the companion volume to this book, which is for test managers, you'll find parallel chapters that address the material in detail but with different emphasis. For example, test analysts need to know quite a bit about incident management. Test analysts spend a lot of time creating incident reports, and you need to know how to do that well. Test managers also need to know a lot about incident management, but they focus on how to keep incidents moving through their reporting and resolution lifecycle and how to gather metrics from such reports.

What should a test analyst be able to do? Or, to ask the question another way, what should you have learned to do—or learned to do better—by the time you finish this book?

Implement the test strategy with a focus on business domain requirements

Analyze the system based on user quality expectations and apply that analy-sis to the testing to be done

Evaluate the system requirements to determine whether the business objec-tives can be met by that system

Prepare and execute adequate testing activities, and report on the progress of these activities

Provide the necessary evidence and data to support evaluations and findings

Implement the necessary tools and techniques to achieve the defined goals

In this book, we focus on these main concepts. I suggest that you keep these high-level objectives in mind as we proceed through the material in each of the following chapters.

In writing this book and the companion volume on test management, I've kept foremost in my mind the question of how to make this material useful to you. If you are using this book to prepare for an ISTQB Advanced Level Test Analyst exam, then I recommend that you read chapter 11 first, then read the other 10 chapters in order. If you are using this book to expand your overall understanding of testing to an advanced level but do not intend to take an ISTQB Advanced Level Test Analyst exam, then I recommend that you read chapters 1 through 10 only. If you are using this book as a reference, then feel free to read only those chapters that are of specific interest to you.

Each of the first 10 chapters is divided into sections. For the most part, I have followed the organization of the ISTQB Advanced Syllabus to the point of section divisions, but subsections and sub-subsection divisions in the syllabus might not appear. You'll also notice that each section starts with a text box describing the learning objectives for this section. If you are curious about how to interpret those K2, K3, and K4 tags in front of each learning objective, and how learning objectives work within the ISTQB syllabus, read chapter 11.

Software testing is in many ways similar to playing the piano, cooking a meal, or driving a car. How so? In each case, you can read books about these activities, but until you have practiced, you know very little about how to do it. So I've included practical, real-world exercises for the key concepts. I encourage you to practice these concepts with the exercises in the book. Then, make sure you take these concepts and apply them on your projects. You can become an advanced software testing professional only by doing software testing.

Download the free chm ebook: Advanced Software Testing Vol. 1

TCP/IP Illustrated, Volume 2: The Implementation
By Gary R. Wright, W. Richard Stevens
   
Publisher : Addison Wesley
Pub Date : January 12, 1995
ISBN : 0-201-63354-X
Pages : 1200 

This book describes and presents the source code for the common reference implementation of TCP/IP: the implementation from the Computer Systems Research Group (CSRG) at the University of California at Berkeley. Historically this has been distributed with the 4.x BSD system (Berkeley Software Distribution). This implementation was first released in 1982 and has survived many significant changes, much fine tuning, and numerous ports to other Unix and non-Unix systems. This is not a toy implementation, but the foundation for TCP/IP implementations that are run daily on hundreds of thousands of systems worldwide. This implementation also provides router functionality, letting us show the differences between a host implementation of TCP/IP and a router.

We describe the implementation and present the entire source code for the kernel implementation of TCP/IP, approximately 15,000 lines of C code. The version of the Berkeley code described in this text is the 4.4BSD-Lite release. This code was made publicly available in April 1994, and it contains numerous networking enhancements that were added to the 4.3BSD Tahoe release in 1988, the 4.3BSD Reno release in 1990, and the 4.4BSD release in 1993. (Appendix B describes how to obtain this source code.) The 4.4BSD release provides the latest TCP/IP features, such as multicasting and long fat pipe support (for high-bandwidth, long-delay paths). Figure 1.1 provides additional details of the various releases of the Berkeley networking code.

This book is intended for anyone wishing to understand how the TCP/IP protocols are implemented: programmers writing network applications, system administrators responsible for maintaining computer systems and networks utilizing TCP/IP, and any programmer interested in understanding how a large body of nontrivial code fits into a real operating system.

Download the free chm ebook: TCP/IP Illustrated, Volume 2: The Implementation

Enterprise Java Security: Building Secure J2EE Applications
By Marco Pistoia, Nataraj Nagaratnam, Larry Koved, Anthony Nadalin
   
Publisher : Addison Wesley
Pub Date : February 20, 2004
ISBN : 0-321-11889-8
Pages : 608
Slots : 1.0


 The purpose of this book is to illustrate the applicability of Java 2 Platform, Enterprise Edition (J2EE), and Java 2 Platform, Standard Edition (J2SE), security technologies in building a secure enterprise infrastructure containing Java-based enterprise applications. With a pragmatic approach, the book explains why Java security is a key factor in an e-business environment and how application developers can use this technology in building secure enterprise applications.

The book introduces the J2EE and J2SE security architectures, showing how these architectures relate to each other and how they are augmented by Java Authentication and Authorization Service (JAAS) to provide authentication and authorization. Then, the book delves into the J2EE security technologies: The security aspects of servlets, JavaServer Pages (JSP), and Enterprise JavaBeans (EJB) are treated in detail because these technologies constitute the core of the J2EE architecture. To satisfy the needs of developers who need to build J2EE applications and want to do so securely and reliably, the book covers in great detail the relationship between J2EE and cryptographic technologies; Java Cryptography Architecture, Java Cryptography Extension, Public-Key Cryptography Standards, Secure/Multipurpose Internet Mail Extensions, and Java Secure Socket Extension are also described in detail. The book explains how to work with J2EE in practice and shows how the technologies presented work together and are integrated. The scenarios described are targeted to J2EE developers and deployers needing to build an integrated, secure, component-based system. Finally, Web Services security and other emerging technologies are discussed, along with a description of how the underlying middleware works. The book ends by summarizing the impact of J2EE security in today's e-business environments.

Unlike other treatments of Java security, this book discusses the J2SE and J2EE security architectures, providing practical solutions and use patterns to address the challenges that lie ahead as these architectures evolve to address enterprise e-business needs. The goal is to give practical guidance to groups involved in making Java-based applications or Web sites into industrial-strength commercial propositions. Examples are provided to give the reader a clearer understanding of the underlying technology.

To achieve the goals of portability and reusability, J2EE security has been designed to be mainly declarative. Most of the authentication, authorization, integrity, confidentiality, and access-control decisions on a J2EE platform can be made through configuration files and deployment descriptors, which are external to the applications. This reduces the burden on the programmer and allows Java enterprise programs to be portable, reusable, and flexible. For this reason, Parts I and II focus on the declarative approach of Java security by showing examples of configuration files and deployment descriptors. Additionally, these parts of the book explain how to use the programmatic approach if declarative security alone is insufficient. (Sample programs can be found in Chapters 4 and 5.) The majority of the sample code of this book can be found in Parts III and IV.

This book has its roots in several articles we wrote for the IBM Systems Journal and IBM developerWorks, describing the origins of Java security and the security for enterprise applications using the J2EE programming model. Although we are geographically dispersed around the United States, we had gathered in Santa Clara, California, at the O'Reilly Conference on Java in March 2000 to present on a number of security topics. It was clear that developers and managers were not familiar with Java security features, J2EE security, and how to manage security in a J2EE environment. Inquiries on Java and J2EE security were being routed to us via e-mail and through our colleagues. We had already written a book on J2SE security, but a book on security for enterprise applications, including those written for server-based applications and Web Services, was needed.

This book draws and expands on material from multiple sources, including the J2SE security book and articles mentioned. Specifically, this book covers J2SE V1.4 and J2EE V1.4. The relevant specifications for J2EE covered in this book include the J2EE V1.4 specification, the Java Servlet V2.4 specification, the EJB V2.1 specification, and the Web Services specifications. The list of the sources used in this book can be found in Appendix D.

Download the free chm ebook: Enterprise Java Security: Building Secure J2EE Applications

Agile Web Development with Rails
Second Edition
ISBN 0-9776166-3-0
Ruby on Rails is a framework that makes it easier to develop, deploy, and
maintain web applications. During the 12 months that followed its initial
release, Rails went from being an unknown toy to being a worldwide phe-
nomenon. It has won awards, and, more importantly, it has become the
framework of choice for the implementation of a wide range of so-called
Web 2.0 applications. It isn’t just trendy among hard-core hackers: many
multinational companies are using Rails to create their web applications.
Why is that? There seem to be many reasons.
First, there seem to be a large number of developers who were frustrated
with the technologies they were using to create web applications. It didn’t
seem to matter whether they were using Java, PHP,  .NET—there was a
growing sense that things were just too damn hard. And then, suddenly,
along comes Rails, and Rails is easier.
But easy on its own doesn’t cut it. We’re talking about professional devel-
opers writing real-world web sites. They wanted to feel that the applica-
tions they were developing would stand the test of time—that they were
designed and implemented using modern, professional techniques. So these
developers dug into Rails, and discovered it wasn’t just a tool for hacking
out sites.
For example, all Rails applications are implemented using the Model-View-
Controller  (MVC)  architecture. Java  developers  are  used  to  frameworks
such as Tapestry and Struts, which are based on MVC. But Rails takes
MVC further: when you develop in Rails, there’s a place for each piece of
code, and all the pieces of your application interact in a standard way. It’s
as if you start out with the skeleton of an application already prepared.
Professional programmers write tests. And again, Rails delivers. All Rails
applications have testing support baked right in. As you add functionality
to the code, Rails automatically creates test stubs for that functionality.
The framework makes it easy to test applications, and as a result Rails
applications tend to get tested.
Rails applications are written in Ruby, a modern, object-oriented script-
ing language. Ruby is concise without being unintelligibly terse—you can
express ideas naturally and cleanly in Ruby code. This leads to programs
that are easy to write and (just as importantly) are easy to read months
later.

Download the free pdf ebook: Agile Web Development with Rails

Hacking Vim
A cookbook to get the most out of the latest  Vim editor
By Kim Schulz
ISBN 978-1-847190-93-2
Chapter 1 introduces Vim and a few well-known relatives; their history and relation
to vi is briefly described.
Chapter 2 introduces how to make Vim a better editor for you by modifying it for
your personal needs. It shows you ways of modifying fonts, the color scheme, the
status line, menus, and toolbar.
Chapter 3 introduces some of the ways in which Vim helps us to navigate through
files easily. It explains an alternative way for boosting navigation through files and
buffers in Vim.
Chapter 4 introduces you to features in Vim. It describes how to use templates, 
auto-completion, folding, sessions, and working with registers.
Chapter 5 introduces simple tricks to format text and code. It also discusses 
how external tool can be used to give Vim just that extra edge it needs to be the
perfect editor. 
Chapter 6 is especially for those who want to learn how to extend Vim with scripts.
The chapter introduces scripting basics, how to use and install/uninstall scripts,
debugging scripts, and lots more.
Appendix A has a listing of games that have been implemented with Vim scripting; it
also provides an overview of chat and mail scripts and has a section on using Vim as
an IDE.
Appendix B shows how to keep your Vim configuration files well organized and
retain your Vim configuration across computers by storing a copy of it online

Download the free pdf ebook: Hacking Vim.pdf

Beautiful Architecture, 1st Edition
by Diomidis Spinellis; Georgios Gousios
 
Publisher: O'Reilly Media, Inc.
Pub Date: January 29, 2009
Print ISBN-13: 978-0-596-51798-4
 
Pages: 432 

What are the ingredients of robust, elegant, flexible, and maintainable software architecture? Beautiful Architecture answers this question through a collection of intriguing essays from more than a dozen of today's leading software designers and architects. In each essay, contributors present a notable software architecture, and analyze what makes it innovative and ideal for its purpose. Some of the engineers in this book reveal how they developed a specific project, including decisions they faced and tradeoffs they made. Others take a step back to investigate how certain architectural aspects have influenced computing as a whole. With this book, you'll discover:

• How Facebook's architecture is the basis for a data-centric application ecosystem

• The effect of Xen's well-designed architecture on the way operating systems evolve

• How community processes within the KDE project help software architectures evolve from rough sketches to beautiful systems

• How creeping featurism has helped GNU Emacs gain unanticipated functionality

• The magic behind the Jikes RVM self-optimizable, self-hosting runtime

• Design choices and building blocks that made Tandem the choice platform in high-availability environments for over two decades

• Differences and similarities between object-oriented and functional architectural views

• How architectures can affect the software's evolution and the developers' engagement

Go behind the scenes to learn what it takes to design elegant software architecture, and how it can shape the way you approach your own projects, with Beautiful Architecture.

Download the free chm ebook: Beautiful Architecture, 1st Edition

Software Engineering and Computer Games
By Rudy Rucker
   
Publisher : Addison Wesley
Pub Date : December 17, 2002
ISBN : 0-201-76791-0
Pages : 544 

"This book should be a requirement of anyone that wants to write games-period"-Andre Lamothe, author and CEO of Xtreme Games

Software Engineering and Computer Games was written with four broad goals:

• To teach a lively style of object-oriented software engineering.

• To show how to bring a complete program to the level of a commercial release.

• To provide a "game engine" framework of linked classes for game development.

• To help students create computer games that are interactive, rapidly executing, and visually beautiful.

It uses an object-oriented (OO) approach throughout, incorporating UML for OO analysis and design and discussing software patterns and how to make use of them in the design process.The book covers nine topics:

• Basic software engineering principles and techniques

• How to organize and complete a substantial software project.

• Practical examples of object-oriented design and programming.

• The design of computer games.

• Simulating physics inside our computer-generated worlds.

• Artificial life, or how to simulate live creatures inside a computer program.

• How to use two and three-dimensional computer graphics.

• Windows programming with the Microsoft Foundation Classes, or MFC.

• How to develop a project using Microsoft Visual Studio (Either Version 6.0 or .NET)

Download the free chm ebook: Software Engineering and Computer Games

By Michael T. Goodrich

The design and analysis of efficient data structures has long been recognized as a
vital subject in computing, for the study of data structures is part of the core of
every collegiate computer science and computer engineering major program we are
familiar with. Typically, the introductory courses are presented as a two- or three-
course sequence. Elementary data structures are often briefly introduced in the first
programming or introduction to computer science course and this is followed by a
more in-depth introduction to data structures in the following course(s).
Furthermore, this course sequence is typically followed at a later point in the
curriculum by a more in-depth study of data structures and algorithms. We feel that
the central role of data structure design and analysis in the curriculum is fully
justified, given the importance of efficient data structures in most software systems,
including the Web, operating systems, databases, compilers, and scientific
simulation systems.
With the emergence of the object-oriented paradigm as the framework of choice for
building robust and reusable software, we have tried to take a consistent
objectoriented viewpoint throughout this text. One of the main ideas of the object-
oriented approach is that data should be presented as being encapsulated with the
methods that access and modify them. That is, rather than simply viewing data as a
collection of bytes and addresses, we think of data as instances of an abstract data
type (ADT) that include a repertory of methods for performing operations on the
data. Likewise, object-oriented solutions are often organized utilizing common
design patterns, which facilitate software reuse and robustness. Thus, we present
each data structure using ADTs and their respective implementations and we
introduce important design patterns as means to organize those implementations
into classes, methods, and objects.
For each ADT presented in this book, we provide an associated Java interface.
Also, concrete data structures realizing the ADTs are provided as Java classes
implementing the interfaces above. We also give Java implementations of
fundamental algorithms (such as sorting and graph traversals) and of sample
applications of data structures (such as HTML tag matching and a photo album).
Due to space limitations, we sometimes show only code fragments in the book and
make additional source code available on the companion Web site,
http://java.datastructures.net.
The Java code implementing fundamental data structures in this book is organized
in a single Java package, net.datastructures. This package forms a coherent library
of data structures and algorithms in Java specifically designed for educational
purposes in a way that is complementary with the Java Collections Framework.

Download the free pdf ebook: Data Structures And Algorithms in Java 4th Edition.pdf

DWR Java AJAX Applications
A step-by-step example-packed guide to learning professional application development
with Direct  Web Remoting
by Sami Salkosuo

Chapter 1 is a brief introduction to AJAX technology and DWR. It also discusses the
DWR community and describes briefly what information can be found about DWR
on the Internet.

Chapter 2 describes DWR features that we use in the samples of this book—a high-
level view of how DWR makes a developer's life easier. It discusses reverse AJAX,
DWR JavaScript libraries, converters, creators, filters, and signatures. It also contains
a section on integrating DWR with other projects and another on security.

Chapter 3 sets the stage for development by describing how to set up the
development environment and how to test and debug our sample applications. It
covers DWR-supported browsers and environments, configuration, error handling,
packaging, and deployment.

Chapter 4 is the first chapter dedicated to sample code. The examples in this chapter
include typical user interface elements such as tables and lists, and how they can be
implemented using DWR. It also has an example for field completion.

Chapter 5 discusses how to use DWR in more advanced user interface elements such
as forms, navigation tree, and scrolling a map.

Chapter 6 shows how DWR applications are integrated to a database, a web service,
or a messaging system.

Chapter 7 includes two sample applications: Collaborative Book Authoring, which
shows how DWR is used to create a web based multi-user authoring environment,
and Chatroom—a typical multi-user chat room application using DWR.

Download the free pdf ebook: DWR Java AJAX Applications.pdf

The definitive design and deployment guide for secure virtual private networks

• Learn about IPSec protocols and Cisco IOS IPSec packet processing
• Understand the differences between IPSec tunnel mode and transport mode
• Evaluate the IPSec features that improve VPN scalability and fault tolerance, such as dead peer detection and control plane keepalives
• Overcome the challenges of working with NAT and PMTUD
• Explore IPSec remote-access features, including extended authentication, mode-configuration, and digital certificates
• Examine the pros and cons of various IPSec connection models such as native IPSec, GRE, and remote access
• Apply fault tolerance methods to IPSec VPN designs
• Employ mechanisms to alleviate the configuration complexity of a large- scale IPSec VPN, including Tunnel End-Point Discovery (TED) and Dynamic Multipoint VPNs (DMVPN)
• Add services to IPSec VPNs, including voice and multicast
• Understand how network-based VPNs operate and how to integrate IPSec VPNs with MPLS VPNs

Among the many functions that networking technologies permit is the ability for organizations to easily and securely communicate with branch offices, mobile users, telecommuters, and business partners. Such connectivity is now vital to maintaining a competitive level of business productivity. Although several technologies exist that can enable interconnectivity among business sites, Internet-based virtual private networks (VPNs) have evolved as the most effective means to link corporate network resources to remote employees, offices, and mobile workers. VPNs provide productivity enhancements, efficient and convenient remote access to network resources, site-to-site connectivity, a high level of security, and tremendous cost savings.

IPSec VPN Design is the first book to present a detailed examination of the design aspects of IPSec protocols that enable secure VPN communication. Divided into three parts, the book provides a solid understanding of design and architectural issues of large-scale, secure VPN solutions. Part I includes a comprehensive introduction to the general architecture of IPSec, including its protocols and Cisco IOS® IPSec implementation details. Part II examines IPSec VPN design principles covering hub-and-spoke, full-mesh, and fault-tolerant designs. This part of the book also covers dynamic configuration models used to simplify IPSec VPN designs. Part III addresses design issues in adding services to an IPSec VPN such as voice and multicast. This part of the book also shows you how to effectively integrate IPSec VPNs with MPLS VPNs.

IPSec VPN Design provides you with the field-tested design and configuration advice to help you deploy an effective and secure VPN solution in any environment.

This security book is part of the Cisco Press® Networking Technology Series. Security titles from Cisco Press help networking professionals secure critical data and resources, prevent and mitigate network attacks, and build end-to-end self-defending networks.

About the Author

Vijay Bollapragada, CCIE® No. 1606, is a senior manager in the Network Systems Integration and Test Engineering group at Cisco Systems® where he works on the architecture, design, and validation of complex network solutions.

Mohamed Khalid, CCIE No. 2435, is a technical leader working with IP VPN solutions at Cisco®. He works extensively with service providers across the globe and their associated Cisco account teams to determine technical and engineering requirements for various IP VPN architectures.

Scott Wainner is a Distinguished Systems Engineer in the U.S. Service Provider Sales Organization at Cisco Systems where he focuses on VPN architecture and solution development. In this capacity, he provides customer guidance on IP VPN architectures and drives internal development initiatives within Cisco Systems.

Download the free chm ebook: IPSec VPN Design.chm

Advanced Programming in the UNIX® Environment: Second Edition
By W. Richard Stevens, Stephen A. Rago
Publisher: Addison Wesley Professional
Pub Date: June 17, 2005
ISBN: 0201433079
Pages: 960

"Stephen Rago's update is a long overdue benefit to the community of professionals using the versatile family of UNIX and UNIX-like operating environments. It removes obsolescence and includes newer developments. It also thoroughly updates the context of all topics, examples, and applications to recent releases of popular implementations of UNIX and UNIX-like environments. And yet, it does all this while retaining the style and taste of the original classic."--Mukesh Kacker, cofounder and former CTO of Pronto Networks, Inc."One of the essential classics of UNIX programming."--Eric S. Raymond, author of The Art of UNIX Programming"This is the definitive reference book for any serious or professional UNIX systems programmer. Rago has updated and extended the classic Stevens text while keeping true to the original. The APIs are illuminated by clear examples of their use. He also mentions many of the pitfalls to look out for when programming across different UNIX system implementations and points out how to avoid these pitfalls using relevant standards such as POSIX 1003.1, 2004 edition and the Single UNIX Specification, Version 3."--Andrew Josey, Director, Certification, The Open Group, and Chair of the POSIX 1003.1 Working Group"Advanced Programming in the UNIX® Environment, Second Edition, is an essential reference for anyone writing programs for a UNIX system. It's the first book I turn to when I want to understand or re-learn any of the various system interfaces. Stephen Rago has successfully revised this book to incorporate newer operating systems such as GNU/Linux and Apple's OS X while keeping true to the first edition in terms of both readability and usefulness. It will always have a place right next to my computer."--Dr. Benjamin Kuperman, Swarthmore CollegePraise for the First Edition"Advanced Programming in the UNIX® Environment is a must-have for any serious C programmer who works under UNIX. Its depth, thoroughness, and clarity of explana-tion are unmatched."--UniForum Monthly"Numerous readers recommended Advanced Programming in the UNIX® Environment by W. Richard Stevens (Addison-Wesley), and I'm glad they did; I hadn't even heard of this book, and it's been out since 1992. I just got my hands on a copy, and the first few chapters have been fascinating."--Open Systems Today"A much more readable and detailed treatment of UNIX internals can be found in Advanced Programming in the UNIX® Environment by W. Richard Stevens (Addison-Wesley). This book includes lots of realistic examples, and I find it quite helpful when I have systems programming tasks to do."--RS/Magazine"This is the definitive reference book for any serious or professional UNIX systems programmer. Rago has updated and extended the original Stevens classic while keeping true to the original."--Andrew Josey, Director, Certification, The Open Group, and Chair of the POSIX 1003.1 Working GroupFor over a decade, serious C programmers have relied on one book for practical, in-depth knowledge of the programming interfaces that drive the UNIX and Linux kernels: W. Richard Stevens' Advanced Programming in the UNIX® Environment. Now, Stevens' colleague Stephen Rago has thoroughly updated this classic to reflect the latest technical advances and add support for today's leading UNIX and Linux platforms.Rago carefully retains the spirit and approach that made this book a classic. Building on Stevens' work, he begins with basic topics such as files, directories, and processes, carefully laying the groundwork for understanding more advanced techniques, such as signal handling and terminal I/O.Substantial new material includes chapters on threads and multithreaded programming, using the socket interface to drive interprocess communication (IPC), and extensive coverage of the interfaces added to the latest version of the POSIX.1 standard. Nearly all examples have been tested on four of today's most widely used UNIX/Linux platforms: FreeBSD 5.2.1; the Linux 2.4.22 kernel; Solaris 9; and Darwin 7.4.0, the FreeBSD/Mach hybrid underlying Apple's Mac OS X 10.3.As in the first edition, you'll learn through example, including more than 10,000 lines of downloadable, ANSI C source code. More than 400 system calls and functions are demonstrated with concise, complete programs that clearly illustrate their usage, arguments, and return values. To tie together what you've learned, the book presents several chapter-length case studies, each fully updated for contemporary environments.Advanced Programming in the UNIX® Environment has helped a generation of programmers write code with exceptional power, performance, and reliability. Now updated for today's UNIX/Linux systems, this second edition will be even more indispensable.

Download the free chm ebook: Advanced Programming in the UNIX Environment: Second Edition

By Steven Holzner
Publisher: Addison Wesley Professional
Pub Date: April 12, 2005
ISBN: 0-13-149862-2
Pages: 360


The fastest route to true PHP mastery!So...you've been asked to pitch in on a PHP project...starting now. Or maybe one's on the horizon. Or maybe you need to get real PHP skills onto your resume. You've done web stuff. Maybe used other scripting languages. Now you want to get productive with PHP, fast.Welcome. We wrote this book for you. We'll leverage what you already know, so you'll go further, faster than you ever expected.You'll get the real nuts and bolts, not theory or hooey. You'll learn through dozens of focused examples: tested for reliability, crafted for clarity, easy to adapt for your own projects.Need specific solutions? This book's modular, high-efficiency format delivers theminstantly. Award-winning author Steven Holzner draws on his unparalleled experience teaching programming: No other PHP guide covers this much, this well, this quickly. Dig in, get started, get resultstoday! All you need to succeed with PHP in Linux or Windows Master core concepts: operators, flow control, strings, arrays, functions, and more Learn essential web techniques: cookies, session management, automated email, FTP, and more Use PHP 5's object model and object-oriented techniques Efficiently handle text boxes, buttons, and other HTML controls Create web forms, validate user input, and check browsers Work with MySQL and other databasesIncludes concise PHP 5 language and functional references!All the book's programming examples are available for download on the companion web site.Spring Into is a new series of fast-paced tutorials from Addison-Wesley. Each book in the series is designed to bring you up-to-speed quickly. Complex topics and technologies are reduced to their core components, and each component is treated with remarkable efficiency in one- or two-page spreads. Just the information you need to begin working...now! And because the books are example-rich and easy to navigate, you'll find that they make great on-the-job references after you've mastered the basics.

Download the free chm ebook: Addison Wesley Spring into PHP 5

By Edmond Woychowsky
Publisher: Prentice Hall
Pub Date: August 08, 2006
Print ISBN-10: 0-13-227267-9
Print ISBN-13: 978-0-13-227267-4
Pages: 432

The Easy, Example-Based Guide to Ajax for Every Web Developer

 

Using Ajax, you can build Web applications with the sophistication and usability of traditional desktop

applications and you can do it using standards and open source software. Now, for the first time,

there's an easy, example-driven guide to Ajax for every Web and open source developer, regardless of

experience.

 

Edmond Woychowsky begins with simple techniques involving only HTML and basic JavaScript. Then,

one step at a time, he introduces techniques for building increasingly rich applications. Don't worry if

you're not an expert on Ajax's underlying technologies; Woychowsky offers refreshers on them, from

JavaScript to the XMLHttpRequest object. You'll also find multiple open source technologies and open

standards throughout, ranging from Firefox to Ruby and MySQL.

 

You'll not only learn how to write "functional" code, but also master design patterns for writing rocksolid,

high-performance Ajax applications. You'll also learn how to use frameworks such as Ruby on

Rails to get the job done fast.

 

• Learn how Ajax works, how it evolved, and what it's good for

• Understand the flow of processing in Ajax applications

• Build Ajax applications with XML and the XMLHttpRequest object

• Integrate back-end code, from PHP to C#

• Use XSLT and XPath, including XPath Axis

• Develop client-side Ajax libraries to support code reuse

• Streamline development with Ruby on Rails and the Ruby programming language

• Use the cross-browser HTML DOM to update parts of a page

• Discover the best Ajax Web resources, including Ajax-capable JavaScript libraries

Download the free chm ebook: Ajax: Creating Web Pages with Asynchronous JavaScript and XML

By Lincoln D. Stein
   
Publisher : Addison Wesley
Pub Date : December 15, 2000
ISBN : 0-201-61571-1
Pages : 784

The network is everywhere. At the office, machines are wired together into local area networks, and the local networks are interconnected via the Internet. At home, personal computers are intermittently connected to the Internet or, increasingly, via "always-on" cable and DSL modems. New wireless technologies, such as Bluetooth, promise to vastly expand the network realm, embracing everything from cell phones to kitchen appliances.

Such an environment creates tremendous opportunities for innovation. Whole new classes of applications are now predicated on the availability of high-bandwidth, always-on connectivity. Interactive games allow players from around the globe to compete on virtual playing fields and the instant messaging protocols let them broadcast news of their triumphs to their friends. New peer-to-peer systems, such as Napster and Gnutella, allow people to directly exchange MP3 audio files and other types of digital content. The SETI@Home project takes advantage of idle time on the millions of personal computers around the world to search for signs of extraterrestrial life in a vast collection of cosmic noise.

The ubiquity of the network allows for more earthbound applications as well. With the right knowledge, you can write a robot that will fetch and summarize prices from competitors' Web sites; a script to page you when a certain stock drops below a specified level; a program to generate daily management reports and send them off via e-mail; a server that centralizes some number-crunching task on a single high-powered machine, or alternatively distributes that task among the multiple nodes of a computer cluster.

Whether you are searching for the best price on a futon or for life in a distant galaxy, you'll need to understand how network applications work in order to take full advantage of these opportunities. You'll need a working understanding of the TCP/IP protocol—the common denominator for all Internet-based communications and the most common protocol in use in local area networks as well. You'll need to know how to connect to a remote program, to exchange data with that program, and what to do when something goes wrong. To work with existing applications, such as Web servers, you'll have to understand how the application-level protocols are built on top of TCP/IP, and how to deal with common data exchange formats such as XML and MIME.

This book uses the Perl programming language to illustrate how to design and implement practical network applications. Perl is an ideal language for network programming for a number of reasons. First, like the rest of the language, Perl's networking facilities were designed to make the easy things easy. It takes just two lines of code to open a network connection to a server somewhere on the Internet and send it a message. A fully capable Web server can be written in a few dozen lines of code.

Second, Perl's open architecture has encouraged many talented programmers to contribute to an ever-expanding library of useful third-party modules. Many of these modules provide powerful interfaces to common network applications. For example, after loading the LWP::Simple module, a single function call allows you to fetch the contents of a remote Web page and store it in a variable. Other third-party modules provide intuitive interfaces to e-mail, FTP, net news, and a variety of network databases.

Perl also provides impressive portability. Most of the applications developed in this book will run without modification on UNIX machines, Windows boxes, Macintoshes, VMS systems, and OS/2.

However, the most compelling reason to choose Perl for network application development is that it allows you to fully exploit the power of TCP/IP. Perl provides you with full access to the same low-level networking calls that are available to C programs and other natively compiled languages. You can create multicast applications, implement multiplexed servers, and design peer-to-peer systems. Using Perl, you can rapidly prototype new networking applications and develop interfaces to existing ones. Should you ever need to write a networking application in C or Java, you'll be delighted to discover how much of the Perl API carries over into these languages.

Download the free chm ebook: Network Programming with Perl

By Philip Romanik, Amy Muntz
  
Publisher : Addison Wesley
Pub Date : April 21, 2003
ISBN : 0-321-10894-9
Pages : 352

"I really like the software engineering advice given here. As the chief engineer/architect for a large development group, I can say with certainty that the advice given in this book about how real-world projects must work is right on the mark."
-Steve Vinoski, coauthor of Advanced CORBA Programming with C++, columnist for C/C++ Users Journal and IEEE Internet Computing, and Chief Architect, IONA Technologies

Applied C++ is a practical, straightforward guide to developing high-quality, maintainable software. It reflects the power of C++, templates, and the Standard Template Library for industrial-strength programming. Whether you are a single developer or work in a large team, the tips and techniques presented in this book will help you improve your language and design skills and show you how to solve substantial problems more effectively.

The authors, drawing on their extensive professional experience, teach largely by example. To illustrate software techniques useful for any application, they develop a toolkit to solve the complex problem of digital image manipulation. By using a concrete, real-world problem and describing exact feature, performance, and extensibility requirements, the authors show you how to leverage existing software components and the tools inherent in C++ to speed development, promote reuse, and deliver successful software products.

Inside Applied C++, you will find:

• A C++ templates primer

• Workable coding guidelines and extensive coding examples

• Quick lists of need-to-know information about Exceptions, Assertions, and Standard Template Library components

• A technique for effectively using prototypes to move your design from an initial concept to a robust solution

• A technique for building debugging support into your software without a ton of overhead

• Thirteen specific techniques to improve the overall performance of your software

Download the free chm ebook: Applied C++: Practical Techniques for Building Better Software

By W. Richard Stevens, Bill Fenner, Andrew M. Rudoff
  
Publisher : Addison Wesley
Pub Date : November 21, 2003
ISBN : 0-13-141155-1
Pages : 1024

"Everyone will want this book because it provides a great mix of practical experience, historical perspective, and a depth of understanding that only comes from being intimately involved in the field. I've already enjoyed and learned from reading this book, and surely you will too."
-Sam Leffler

The classic guide to UNIX networking APIs... now completely updated!

To build today's highly distributed, networked applications and services, you need deep mastery of sockets and other key networking APIs. One book delivers comprehensive, start-to-finish guidance for building robust, high-performance networked systems in any environment: UNIX Network Programming, Volume 1, Third Edition.

Building on the legendary work of W. Richard Stevens, this edition has been fully updated by two leading network programming experts to address today's most crucial standards, implementations, and techniques. New topics include:

• POSIX Single UNIX Specification Version 3

• IPv6 APIs (including updated guidance on IPv6/IPv4 interoperability)

• The new SCTP transport protocol

• IPsec-based Key Management Sockets

• FreeBSD 4.8/5.1, Red Hat Linux 9.x, Solaris 9, AIX 5.x, HP-UX, and Mac OS X implementations

• New network program debugging techniques

• Source Specific Multicast API, the key enabler for widespread IP multicast deployment

The authors also update and extend Stevens' definitive coverage of these crucial UNIX networking standards and techniques:

• TCP and UDP transport

• Sockets: elementary, advanced, routed, and raw

• I/O: multiplexing, advanced functions, nonblocking, and signal-driven

• Daemons and inetd

• UNIX domain protocols

• ioctl operations

• Broadcasting and multicasting

• Threads

• Streams

• Design: TCP iterative, concurrent, preforked, and prethreaded servers

Since 1990, network programmers have turned to one source for the insights and techniques they need: W. Richard Stevens' UNIX Network Programming. Now, there's an edition specifically designed for today's challenges-and tomorrow's.

Download the free chm ebook: UNIX Network Programming Volume 1, Third Edition: The Sockets Networking API

By Cliff Binstock, Dave Peterson, Mitchell Smith, Mike Wooding, Chris Dix, Chris Galtenberg
   
Publisher : Addison Wesley
Pub Date : September 27, 2002
ISBN : 0-672-32374-5
Pages : 1008

With the successful implementation of XML Schema, developers are learning how to increase productivity, improve software reliability, minimize development time, and decrease time to market. This in-depth reference is an all-in-one resource designed to help developers leverage the power and potential of XML schemas by offering a complete roadmap to their creation, design, and use.

This authoritative reference and tutorial is filled with practical insights and detailed examples. The book begins by providing a conceptual introduction to XML Schema. From there, coverage shifts to the W3C Schema Recommendation and how to apply schemas to specific business goals. The authors provide insight and instruction throughout on integrating XML schemas into existing technologies such as .NET, Java, Visual Basic, Oracle, and more. The book concludes with a complete case study designed to reinforce and illustrate material covered.

Additional topics include:

• Applications for schemas

• Simple and complex types

• XML schema processing and validation

• Namespaces in XML

• Using schemas with DOM and SAX

• XML schema document syntax

• XML Information Sets

• XML Schema applications of XPath

Whether designing a schema from scratch or integrating schemas into contemporary technologies, The XML Schema Complete Reference is the most complete and definitive sourcebook available for the XML Schema environment.

Download the free chm: The XML Schema Complete Reference

By W. Richard Stevens

This book describes the TCP/IP protocol suite, but from a different perspective than other texts on TCP/IP. Instead of just describing the protocols and what they do, we'll use a popular diagnostic tool to watch the protocols in action. Seeing how the protocols operate in varying circumstances provides a greater understanding of how they work and why certain design decisions were made. It also provides a look into the implementation of the protocols, without having to wade through thousands of lines of source code.

When networking protocols were being developed in the 1960s through the 1980s, expensive, dedicated hardware was required to see the packets going "across the wire." Extreme familiarity with the protocols was also required to comprehend the packets displayed by the hardware. Functionality of the hardware analyzers was limited to that built in by the hardware designers.

Today this has changed dramatically with the ability of the ubiquitous workstation to monitor a local area network [Mogul 1990]. Just attach a workstation to your network, run some publicly available software (described in Appendix A), and watch what goes by on the wire. While many people consider this a tool to be used for diagnosing network problems, it is also a powerful tool for understanding how the network protocols operate, which is the goal of this book.

This book is intended for anyone wishing to understand how the TCP/IP protocols operate: programmers writing network applications, system administrators responsible for maintaining computer systems and networks utilizing TCP/IP, and users who deal with TCP/IP applications on a daily basis.

Download the free chm: Tcp/Ip illustrated, volume 1, the protocols.chm

By Chris Adamson, Joshua Marinacci
Publisher: O'Reilly
Pub Date: June 2005
ISBN: 0-596-00907-0
Pages: 542

Swing Hacks helps Java developers move beyond the basics of Swing, the graphical user interface (GUI) standard since Java 2. If you're a Java developer looking to build enterprise applications with a first-class look and feel, Swing is definitely one skill you need to master. This latest title from O'Reilly is a reference to the cool stuff in Swing. It's about the interesting things you learn over the years--creative, original, even weird hacks--the things that make you say, "I didn't know you could even do that with Swing!"

Swing Hacks will show you how to extend Swing's rich component set in advanced and sometimes non-obvious ways. The book touches upon the entire Swing gamut-tables, trees, sliders, spinners, progress bars, internal frames, and text components. Detail is also provided on JTable/JTree, threaded component models, and translucent windows. You'll learn how to filter lists, power-up trees and tables, and add drag-and-drop support.

Swing Hacks will show you how to do fun things that will directly enhance your own applications. Some are visual enhancements to make your software look better. Some are functional improvements to make your software do something it couldn't do before. Some are even just plain silly, in print only to prove it could be done. The book will also give you give you a small glimpse of the applications coming in the future. New technology is streaming into the Java community at a blistering rate, and it gives application developers a whole new set of blocks to play with.

With its profusion of tips and tricks, Swing Hacks isn't just for the developer who wants to build a better user interface. It's also ideally suited for client-side Java developers who want to deliver polished applications, enthusiasts who want to push Java client application boundaries, and coders who want to bring powerful techniques to their own applications.

Whatever your programming needs, Swing Hacks is packed with programming lessons that increase your competency with interface-building tools.

Download the free chm ebook: Swing.Hacks.chm

by Douglas Crockford
Publisher: O'Reilly
Pub Date: May 2, 2008
Print ISBN-13: 978-0-596-51774-8
Pages: 170

Most programming languages contain good and bad parts, but JavaScript has more than its share of the bad, having been developed and released in a hurry before it could be refined. This authoritative book scrapes away these bad features to reveal a subset of JavaScript that's more reliable, readable, and maintainable than the language as a whole-a subset you can use to create truly extensible and efficient code. Considered the JavaScript expert by many people in the development community, author Douglas Crockford identifies the abundance of good ideas that make JavaScript an outstanding object-oriented programming language-ideas such as functions, loose typing, dynamic objects, and an expressive object literal notation. Unfortunately, these good ideas are mixed in with bad and downright awful ideas, like a programming model based on global variables. When Java applets failed, JavaScript became the language of the Web by default, making its popularity almost completely independent of its qualities as a programming language. In JavaScript: The Good Parts, Crockford finally digs through the steaming pile of good intentions and blunders to give you a detailed look at all the genuinely elegant parts of JavaScript, including:

• Syntax

• Objects

• Functions

• Inheritance

• Arrays

• Regular expressions

• Methods

• Style

• Beautiful features

The real beauty? As you move ahead with the subset of JavaScript that this book presents, you'll also sidestep the need to unlearn all the bad parts. Of course, if you want to find out more about the bad parts and how to use them badly, simply consult any other JavaScript book. With JavaScript: The Good Parts, you'll discover a beautiful, elegant, lightweight and highly expressive language that lets you create effective code, whether you're managing object libraries or just trying to get Ajax to run fast. If you develop sites or applications for the Web, this book is an absolute must.

Free chm download:  OReilly.JavaScript.The.Good.Parts.May.2008.chm

When we wrote the first edition of this book, it was not very common for college courses on
networking to include programming components. That seems difficult to believe now, when
the Internet has become so important to our world, and the pedagogical benefits of hands-on
programming and real-world protocol examples are so widely accepted. Although there are now
other languages that provide access to the Internet, interest in the original C-based Berkeley
Sockets  remains high. The Sockets API (application programming interface) for networking
was developed at UC Berkeley in the 1980s for the BSD flavor of UNIX—one of the very first
examples of what would now be called an open-source project.
The Sockets API and the Internet both grew up in a world of many competing protocol
families—IPX, Appletalk, DECNet, OSI, and SNA in addition to Transmission Control Proto-
col/Internet Protocal (TCP/IP)—and Sockets was designed to support them all. Fewer protocol
families were in common use by the time we wrote the first edition of this book, and the num-
ber today is even smaller. Nevertheless, as we predicted in the first edition, the Sockets API
remains important for those who want to design and build distributed applications that use
the Internet—that is, that use TCP/IP. And the interface has proven robust enough to support
the new version of the Internet Protocol (IPv6), which is now supported on virtually all common
computing platforms.
Two main considerations motivated this second edition. First, based on our own experi-
ence and feedback from others, we found that some topics needed to be presented in more
depth and that others needed to be expanded. The second consideration is the increasing
acceptance and use of IP version 6, which is now supported by essentially all current end sys-
tem platforms. At this writing, it is not possible to use IPv6 to exchange messages with a large
fraction of hosts on the Internet, but it is possible to assign an IPv6 address to many of them.
Although it is still too early to tell whether IPv6 will take over the world, it is not too early to
start writing applications to be prepared.

Download the free ebook: TCP IP Sockets in C, Second Edition Practical Guide for Programmers

Publisher: O'Reilly
Pub Date: June 2005
ISBN: 0-596-00795-7
Pages: 234

System developers have used modeling languages for decades to specify, visualize, construct, and document systems. The Unified Modeling Language (UML) is one of those languages. UML makes it possible for team members to collaborate by providing a common language that applies to a multitude of different systems. Essentially, it enables you to communicate solutions in a consistent, tool-supported language.

Today, UML has become the standard method for modeling software systems, which means you're probably confronting this rich and expressive language more than ever before. And even though you may not write UML diagrams yourself, you'll still need to interpret diagrams written by others.

UML 2.0 in a Nutshell from O'Reilly feels your pain. It's been crafted for professionals like you who must read, create, and understand system artifacts expressed using UML. Furthermore, it's been fully revised to cover version 2.0 of the language.

This comprehensive new edition not only provides a quick-reference to all UML 2.0 diagram types, it also explains key concepts in a way that appeals to readers already familiar with UML or object-oriented programming concepts.

Topics include:

• The role and value of UML in projects

• The object-oriented paradigm and its relation to the UML

• An integrated approach to UML diagrams

• Class and Object, Use Case, Sequence, Collaboration, Statechart, Activity, Component, and Deployment Diagrams

• Extension Mechanisms

• The Object Constraint Language (OCL)

If you're new to UML, a tutorial with realistic examples has even been included to help you quickly familiarize yourself with the system.

Free chm ebook download: UML 2.0 in a Nutshell

By David Flanagan
Publisher: O'Reilly
Pub Date: August 2006
Print ISBN-10: 0-596-10199-6
Print ISBN-13: 978-0-59-610199-2
Pages: 1018

This Fifth Edition is completely revised and expanded to cover JavaScript as it is used in today's Web 2.0 applications. This book is both an example-driven programmer's guide and a keep-on-your-desk reference, with new chapters that explain everything you need to know to get the most out of JavaScript, including:

• Scripted HTTP and Ajax

• XML processing

• Client-side graphics using the <canvas> tag

• Namespaces in JavaScript--essential when writing complex programs

• Classes, closures, persistence, Flash, and JavaScript embedded in Java applications

Part I explains the core JavaScript language in detail. If you are new to JavaScript, it will teach you the language. If you are already a JavaScript programmer, Part I will sharpen your skills and deepen your understanding of the language.

Part II explains the scripting environment provided by web browsers, with a focus on DOM scripting with unobtrusive JavaScript. The broad and deep coverage of client-side JavaScript is illustrated with many sophisticated examples that demonstrate how to:

• Generate a table of contents for an HTML document

• Display DHTML animations

• Automate form validation

• Draw dynamic pie charts

• Make HTML elements draggable

• Define keyboard shortcuts for web applications

• Create Ajax-enabled tool tips

• Use XPath and XSLT on XML documents loaded with Ajax

• And much more

Part III is a complete reference for core JavaScript. It documents every class, object, constructor, method, function, property, and constant defined by JavaScript 1.5 and ECMAScript version 3.

Part IV is a reference for client-side JavaScript, covering legacy web browser APIs, the standard Level 2 DOM API, and emerging standards such as the XMLHttpRequest object and the <canvas> tag.

Download the free chm ebook: JavaScript: The Definitive Guide, 5th Edition

This book is meant primarily for two types of people. The first is web developers or front-end
engineers who know some JavaScript and wish to learn more. Specifically, those who want to
improve their understanding of the object-oriented capabilities of JavaScript and learn how
they can make their code more modular, maintainable, and efficient. This book will teach
these readers about the basics of object-oriented programming in JavaScript. It will also teach
them about specific design patterns, showing when they can be used and how to implement
them. This type of reader will already be familiar with the basic JavaScript syntax and will focus
more on the sections that deal with converting existing code to implement specific patterns,
and explanations of when each pattern should or shouldn’t be used.
The second type of readers are programmers who are more involved with server-side
languages such as Java and C++ and are relative beginners in JavaScript. They wish to use
their knowledge of design patterns and object-oriented programming and put it to use in
a client-side language. This book will teach these readers how to implement commonly
used object-oriented idioms in JavaScript, such as interfaces, inheritance, and encapsula-
tion. These readers will find the code samples particularly useful because they may not be
familiar with the differences in syntax between JavaScript and other object-oriented lan-
guages. This type of reader may already be familiar with specific design patterns and so
may get more out of the JavaScript-specific, object-oriented techniques covered in Part 1.
Readers who are unfamiliar with the basics of JavaScript and object-oriented program-
ming may have a tough time following some of the examples. This is not an entry-level text,
and it assumes a certain level of programming knowledge. That being said, we do our best to
explain each concept as simply and clearly as possible, to make it easy to understand regard-
less of your level of expertise.

Download the free pdf: Pro JavaScript Design Patterns .pdf

This book is organized into 50 separate items covering ten important areas. The
selected best practices are organized in a sequence that parallels the phases of the
system development life cycle.
The reader can approach the material sequentially, item-by-item and part-by-part,
or simply refer to specific items when necessary to gain information about and
understanding of a particular problem. For the most part, each chapter stands on its
own, although there are references to other chapters, and other books, where
helpful to provide the reader with additional information.
Chapter 1 describes requirements-phase considerations for the testing effort. It is
important in the requirements phase for all stakeholders, including a representative
of the testing team, to be involved in and informed of all requirements and
changes. In addition, basing test cases on requirements is an essential concept for
any large project. The importance of having the testing team represented during
this phase cannot be overstated; it is in this phase that a thorough understanding of
the system and its requirements can be obtained.
Chapter 2 covers test-planning activities, including ways to gain understanding of
the goals of the testing effort, approaches to determining the test strategy, and
considerations related to data, environments, and the software itself. Planning must
take place as early as possible in the software life cycle, as lead times must be
considered for implementing the test program successfully. Early planning allows
for testing schedules and budgets to be estimated, approved, and incorporated into
the overall software development plan. Estimates must be continually monitored
and compared to actuals, so they can be revised and expectations can be managed
as required.
Chapter 3 focuses on the makeup of the testing team. At the core of any
successful testing program are its people. A successful testing team has a mixture
of technical and domain knowledge, as well as a structured and concise division of
roles and responsibilities. Continually evaluating the effectiveness of each test-
team member throughout the testing process is important to ensuring success.
Chapter 4 discusses architectural considerations for the system under test. Often
overlooked, these factors must be taken into account to ensure that the system itself
is testable, and to enable gray-box testing and effective defect diagnosis.
Chapter 5 details the effective design and development of test procedures,
including considerations for the creation and documentation of tests, and discusses
the most effective testing techniques. As requirements and system design are
refined over time and through system-development iterations, so must the test
procedures be refined to incorporate the new or modified requirements and system
functions.
Chapter 6 examines the role of developer unit testing in the overall testing
strategy. Unit testing in the implementation phase can result in significant gains in
software quality. If unit testing is done properly, later testing phases will be more
successful. There is a difference, however, between casual, ad-hoc unit testing
based on knowledge of the problem, and structured, repeatable unit testing based
on the requirements of the system.
Chapter 7 explains automated testing tool issues, including the proper types of
tools to use on a project, the build-versus-buy decision, and factors to consider in
selecting the right tool for the organization. The numerous types of testing tools
available for use throughout the phases in the development life cycle are described
here. In addition, custom tool development is also covered.
Chapter 8 discusses selected best practices for automated testing. The proper use
of capture/playback tools, test harnesses, and regression testing are described.
Chapter 9 provides information on testing nonfunctional aspects of a software
application. Ensuring that nonfunctional requirements are met, including
performance, security, usability, compatibility, and concurrency testing, adds to the
overall quality of the application.
Chapter 10 provides a strategy for managing the execution of tests, including
appropriate methods of tracking test-procedure execution and the defect life cycle,
and gathering metrics to assess the testing process.

Download the free pdf: effective software testing