Here’s a comprehensive, up-to-date and practical introduction to software test design. This invaluable book presents all the important test design techniques in a single place and in a consistent, and easy-to-digest format. An immediately useful handbook for test engineers, developers, quality assurance professionals, and requirements and systems analysts, it enables you to: choose the best test case design, find software defects in less time and with fewer resources, and develop optimal strategies that help reduce the likelihood of costly errors. It also assists you in estimating the effort, time and cost of good testing.

Numerous case studies and examples of software testing techniques are included, helping you to fully understand the practical applications of these techniques. From well-established techniques such as equivalence classes, boundary value analysis, decision tables, and state-transition diagrams, to new techniques like use case testing, pairwise testing, and exploratory testing, the book is an indispensable resource for testing professionals seeking to improve their skills and an excellent reference for college-level courses in software test design.

This book is about programming per se. It is about the most elementary principles of program construction—problem decomposition, invariant properties, and guarantees of progress. It is intended to appeal to both novice programmers, who wish to start on the right track, and to experienced programmers who wish to properly master their craft.

Although the subject matter of the book is 'elementary', in the sense of foundational, it is not 'easy'. Programming is challenging, and it is wrong to skirt the issues or to wrap it up  in a way that makes it seem otherwise. I have lectured on this material for many years, mostly to undergraduates on computing science degrees, and, occasionally, to professional programmers. Inevitably, it is the experienced programmers who appreciate its value the most. Novice programmers have the additional  hurdle of learning how to write code—too often in a highly complex programming language. For them, the problem is the programming language, whereas, of course, the programming language should not be a problem, but part of the solution.

In a constant stream of new ideas, wireless technologies continue to emerge offering a range of capabilities, each affording simplicity and ease-of-use. Such diversity and choice should surely beg the question, are manufacturers using the right technology for the right product?

Developing Practical Wireless Applications will explore this question and, in doing so, will illustrate many of the wireless technologies currently available whilst drawing upon their individual strengths and weaknesses. More specifically, the book will draw your attention to the diverse collection of standardized and proprietary solutions available to manufacturers. As developers and innovators your choices are not restricted to any norm and, as such, a standardized or proprietary solution may afford you greater benefits in realising any product roadmap.

Developing Practical Wireless Applications will provide you with a comprehensive understanding of how each technology works, coupled with an exploration into overlapping, complementary and competing technologies. In establishing this foundation, we will explore wireless applications in their context and address their suitability. In contrast, the book also considers the practicality of a wireless world in an attempt to better understand our audience and specific demographic groups. Coupled with a richer understanding of our consumers, along with our technology make-up we can indeed target wireless products more effectively.

Software architecture is an important field of study that is becoming more important and more talked about with every passing day. But, to our knowledge, there exists little practical guidance on how to manage software architecture within a real software development organization from a technical or from a managerial perspective. This book has emerged from our belief that the coupling of the software architecture of a system and its business and organizational context has not been well explored.

Our experience with designing and reviewing large and complex software-intensive systems has led us to recognize the role of business and organization in the design of the system and also in its ultimate success or failure. Systems are built to satisfy an organizationis requirements (or assumed requirements in the case of shrink-wrapped products), and these requirements determine the extent to which a system must meet performance targets, be highly available, interoperate with other systems, or be designed for long lifetimes. These properties of a system are constrained by the systemis software architecture; or, to put it another way, the desire to achieve these properties influences the design choices made by a software architect.

As the most popular database system in the world, Microsoft Access is used by millions of people and supported by hundreds of thousands of Access developers. The 2007 version marks the largest release of Access in five years. Written by design engineers on the Access test team at Microsoft, this book introduces you to the many new features of Access 2007 and shows you innovative ways of looking at old problems such as automation, debugging, and deployment.

The authors break down the book into four parts—programming Access applications, data manipulation, interacting with the application, and finalizing the application—in order to walk you through the important steps of creating a full-featured application. They also provide you with in-depth examples that require only minor modifications and then can be easily implemented in the real world. You'll quickly learn how the 2007 version makes it simpler to write quality Access applications with XML, C#, and other .NET languages that are actually fun to write, feature rich, and easy to use.

