The Art of Error Correcting Coding provides a comprehensive coverage of the basic techniques of error concealment. It addresses the need for selecting, implementing and simulating algorithms for the encoding and decoding of codes used for error correction and detection. This practical approach uses simple and easy to follow numerical examples to describe the basic concepts of a particular coding or decoding scheme. Basic analysis tools are provided throughout to help in the assessment of the error performance block and convolutional codes of a particular Error Correcting Coding (ECC) scheme for a selection of the basic channel models.
* Provides a complete treatment of important decoding algorithms including errors-and-erasures decoding of BCH and Reed-Solomon codes for any set of consecutive zeros and any length
* Describes Viterbi decoding and the key implementation issues
* Includes soft-output decoding algorithms, MAP, log-MAP, Max-log-MAP, belief propagation and ordered statistics
* Discusses new reliability-based algorithms such as GMD and the Chase algorithm with soft outputs
* Examines turbo codes, both serially and parallel concatenated, as well as low-density parity-check (LDPC) codes and their iterative decoders
* Features a companion website providing computer programs written in C language, to help understanding and implementing basic ECC techniques
This volume provides an indispensable tool for understanding and applying ECC techniques in transmission and storage of digital information. Engineers, computer scientists and graduate students alike, will all benefit from such a practical introductory approach.

Sustainable Software Development brings together principles and practices for building software that is technically superior, delivers exceptional business value, and can evolve rapidly to reflect any change to your business or technical environment.

Kevin Tate shows how to eliminate practices that make development unsustainable and replaces these practices with a sustainable approach that draws on the best ideas from both agile and conventional development. Tate demonstrates how to balance rapid releases and long-term sustainability, achieving both rich functionality and superior quality. You’ll learn how to build a development organization that is more productive and can continually improve its capability to handle complexity and change.

# Streamline IT SOX Compliance Using the Live CD
# Use the tools on the bootable Linux CD to automate and manage workflow, disseminate information, track projects, manage groups, and much more. Understand the Liability of Noncompliance
# Learn the penalties associated with noncompliance resulting from both intentional and unintentional filing of an inaccurate certification. Deploy COBIT Standards and Best-Known Methods (BKMs) in Your Organization
# Master the six components of COBIT: Executive summary, framework, control objective, control practices, management guidelines, and audit guidelines. Create an IT SOX Compliance Policy
# Learn to write, implement, and enforce an effective IT compliance policy that will be supported by both users and management. Realize the Benefits of Open Source Tools
# Deploy Open Source applications throughout your enterprise to reduce cost and improve security. Plan and Organize Your COBIT Strategy
# Develop strategic IT plans that support business objectives and can stand the test of time. Acquire Requisite Applications and Implement Your Plan
# Ensure that you have the right people, skills, and tools to implement, test, certify, and maintain both existing and newly developed systems. Deliver and Support New Systems
# Ensure that new systems perform as expected upon implementation and that they continue to perform in accordance with established expectations. Monitor the Progress of Your COBIT Deployment
Use service level agreements (SLAs) or established baselines to quantify performance against expectations and proactively troubleshoot problems.

* Written in a practical, easy to understand style, this text provides a step-by-step guide to System Analysis and Engineering by introducing concepts, principles, and practices via a progression of topical, lesson oriented chapters.
* Each chapter focuses on specific aspects of system analysis, design, and development, and includes definitions of key terms, examples, author’s notes, key principles, and challenging exercises that teach readers to apply their knowledge to real world systems.
* Concepts and methodologies presented can be applied by organizations in business sectors such as transportation, construction, medical, financial, education, aerospace and defense, utilities, government, and others, regardless of size.
* An excellent undergraduate or graduate-level textbook in systems analysis and engineering, this book is written for both new and experienced professionals who acquire, design, develop, deploy, operate, or support systems, products, or services.

Validation of programmable architectures, consisting of processor cores, coprocessors, and memory subsystems, is one of the major bottlenecks in current System-on-Chip design methodology. A critical challenge in validation of such systems is the lack of a golden reference model. As a result, many existing validation techniques employ a bottom-up approach to design verification, where the functionality of an existing architecture is, in essence, reverse-engineered from its implementation. Traditional validation techniques employ different reference models depending on the abstraction level and verification task, resulting in potential inconsistencies between multiple reference models. This book presents a top-down validation methodology that complements the existing bottom-up approaches. It leverages the system architect’s knowledge about the behavior of the design through architecture specification using an Architecture Description Language (ADL). The authors also address two fundamental challenges in functional verification: lack of a golden reference model, and lack of a comprehensive functional coverage metric. Functional Verification of Programmable Embedded Architectures: A Top-Down Approach is designed for students, researchers, CAD tool developers, designers, and managers interested in the development of tools, techniques and methodologies for system-level design, microprocessor validation, design space exploration and functional verification of embedded systems.

Regular expressions help users and developers to find and manipulate text more effectively and efficiently. In addition, regular expressions are supported by many scripting languages, programming languages, and databases. This example-rich tutorial helps debunk the traditional reputation of regular expressions as being cryptic. It explains the various parts of a regular expression pattern, what those parts mean, how to use them, and common pitfalls to avoid when writing regular expressions. With chapters on using regular expressions with popular Windows platform software including databases, cross platform scripting languages, and programming languages, you’ll learn to make effective use of the power provided by regular expressions once you fully comprehend their strengths and potential. What you will learn from this book -Fundamental concepts of regular expressions and how to write them -How to break down a text manipulation problem into component parts so you can then logically construct a regular expression pattern -How to use regular expressions in several scripting and programming languages and software packages -The variations that exist among regular expression dialects -Reusable, real-world working code that can be used to solve everyday regular expression problems Who this book is for: This book is for developers who need to manipulate text but are new to regular expressions. Some basic programming or scripting experience is useful but not required

It is widely recognized that incorrect requirements account for up to 60 percent of errors in software products, and yet the majority of software development organizations do not have a formal requirements process. Many organizations appear willing to spend huge amounts on fixing and altering poorly specified software, but seem unwilling to invest a much smaller amount to get the requirements right in the first place.

Mastering the Requirements Process, Second , sets out an industry-proven process for gathering and verifying requirements with an eye toward today’s agile development environments. In this total update of the bestselling guide, the authors show how to discover precisely what the customer wants and needs while doing the minimum requirements work according to the project’s level of agility.

“There are many books available on software risks and software failures. There are very few books that provide step-by-step information on getting troubled software projects back on track. This book provides detailed guidelines for software project recovery. Some of the steps the author recommends may be unpleasant, but all are important.”

–Capers Jones, chief scientist emeritus at Software Productivity Research LLC

“This is a well-conceived, well-written, interesting book about an important topic. The author is right in saying that no one else has covered this particular facet of project failure.”

–Robert L. Glass, publisher of the Software Practitioner

A 10-STEP PROCESS TO IDENTIFY SEVERELY TROUBLED PROJECTS AND AVOID COSTLY FAILURE

It’s a software development nightmare: a project that’s rapidly spiraling out of control…or already a disaster. Conventional project management techniques won’t save these projects: there are no standard rescue processes to follow. You need something radically different: Catastrophe Disentanglement.

Drawing on in-depth data from hundreds of development organizations, E.M. Bennatan presents a proven, 10-step program for rescuing any project that’s worth saving. You’ll find specific guidance for addressing massive budget overruns, schedule slippage, poor quality–or all three at once. Using practical examples drawn from decades of hands-on experience as a software development leader and consultant, Bennatan shows how to

• Evaluate where your project really stands
• Align your project’s developers, managers, and customers
• Defi ne the minimum acceptable project goals that are achievable
• Replan your project to successfully deliver the new minimum goals
• Identify risks in your revised project and create effective contingency plans
• Install an “early warning system” to keep your rescued project from slipping back toward catastrophe

The second volume in the Write Great Code series supplies the critical information that today’s computer science students don’t often get from college and university courses: How to carefully choose their high-level language statements to produce efficient code. Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level, teaches software engineers how compilers translate high-level language statements and data structures into machine code. Armed with this knowledge, a software engineer can make an informed choice concerning the use of those high-level structures to help the compiler produce far better machine code–all without having to give up the productivity and portability benefits of using a high-level language.

Want to be a better developer? This books collects the personal habits, ideas, and approaches of successful agile software developers and presents them in a series of short, easy-to-digest tips. This isn’t academic fluff; follow these ideas and you’ll show yourself, your teammates, and your managers real results. These are the proven and effective agile practices that will make you a better developer.

This book will help you improve five areas of your career:

• The Development Process
• What to Do While Coding
• Developer Attitudes
• Project and Team Management
• Iterative and Incremental Learning
  

These practices provide guidelines that will help you succeed in delivering and meeting your user’s expectations, even if the domain is unfamiliar. You’ll be able to keep normal project pressure from turning into disastrous stress while writing code, and see how to effectively coordinate mentors, team leads, and developers in harmony.