• Visual Studio 2005 Team System (VSTS) features a robust, integrated suite of test tools that work seamlessly in the Visual Studio development environment
• Covering all phases of the development lifecycle, this book shows readers how to implement best practices for software testing using the appropriate components of VSTS
• Readers will learn how to use the tools effectively, directly from those who helped design and develop the software
• Shows how to catch common programming mistakes every time code is compiled, helping to shorten the time to market

In this book, you will learn about what drives the Linux development process. You will discover the wide variety of tools commonly used by Linux developers – compilers, debuggers, Software Configuration Management – and how those tools are used to build application software, tools, utilities and even the Linux kernel itself. You will learn about the unique components of a Linux system that really set it apart from other UNIX-like systems, and you will delve into the inner workings of the system in order to better understand your role as one of a budding new generation of Linux developers.

You will learn about novel development methods, including the use of virtualization technology, cross-compilation as a means to build software for different compatible platforms. You will also learn about the importance of internationalization to a community that has no borders – Linux is truly international and so are its users. Finally, you will learn about wider uses of Linux with the modern Internet by writing software for the oft-touted LAMP (Linux, Apache, MySQL, Perl/Python) stack. Linux is about so much more than just the Linux kernel itself – and it’s important to realize that as a Linux developer.

This book is written for two different kinds of reader. First and foremost, this book is targeted at existing programmers looking to make the switch to Linux. Such readers will already have some familiarity with the C programming language and understand fundamental concepts – compilers, linkers, debuggers, and so on. They will have likely read an introductory text on the subject – for example, Wrox’s Beginning Linux Programming (Wiley 2004), but will have little practical experience.

As the application of object technology-particularly the Java programming language-has become commonplace, a new problem has emerged to confront the software development community. Significant numbers of poorly designed programs have been created by less-experienced developers, resulting in applications that are inefficient and hard to maintain and extend. Increasingly, software system professionals are discovering just how difficult it is to work with these inherited, "non-optimal" applications. For several years, expert-level object programmers have employed a growing collection of techniques to improve the structural integrity and performance of such existing software programs. Referred to as "refactoring," these practices have remained in the domain of experts because no attempt has been made to transcribe the lore into a form that all developers could use. . .until now. In Refactoring: Improving the Design of Existing Software, renowned object technology mentor Martin Fowler breaks new ground, demystifying these master practices and demonstrating how software practitioners can realize the significant benefits of this new process.

Visual languages are the defining component of interactive computing environments, yet in spite of the rapid pace of evolution of this domain, significant challenges remain.

Visual Languages for Interactive Computing: Definitions and Formalizations presents comprehensive coverage of the problems and methodologies related to the syntax, semantics, and ambiguities of visual languages. This all-inclusive reference authoritatively sets out the defining issues related to formalizing visual languages for interactive computing, creating a foundational reference for future research and application. As a unique collection of research on all critical elements of the field, this Premier Reference Source enables libraries to provide the defining research to drive the next generation of improvements to interactive computing.

Software security is the practice of building software to be secure and function properly under malicious attack. This book is about one of software security’s most important practices: code review with a static analysis tool.

In my book Software Security, I introduce a set of seven best practices called touchpoints. Putting software security into practice requires making some changes to the way most organizations build software. The good news is that these changes don’t need to be fundamental, earth shattering, or cost-prohibitive. In fact, adopting a straightforward set of engineering best practices, designed in such a way that security can be interleaved into existing development processes, is often all it takes.

The book is not a guide to using security features, frameworks, or APIs. We do not discuss the Java Security Manager, advanced cryptographic techniques, or the right approach to identity management. Clearly, these are important topics. They are so important, in fact, that they warrant books  of their own. Our goal is to focus on things unrelated to security features that put security at risk when they go wrong.

This book is written for people who have decided to make software security a priority. We hope that programmers, managers, and software architects will all benefit from reading it. Although we do not assume any detailed knowledge about software security or static analysis, we cover the subject matter in enough depth that we hope professional code reviewers and penetration testers will benefit, too. We do assume that you are comfortable programming in either C or Java, and that you won’t be too uncomfortable reading short examples in either language. Some chapters are slanted more toward one language than another. For instance, the examples in the chapters on buffer overflow are written in C.