%{search_type} search results

• Software Engineering Step-by-Step
• Software Engineering Step-by-Step. Software Engineering from 20,000 Feet
• Before the Beginning
• Project Management
• Requirement Gathering
• High-Level Design
• Low-Level Design
• Development
• Testing
• Deployment
• Metrics
• Maintenance
• Process Models
• Process Models. Predictive Models
• Iterative Models
• RAD
• Solution to Exercises.

A complete introduction to building robust and reliable software Beginning Software Engineering demystifies the software engineering methodologies and techniques that professional developers use to design and build robust, efficient, and consistently reliable software. Free of jargon and assuming no previous programming, development, or management experience, this accessible guide explains important concepts and techniques that can be applied to any programming language. Each chapter ends with exercises that let you test your understanding and help you elaborate on the chapter's main concepts. Everything you need to understand waterfall, Sashimi, agile, RAD, Scrum, Kanban, Extreme Programming, and many other development models is inside! Describes in plain English what software engineering is Explains the roles and responsibilities of team members working on a software engineering project Outlines key phases that any software engineering effort must handle to produce applications that are powerful and dependable Details the most popular software development methodologies and explains the different ways they handle critical development tasks Incorporates exercises that expand upon each chapter's main ideas Includes an extensive glossary of software engineering terms.
(source: Nielsen Book Data)

• Queuing Networks as Applications Models
• Building and Solving Application Models
• Workload Characterization and Transaction Profiling
• Servers, CPUs, and other Building Blocks of Application Scalability
• Operating System Overhead
• Software Bottlenecks
• Performance and Capacity of Virtual Systems
• Model-Based Application Sizing: Say Good-Bye to Guessing
• Modeling Different Application Configurations.

Poorly performing enterprise applications are the weakest links in a corporation's management chain, causing delays and disruptions of critical business functions. This groundbreaking book frames enterprise application performance engineering not as an art but as applied science built on model-based methodological foundation. The book introduces queuing models of enterprise application that visualize, demystify, explain, and solve system performance issues. Analysis of these models will help to discover and clarify unapparent connections and correlations among workloads, hardware architecture, and software parameters.
(source: Nielsen Book Data)

Discover over 70 real-world examples to overcome the most complex concepts you will face developing with Visualforce About This Book * This book provides an enhanced user experience with dynamically-generated, reactive pages * Access data over additional channels via public web sites and mobile pages * Packed with easy-to-follow recipes, including step-by-step instructions and Apex/Visualforce code downloads this title is the all in one package you need to get more from Visualforce. Who This Book Is For This book will be beneficial to developers who are already well-versed with the basics of Visualforce. An awareness of the standard component library and the purpose of controllers is expected. What You Will Learn * Pass parameters between Visualforce pages * Update attributes in component controllers * Avoid validation errors with action regions * Refresh record details from embedded Visualforce * Create and develop a website template from scratch * Get to know about the Salesforce Lightening Design system and use Visualforce in Salesforce1 * Effectively tackle frequently-faced problems while developing Visualforce pages In Detail Visualforce is a framework that allows developers to build sophisticated, custom user interfaces that can be hosted natively on the Force.com platform. The Visualforce framework includes a tag-based markup language, similar to HTML that is used to write the Visualforce pages and a set of controllers that are used to write business logic to the Visualforce pages. Visualforce Development Cookbook provides solutions to a variety of challenges faced by Salesforce developers and demonstrates how easy it is to build rich, interactive pages using Visualforce. Whether you are looking to make a minor addition to the standard page functionality or override it completely, this book will provide you with the help you require throughout. You will start by learning about the simple utilities and will build up to more advanced techniques for data visualization and to reuse functionality. You will learn how to perform various tasks such as creating multiple records from a single page, visualizing data as charts, using JavaScript to enhance client-side functionality, building a public website, and making data available to a mobile device. With an interesting chapter on tackling common issues faced while developing Visualforce pages, the book provides lots of practical examples to enhance and extend your Salesforce user interface. Style and approach Following a cookbook structure, the book provides recipes on some essential technical scenarios and a few that focus on real-world development problems. This book is packed with illustrations and contains lots of code samples to improve your understanding.
(source: Nielsen Book Data)

• Foreword xiii
• Overview xvii
• Acknowledgments xxiii
• About the Author xxv
• Part One Understanding the Estimation Process 1
• 1. The Estimation Process: Phases and Roles 3
• 1.1. Introduction 3
• 1.2. Generic Approaches in Estimation Models: Judgment or Engineering? 4
• 1.2.1. Practitioner's Approach: Judgment and Craftsmanship 4
• 1.2.2. Engineering Approach: Modest-One Variable at a Time 5
• 1.3. Overview of Software Project Estimation and Current Practices 6
• 1.3.1. Overview of an Estimation Process 6
• 1.3.2. Poor Estimation Practices 7
• 1.3.3. Examples of Poor Estimation Practices 9
• 1.3.4. The Reality: A Tally of Failures 10
• 1.4. Levels of Uncertainty in an Estimation Process 11
• 1.4.1. The Cone of Uncertainty 11
• 1.4.2. Uncertainty in a Productivity Model 12
• 1.5. Productivity Models 14
• 1.6. The Estimation Process 16
• 1.6.1. The Context of the Estimation Process 16
• 1.6.2. The Foundation: The Productivity Model 17
• 1.6.3. The Full Estimation Process 18
• 1.7. Budgeting and Estimating: Roles and Responsibilities 23
• 1.7.1. Project Budgeting: Levels of Responsibility 23
• 1.7.2. The Estimator 25
• 1.7.3. The Manager (Decision-Taker and Overseer) 25
• 1.8. Pricing Strategies 27
• 1.8.1. Customers-Suppliers: The Risk Transfer Game in Estimation 28
• 1.9. Summary - Estimating Process, Roles, and Responsibilities 28
• Exercises 30
• Term Assignments 31
• 2. Engineering and Economics Concepts for Understanding Software Process Performance 32
• 2.1. Introduction: The Production (Development) Process 32
• 2.2. The Engineering (and Management) Perspective on a Production Process 34
• 2.3. Simple Quantitative Process Models 36
• 2.3.1. Productivity Ratio 36
• 2.3.2. Unit Effort (or Unit Cost) Ratio 38
• 2.3.3. Averages 39
• 2.3.4. Linear and Non-Linear Models 42
• 2.4. Quantitative Models and Economics Concepts 45
• 2.4.1. Fixed and Variable Costs 45
• 2.4.2. Economies and Diseconomies of Scale 48
• 2.5. Software Engineering Datasets and Their Distribution 49.

• 2.5.1. Wedge-Shaped Datasets 49
• 2.5.2. Homogeneous Datasets 50
• 2.6. Productivity Models: Explicit and Implicit Variables 52
• 2.7. A Single and Universal Catch-All Multidimensional Model or Multiple Simpler Models? 54
• 2.7.1. Models Built from Available Data 55
• 2.7.2. Models Built on Opinions on Cost Drivers 55
• 2.7.3. Multiple Models with Coexisting Economies and Diseconomies of Scale 56
• Exercises 58
• Term Assignments 59
• 3. Project Scenarios, Budgeting, and Contingency Planning 60
• 3.1. Introduction 60
• 3.2. Project Scenarios for Estimation Purposes 61
• 3.3. Probability of Underestimation and Contingency Funds 65
• 3.4. A Contingency Example for a Single Project 67
• 3.5. Managing Contingency Funds at the Portfolio Level 69
• 3.6. Managerial Prerogatives: An Example in the AGILE Context 69
• 3.7. Summary 71
• Further Reading: A Simulation for Budgeting at the Portfolio Level 71
• Exercises 74
• Term Assignments 75
• Part Two Estimation Process: What Must be Verified? 77
• 4. What Must be Verified in an Estimation Process: An Overview 79
• 4.1. Introduction 79
• 4.2. Verification of the Direct Inputs to An Estimation Process 81
• 4.2.1. Identification of the Estimation Inputs 81
• 4.2.2. Documenting the Quality of These Inputs 82
• 4.3. Verification of the Productivity Model 84
• 4.3.1. In-House Productivity Models 84
• 4.3.2. Externally Provided Models 85
• 4.4. Verification of the Adjustment Phase 86
• 4.5. Verification of the Budgeting Phase 87
• 4.6. Re-Estimation and Continuous Improvement to the Full Estimation Process 88
• Further Reading: The Estimation Verification Report 89
• Exercises 92
• Term Assignments 93
• 5. Verification of the Dataset Used to Build the Models 94
• 5.1. Introduction 94
• 5.2. Verification of DIRECT Inputs 96
• 5.2.1. Verification of the Data Definitions and Data Quality 96
• 5.2.2. Importance of the Verification of the Measurement Scale Type 97
• 5.3. Graphical Analysis - One-Dimensional 100.

• 5.4. Analysis of the Distribution of the Input Variables 102
• 5.4.1. Identification of a Normal (Gaussian) Distribution 102
• 5.4.2. Identification of Outliers: One-Dimensional Representation 103
• 5.4.3. Log Transformation 107
• 5.5. Graphical Analysis - Two-Dimensional 108
• 5.6. Size Inputs Derived from a Conversion Formula 111
• 5.7. Summary 112
• Further Reading: Measurement and Quantification 113
• Exercises 116
• Term Assignments 117
• Exercises-Further Reading Section 117
• Term Assignments-Further Reading Section 118
• 6. Verification of Productivity Models 119
• 6.1. Introduction 119
• 6.2. Criteria Describing the Relationships Across Variables 120
• 6.2.1. Simple Criteria 120
• 6.2.2. Practical Interpretation of Criteria Values 122
• 6.2.3. More Advanced Criteria 124
• 6.3. Verification of the Assumptions of the Models 125
• 6.3.1. Three Key Conditions Often Required 125
• 6.3.2. Sample Size 126
• 6.4. Evaluation of Models by Their Own Builders 127
• 6.5. Models Already Built-Should You Trust Them? 128
• 6.5.1. Independent Evaluations: Small-Scale Replication Studies 128
• 6.5.2. Large-Scale Replication Studies 129
• 6.6. Lessons Learned: Distinct Models by Size Range 133
• 6.6.1. In Practice, Which is the Better Model? 138
• 6.7. Summary 138
• Exercises 139
• Term Assignments 139
• 7. Verification of the Adjustment Phase 141
• 7.1. Introduction 141
• 7.2. Adjustment Phase in the Estimation Process 142
• 7.2.1. Adjusting the Estimation Ranges 142
• 7.2.2. The Adjustment Phase in the Decision-Making Process: Identifying Scenarios for Managers 144
• 7.3. The Bundled Approach in Current Practices 145
• 7.3.1. Overall Approach 145
• 7.3.2. Detailed Approach for Combining the Impact of Multiple Cost Drivers in Current Models 146
• 7.3.3. Selecting and Categorizing Each Adjustment: The Transformation of Nominal Scale Cost Drivers into /Numbers 147
• 7.4. Cost Drivers as Estimation Submodels! 148
• 7.4.1. Cost Drivers as Step Functions 148.

• 7.4.2. Step Function Estimation Submodels with Unknown Error Ranges 149
• 7.5. Uncertainty and Error Propagation 151
• 7.5.1. Error Propagation in Mathematical Formulas 151
• 7.5.2. The Relevance of Error Propagation in Models 153
• Exercises 156
• Term Assignments 157
• Part Three Building Estimation Models: Data Collection and Analysis 159
• 8. Data Collection and Industry Standards: The ISBSG Repository 161
• 8.1. Introduction: Data Collection Requirements 161
• 8.2. The International Software Benchmarking Standards Group 163
• 8.2.1. The ISBSG Organization 163
• 8.2.2. The ISBSG Repository 164
• 8.3. ISBSG Data Collection Procedures 165
• 8.3.1. The Data Collection Questionnaire 165
• 8.3.2. ISBSG Data Definitions 167
• 8.4. Completed ISBSG Individual Project Benchmarking Reports: Some Examples 170
• 8.5. Preparing to Use the ISBSG Repository 173
• 8.5.1. ISBSG Data Extract 173
• 8.5.2. Data Preparation: Quality of the Data Collected 173
• 8.5.3. Missing Data: An Example with Effort Data 175
• Further Reading 1: Benchmarking Types 177
• Further Reading 2: Detailed Structure of the ISBSG Data Extract 179
• Exercises 183
• Term Assignments 183
• 9. Building and Evaluating Single Variable Models 185
• 9.1. Introduction 185
• 9.2. Modestly, One Variable at a Time 186
• 9.2.1. The Key Independent Variable: Software Size 186
• 9.2.2. Analysis of the Work-Effort Relationship in a Sample 188
• 9.3. Data Preparation 189
• 9.3.1. Descriptive Analysis 189
• 9.3.2. Identifying Relevant Samples and Outliers 189
• 9.4. Analysis of the Quality and Constraints of Models 193
• 9.4.1. Small Projects 195
• 9.4.2. Larger Projects 195
• 9.4.3. Implication for Practitioners 195
• 9.5. Other Models by Programming Language 196
• 9.6. Summary 202
• Exercises 203
• Term Assignments 203
• 10. Building Models with Categorical Variables 205
• 10.1. Introduction 205
• 10.2. The Available Dataset 206
• 10.3. Initial Model with a Single Independent Variable 208.

• 10.3.1. Simple Linear Regression Model with Functional Size Only 208
• 10.3.2. Nonlinear Regression Models with Functional Size 208
• 10.4. Regression Models with Two Independent Variables 210
• 10.4.1. Multiple Regression Models with Two Independent Quantitative Variables 210
• 10.4.2. Multiple Regression Models with a Categorical Variable: Project Difficulty 210
• 10.4.3. The Interaction of Independent Variables 215
• Exercises 216
• Term Assignments 217
• 11. Contribution of Productivity Extremes in Estimation 218
• 11.1. Introduction 218
• 11.2. Identification of Productivity Extremes 219
• 11.3. Investigation of Productivity Extremes 220
• 11.3.1. Projects with Very Low Unit Effort 221
• 11.3.2. Projects with Very High Unit Effort 222
• 11.4. Lessons Learned for Estimation Purposes 224
• Exercises 225
• Term Assignments 225
• 12. Multiple Models from a Single Dataset 227
• 12.1. Introduction 227
• 12.2. Low and High Sensitivity to Functional Size Increases: Multiple Models 228
• 12.3. The Empirical Study 230
• 12.3.1. Context 230
• 12.3.2. Data Collection Procedures 231
• 12.3.3. Data Quality Controls 231
• 12.4. Descriptive Analysis 231
• 12.4.1. Project Characteristics 231
• 12.4.2. Documentation Quality and Its Impact on Functional Size Quality 233
• 12.4.3. Unit Effort (in Hours) 234
• 12.5. Productivity Analysis 234
• 12.5.1. Single Model with the Full Dataset 234
• 12.5.2. Model of the Least Productive Projects 235
• 12.5.3. Model of the Most Productive Projects 237
• 12.6. External Benchmarking with the ISBSG Repository 238
• 12.6.1. Project Selection Criteria and Samples 238
• 12.6.2. External Benchmarking Analysis 239
• 12.6.3. Further Considerations 240
• 12.7. Identification of the Adjustment Factors for Model Selection 241
• 12.7.1. Projects with the Highest Productivity (i.e., the Lowest Unit Effort) 241
• 12.7.2. Lessons Learned 242
• Exercises 243
• Term Assignments 243
• 13. Re-Estimation: A Recovery Effort Model 244.

• 13.1. Introduction 244
• 13.2. The Need for Re-Estimation and Related Issues 245
• 13.3. The Recovery Effort Model 246
• 13.3.1. Key Concepts 246
• 13.3.2. Ramp-Up Process Losses 247
• 13.4. A Recovery Model When a Re-Estimation Need is Recognized at Time T > 0 248
• 13.4.1. Summary of Recovery Variables 248
• 13.4.2. A Mathematical Model of a Recovery Course in Re-Estimation 248
• 13.4.3. Probability of Underestimation −p(u) 249
• 13.4.4. Probability of Acknowledging the Underestimation on a Given Month −p(t) 250
• Exercises 251
• Term Assignments 251
• References 253
• Index 257.

This book introduces theoretical concepts to explain the fundamentals of the design and evaluation of software estimation models. It provides software professionals with vital information on the best software management software out there. * End-of-chapter exercises * Over 100 figures illustrating the concepts presented throughout the book * Examples incorporated with industry data.
(source: Nielsen Book Data)

Discover over 70 recipes that provide the solutions you need to know to face every challenge in Angular 2 head on About This Book * A first-rate reference guide with a clear structure and intuitive index that gives you as a developer exactly the information you want in exactly the way you want it * Covers no legacy material from the outdated Angular release candidates; it is up-to-date with the latest release of Angular 2.4 * All the code in the book is explicitly written out, and every piece of code shown is a step towards building a simple working example Who This Book Is For This book is for developers who are competent with JavaScript and are looking to dive headfirst into the TypeScript edition of Angular 2. This book is also geared towards developers with experience in Angular 1 who are looking to make the transition. What You Will Learn * Understand how to best move an Angular 1 application to Angular 2 * Build a solid foundational understanding of the core elements of Angular 2 such as components, forms, and services * Gain an ability to wield complex topics such as Observables and Promises * Properly implement applications utilizing advanced topics such as dependency injection * Know how to maximize the performance of Angular 2 applications * Understand the best ways to take an Angular 2 application from TypeScript in a code editor to a fully function application served on your site * Get to know the best practices when organizing and testing a large Angular 2 application In Detail Angular 2 introduces an entirely new way to build applications. It wholly embraces all the newest concepts that are built into the next generation of browsers, and it cuts away all the fat and bloat from Angular 1. This book plunges directly into the heart of all the most important Angular 2 concepts for you to conquer. In addition to covering all the Angular 2 fundamentals, such as components, forms, and services, it demonstrates how the framework embraces a range of new web technologies such as ES6 and TypeScript syntax, Promises, Observables, and Web Workers, among many others. This book covers all the most complicated Angular concepts and at the same time introduces the best practices with which to wield these powerful tools. It also covers in detail all the concepts you'll need to get you building applications faster. Oft-neglected topics such as testing and performance optimization are widely covered as well. A developer that reads through all the content in this book will have a broad and deep understanding of all the major topics in the Angular 2 universe. Style and approach This book follows a cookbook approach-each recipe presents a unique problem to which the solution is presented in a clear, concise, and manner step-by-step manner. With practical hands-on guidance in each and every recipe, you'll be able to get to grips with the concepts.
(source: Nielsen Book Data)

A beginner's guide to implementing Continuous Integration and Continuous Delivery using Jenkins About This Book * Speed up and increase software productivity and software delivery using Jenkins * Automate your build, integration, release, and deployment processes with Jenkins-and learn how continuous integration (CI) can save you time and money * Explore the power of continuous delivery using Jenkins through powerful real-life examples Who This Book Is For This book is for anyone who wants to exploit the power of Jenkins. This book servers a great starting point for those who are in the field DevOps and would like to leverage the benefits of CI and continuous delivery in order to increase productivity and reduce delivery time. What You Will Learn * Take advantage of a continuous delivery solution to achieve faster software delivery * Speed up productivity using a continuous Integration solution through Jenkins * Understand the concepts of CI and continuous delivery * Orchestrate many DevOps tools using Jenkins to automate builds, releases, deployment, and testing * Explore the various features of Jenkins that make DevOps activities a piece of cake * Configure multiple build machines in Jenkins to maintain load balancing * Manage users, projects, and permissions in Jenkins to ensure better security * Leverage the power of plugins in Jenkins In Detail In past few years, Agile software development has seen tremendous growth across the world. There is huge demand for software delivery solutions that are fast yet flexible to frequent amendments. As a result, CI and continuous delivery methodologies are gaining popularity. Jenkins' core functionality and flexibility allows it to fit in a variety of environments and can help streamline the development process for all stakeholders. This book starts off by explaining the concepts of CI and its significance in the Agile world with a whole chapter dedicated to it. Next, you'll learn to configure and set up Jenkins. You'll gain a foothold in implementing CI and continuous delivery methods. We dive into the various features offered by Jenkins one by one exploiting them for CI. After that, you'll find out how to use the built-in pipeline feature of Jenkins. You'll see how to integrate Jenkins with code analysis tools and test automation tools in order to achieve continuous delivery. Next, you'll be introduced to continuous deployment and learn to achieve it using Jenkins. Through this book's wealth of best practices and real-world tips, you'll discover how easy it is to implement a CI service with Jenkins. Style and approach This is a step-by-step guide to setting up a CI and continuous delivery system loaded with hands-on examples.
(source: Nielsen Book Data)

A beginner's guide to implementing Continuous Integration and Continuous Delivery using Jenkins About This Book * Speed up and increase software productivity and software delivery using Jenkins * Automate your build, integration, release, and deployment processes with Jenkins-and learn how continuous integration (CI) can save you time and money * Explore the power of continuous delivery using Jenkins through powerful real-life examples Who This Book Is For This book is for anyone who wants to exploit the power of Jenkins. This book servers a great starting point for those who are in the field DevOps and would like to leverage the benefits of CI and continuous delivery in order to increase productivity and reduce delivery time. What You Will Learn * Take advantage of a continuous delivery solution to achieve faster software delivery * Speed up productivity using a continuous Integration solution through Jenkins * Understand the concepts of CI and continuous delivery * Orchestrate many DevOps tools using Jenkins to automate builds, releases, deployment, and testing * Explore the various features of Jenkins that make DevOps activities a piece of cake * Configure multiple build machines in Jenkins to maintain load balancing * Manage users, projects, and permissions in Jenkins to ensure better security * Leverage the power of plugins in Jenkins In Detail In past few years, Agile software development has seen tremendous growth across the world. There is huge demand for software delivery solutions that are fast yet flexible to frequent amendments. As a result, CI and continuous delivery methodologies are gaining popularity. Jenkins' core functionality and flexibility allows it to fit in a variety of environments and can help streamline the development process for all stakeholders. This book starts off by explaining the concepts of CI and its significance in the Agile world with a whole chapter dedicated to it. Next, you'll learn to configure and set up Jenkins. You'll gain a foothold in implementing CI and continuous delivery methods. We dive into the various features offered by Jenkins one by one exploiting them for CI. After that, you'll find out how to use the built-in pipeline feature of Jenkins. You'll see how to integrate Jenkins with code analysis tools and test automation tools in order to achieve continuous delivery. Next, you'll be introduced to continuous deployment and learn to achieve it using Jenkins. Through this book's wealth of best practices and real-world tips, you'll discover how easy it is to implement a CI service with Jenkins. Style and approach This is a step-by-step guide to setting up a CI and continuous delivery system loaded with hands-on examples.
(source: Nielsen Book Data)

• Machine generated contents note: 1.Introduction / Fumin Zhang
• 1.1.Introduction
• 1.2.Chapter Summary and Contributions
• References
• 2.Sensor Placement Algorithms for a Path Covering Problem / Rajnikant Sharma
• 2.1.Problem Statement
• 2.2.Algorithm Approx1
• 2.2.1.Algorithm for Targets That Lie Within a Strip
• 2.2.2.Algorithm for a General Set of Points
• 2.2.3.Proof of the Approximation Ratio
• 2.3.Algorithm Approx2
• 2.4.Numerical Results
• 2.5.Conclusions
• References
• 3.Robust Coordination of Small UAVs for Vision-Based Target Tracking Using Output-Feedback MPC with MHE / Joao P. Hespanha
• 3.1.Vision-Based Target Tracking
• 3.2.Problem Formulation
• 3.2.1.UAV Dynamics
• 3.2.2.Target Dynamics and Overall State Space
• 3.2.3.Measurement Error Models
• 3.3.Robust Output-Feedback MPC/MHE
• 3.4.Simulation Results
• 3.4.1.Constant-Velocity Target
• 3.4.2.Evasive Target
• 3.4.3.Experimental Target Log
• 3.5.Conclusion and Future Work
• References
• 4.Projection-Based Consensus for Time-Critical Coordination of Unmanned Aerial Vehicles under Velocity Constraints / David Casbeer
• 4.1.Introduction
• 4.2.Problem Statement
• 4.2.1.Notations
• 4.2.2.Problem Formulation
• 4.3.Projection-Based Consensus Algorithm
• 4.4.Convergence Analysis
• 4.5.Convergence Time
• 4.6.Feasibility
• 4.7.Simulation
• 4.8.Summary
• References
• 5.Greedy Maximization for Asset-Based Weapon-Target Assignment with Time-Dependent Rewards / Han-Lim Choi
• 5.1.Introduction
• 5.2.Problem Formulation
• 5.2.1.Problem Variables
• 5.2.2.Constraints
• 5.2.3.Objective Function
• 5.3.Properties of the Objective Function
• 5.3.1.Preliminary
• Greedy Algorithm
• 5.3.2.Preliminary
• Maximization of Set Function
• 5.3.3.Weapon Target Assignment
• Lower Bound with Greedy Algorithm
• 5.4.Algorithmic Details
• 5.4.1.Time Slot Generation
• 5.4.2.Greedy Maximization
• 5.5.Numerical Case Studies
• 5.5.1.Simple TSWTA Example
• 5.5.2.Realistic Interceptor-Ballistic Target Assignment
• 5.6.Conclusion
• Acknowledgment
• References
• 6.Coordinated Threat Assignments and Mission Management of Unmanned Aerial Vehicles / David Casbeer
• 6.1.Introduction
• 6.2.Problem Statement
• 6.2.1.Preliminaries
• 6.2.2.Mission Description
• 6.3.Decentralized Assignment of Threats
• 6.3.1.Optimal Individual Paths and Selections
• 6.3.2.Decentralized Assignment Algorithm
• 6.4.Assignment Constraints
• 6.4.1.Timing Constraints
• 6.4.2.Coupled Decision Making
• 6.5.Multiple Main Targets
• 6.6.Conclusions
• References
• 7.Event-Triggered Communication and Control for Multi-Agent Average Consensus / George J. Pappas
• 7.1.Introduction
• 7.1.1.Organization
• 7.2.Preliminaries
• 7.2.1.Event-Triggered Control of Linear Systems
• 7.3.Problem Statement
• 7.4.Centralized Event-Triggered Control
• 7.5.Decentralized Event-Triggered Control
• 7.6.Decentralized Event-Triggered Communication and Control
• 7.6.1.Directed Graphs
• 7.7.Periodic Event-Triggered Coordination
• 7.8.Conclusions and Future Outlook
• References
• Appendix
• 8.Topology Design and Identification for Dynamic Networks / Ran Dai
• 8.1.Introduction
• 8.2.Network Topology Design Problems
• 8.2.1.Network Design for Fast Convergence of Consensus Protocol
• 8.2.2.Network Design for Minimum Total Effective Resistance
• 8.2.3.Equivalent Conversion from Cardinality-Constrained Optimization Problems to RCOPs
• 8.3.Network Topology Identification Problems
• 8.3.1.LTI System Identification
• 8.3.2.Formulation of NTIs as QCQPs
• 8.3.3.Equivalent Conversion from QCQPs to RCOPs
• 8.4.Iterative Rank Minimization Approach
• 8.5.Simulation Examples
• 8.5.1.Example for Designing Fast Converging Consensus-based Network
• 8.5.2.Example for Designing Minimum Total Effective Resistance Network
• 8.5.3.Example of NTI with Agent Dynamics Driven by Consensus Protocol
• 8.6.Conclusions
• References
• 9.Distributed Multi-Agent Coordination with Uncertain Interactions: A Probabilistic Perspective / Corey Schumacher
• 9.1.Introduction
• 9.2.Preliminaries
• 9.2.1.Graph Theory Notions
• 9.2.2.Problem Statement
• 9.3.Fixed Interaction Graph
• 9.3.1.Equal Possibility
• 9.3.2.Unequal Possibility
• 9.4.Switching Interaction Graph
• 9.5.Conclusion
• References
• 10.Awareness Coverage Control in Unknown Environments Using Heterogeneous Multi-Robot Systems / Li Wang
• 10.1.Introduction
• 10.2.Problem Formulation
• 10.2.1.Robot Models
• 10.2.2.Sensor Models
• 10.2.3.Communication Strategies
• 10.2.4.State of Awareness Dynamics
• 10.3.Cooperative Control of Heterogeneous Multi-Robot Systems
• 10.3.1.Motion Control for Boundary-Tracking UAVs
• 10.3.2.Awareness Coverage Control for Coverage Robots
• 10.3.2.1.Awareness Metric
• 10.3.2.2.Domain Coverage Algorithm
• 10.4.Simulation Results
• 10.5.Conclusion
• References.

Your answer to the software project management gap The Complete Software Project Manager: From Planning to Launch and Beyond addresses an interesting problem experienced by today's project managers: they are often leading software projects, but have no background in technology. To close this gap in experience and help you improve your software project management skills, this essential text covers key topics, including: how to understand software development and why it is so difficult, how to plan a project, choose technology platforms, and develop project specifications, how to staff a project, how to develop a budget, test software development progress, and troubleshoot problems, and what to do when it all goes wrong. Real-life examples, hints, and management tools help you apply these new ideas, and lists of red flags, danger signals, and things to avoid at all costs assist in keeping your project on track. Companies have, due to the nature of the competitive environment, been somewhat forced to adopt new technologies. Oftentimes, the professionals leading the development of these technologies do not have any experience in the tech field and this can cause problems. To improve efficiency and effectiveness, this groundbreaking book offers guidance to professionals who need a crash course in software project management. * Review the basics of software project management, and dig into the more complicated topics that guide you in developing an effective management approach * Avoid common pitfalls by perusing red flags, danger signals, and things to avoid at all costs * Leverage practical roadmaps, charts, and step-by-step processes * Explore real-world examples to see effective software project management in action The Complete Software Project Manager: From Planning to Launch and Beyond is a fundamental resource for professionals who are leading software projects but do not have a background in technology.
(source: Nielsen Book Data)

Learn how to use the power of Xcode to turn your next great app idea into a reality About This Book * Learn the theory and tools behind app development using Swift 3 and Xcode 8 * Build a fully featured iOS app, including a companion app for the Apple Watch * Optimize, debug, and ultimately release your app on Test Flight and the App Store Who This Book Is For This book is intended for programmers looking to get a jump-start into the world of iOS development. Whether you're a young student who has only spent a few months with Java, or a seasoned developer who has spent their career developing for a different platform, all that is expected is a basic understanding of a programming language such as C++, C#, or Java. What You Will Learn * Understand the most important features of the Xcode IDE * Write Swift 3 code for application data models and view controllers * Prepare visual layouts for an iOS application using storyboards, size classes, and auto-layout * Integrate many common technologies into an app, such as multi-touch gestures, CoreData, and notifications * Build companion applications for the Apple Watch with watchOS 3 * Debug applications using Xcode's suite of debugging tools, and prevent bugs with unit testing * Optimize an application using Xcode 8's profiling tools and asset catalogs * Distribute a beta application through TestFlight, and a finished application through the App Store In Detail Over the last few years, we've seen a breakthrough in mobile computing and the birth of world-changing mobile apps. With a reputation as one of the most user-centric and developer-friendly platforms, iOS is the best place to launch your next great app idea. As the official tool to create iOS applications, Xcode is chock full of features aimed at making a developer's job easier, faster, and more fun. This book will take you from complete novice to a published app developer, and covers every step in between. You'll learn the basics of iOS application development by taking a guided tour through the Xcode software and Swift programming language, before putting that knowledge to use by building your first app called "Snippets." Over the course of the book, you will continue to explore the many facets of iOS development in Xcode by adding new features to your app, integrating gestures and sensors, and even creating an Apple Watch companion app. You'll also learn how to use the debugging tools, write unit tests, and optimize and distribute your app. By the time you make it to the end of this book, you will have successfully built and published your first iOS application. Style and approach This easy-to-follow guide presents topics in a hands-on lecture format where concepts are introduced and explained, then used in an example as reinforcement. The first third of the book covers the separate building blocks of development, while the second two thirds cover the development of an app from start to finish.
(source: Nielsen Book Data)

• Introduction WHY STUDY PROGRAMMING LANGUAGES PROGRAMMING LANGUAGE ELEMENTS EVALUATING PROGRAMMING LANGUAGES
• JavaScript HELLO JAVASCRIPT THE BASICS CLOSURES METHODS PROTOTYPES SCOPE CALLBACKS AND PROMISES JAVASCRIPT WRAP UP
• CoffeeScript HELLO COFFEESCRIPT THE BASICS NO SHADOWING?! COMPREHENSIONS DESTRUCTURING EXISTENTIAL OPERATORS COFFEESCRIPT WRAP UP
• Lua HELLO LUA THE BASICS SCOPE TABLES METATABLES COROUTINES 3LUA WRAP UP
• Python HELLO PYTHON THE BASICS SCOPE PARAMETER ASSOCIATIO SPECIAL METHODS ITERATORS AND GENERATORS DECORATORS PYTHON WRAP UP
• Ruby HELLO RUBY THE BASICS OBJECT ORIENTATION Messaging Encapsulation Inheritance Polymorphism Singleton Classes BLOCKS MIXINS ACCESS CONTROL METAPROGRAMMING RUBY WRAP UP
• Julia HELLO JULIA THE BASICS TYPES Abstract Types Parametric Types Sum and Product Types Type Annotations Covariance, Contravariance, and Invariance MULTIPLE DISPATCH METAPROGRAMMING PARALLEL COMPUTING JULIA WRAP UP
• Java HELLO JAVA THE BASICS INTERFACES STATIC TYPING GENERICS THREADS METAPROGRAMMING JAVA WRAP UP
• Clojure HELLO CLOJURE THE BASICS NAMESPACES PERSISTENT DATA STRUCTURES TRANSIENTS SOFTWARE TRANSACTIONAL MEMORY AGENTS THE EXPRESSION PROBLEM MACROS CLOJURE WRAP UP
• Elm HELLO ELM THE BASICS TYPE INFERENCE TAGGED UNIONS RECORDS EFFECTS ELM WRAP UP
• Erlang HELLO ERLANG THE BASICS MATCHING MESSAGING ERLANG WRAP UP
• Go HELLO GO THE BASICS POINTERS SLICES INTERFACES PANICS GOROUTINES REFLECTION GO WRAP UP
• Swift HELLO SWIFT THE BASICS OPTIONALS OPERATORS PROTOCOLS EXTENSIONS SAFETY FEATURES AUTOMATIC REFERENCE COUNTING SWIFT WRAP UP
• Additional Languages THE CLASSICS SYSTEMS LANGUAGES THE ENTERPRISE SCRIPTING THE ML FAMILY CONCURRENCY MATTERS THE WEB CRYSTALLIZATIONS OF STYLE ESOTERIC LANGUAGES ASSEMBLY LANGUAGES 3
• Afterword WHERE WE'VE BEEN Functions Types Expressions Control Flow Concurrency Modularity Metaprogramming WHERE TO GO NEXT
• Appendix A Numbers INTEGERS FLOATING POINT NUMBERS RATIOS AND DECIMALS
• Appendix B Text CHARACTERS, GLYPHS, AND GRAPHEME CLUSTERS CHARACTER PROPERTIES CHARACTER ENCODING
• Glossary Bibliography Index.
• (source: Nielsen Book Data)

Programming Language Explorations is a tour of several modern programming languages in use today. The book teaches fundamental language concepts using a language-by-language approach. As each language is presented, the authors introduce new concepts as they appear, and revisit familiar ones, comparing their implementation with those from languages seen in prior chapters. The goal is to present and explain common theoretical concepts of language design and usage, illustrated in the context of practical language overviews. Twelve languages have been carefully chosen to illustrate a wide range of programming styles and paradigms. The book introduces each language with a common trio of example programs, and continues with a brief tour of its basic elements, type system, functional forms, scoping rules, concurrency patterns, and sometimes, metaprogramming facilities. Each language chapter ends with a summary, pointers to open source projects featuring the language, references to materials for further study, and a collection of exercises, designed as further explorations. Following the twelve featured language chapters, the authors provide a brief tour of over two dozen additional languages, and a summary chapter bringing together many of the questions explored throughout the text. Targeted to both professionals and advanced college undergraduates looking to expand the range of languages and programming patterns they can apply in their work and studies, the book pays attention to modern programming practice, covers cutting-edge languages and patterns, and provides many runnable examples, all of which can be found in an online GItHub repository. The exploration style places this book between a tutorial and a reference, with a focus on the concepts and practices underlying programming language design and usage. Instructors looking for material to supplement a programming languages or software engineering course may find the approach unconventional, but hopefully, a lot more fun.
(source: Nielsen Book Data)

Discover over 70 real-world examples to overcome the most complex concepts you will face developing with Visualforce About This Book * This book provides an enhanced user experience with dynamically-generated, reactive pages * Access data over additional channels via public web sites and mobile pages * Packed with easy-to-follow recipes, including step-by-step instructions and Apex/Visualforce code downloads this title is the all in one package you need to get more from Visualforce. Who This Book Is For This book will be beneficial to developers who are already well-versed with the basics of Visualforce. An awareness of the standard component library and the purpose of controllers is expected. What You Will Learn * Pass parameters between Visualforce pages * Update attributes in component controllers * Avoid validation errors with action regions * Refresh record details from embedded Visualforce * Create and develop a website template from scratch * Get to know about the Salesforce Lightening Design system and use Visualforce in Salesforce1 * Effectively tackle frequently-faced problems while developing Visualforce pages In Detail Visualforce is a framework that allows developers to build sophisticated, custom user interfaces that can be hosted natively on the Force.com platform. The Visualforce framework includes a tag-based markup language, similar to HTML that is used to write the Visualforce pages and a set of controllers that are used to write business logic to the Visualforce pages. Visualforce Development Cookbook provides solutions to a variety of challenges faced by Salesforce developers and demonstrates how easy it is to build rich, interactive pages using Visualforce. Whether you are looking to make a minor addition to the standard page functionality or override it completely, this book will provide you with the help you require throughout. You will start by learning about the simple utilities and will build up to more advanced techniques for data visualization and to reuse functionality. You will learn how to perform various tasks such as creating multiple records from a single page, visualizing data as charts, using JavaScript to enhance client-side functionality, building a public website, and making data available to a mobile device. With an interesting chapter on tackling common issues faced while developing Visualforce pages, the book provides lots of practical examples to enhance and extend your Salesforce user interface. Style and approach Following a cookbook structure, the book provides recipes on some essential technical scenarios and a few that focus on real-world development problems. This book is packed with illustrations and contains lots of code samples to improve your understanding.
(source: Nielsen Book Data)

Master the art of making Docker more extensible, composable, and modular by leveraging plugins and other supporting tools About This Book * Get the first book on the market that shows you how to extend the capabilities of Docker using plugins and third-party tools * Master the skills of creating various plugins and integrating great tools in order to enhance the functionalities of Docker * A practical and learning guide that ensures your investment in Docker becomes more valuable Who This Book Is For This book is for developers and sys admins who are well versed Docker and have knowledge on basic programming languages. If you can't wait to extend Docker and customize it to meet your requirements, this is the book for you! What You Will Learn * Find out about Docker plugins and the problems they solve * Gain insights into creating your own plugin * Use Docker tools to extend the basic functionality of the core Docker engine * Get to grips with the installation and configuration of third-party tools available to use with Docker plugins * Install, configure, and use a scheduling service to manage the containers in your environment * Enhance your day-to-day Docker usage through security, troubleshooting, and best practices In Detail With Docker, it is possible to get a lot of apps running on the same old servers, making it very easy to package and ship programs. The ability to extend Docker using plugins and load third-party plugins is incredible, and organizations can massively benefit from it. In this book, you will read about what first and third party tools are available to extend the functionality of your existing Docker installation and how to approach your next Docker infrastructure deployment. We will show you how to work with Docker plugins, install it, and cover its lifecycle. We also cover network and volume plugins, and you will find out how to build your own plugin. You'll discover how to integrate it with Puppet, Ansible, Jenkins, Flocker, Rancher, Packer, and more with third-party plugins. Then, you'll see how to use Schedulers such as Kubernetes and Amazon ECS. Finally, we'll delve into security, troubleshooting, and best practices when extending Docker. By the end of this book, you will learn how to extend Docker and customize it based on your business requirements with the help of various tools and plugins. Style and approach An easy to follow guide with plenty of hands-on practical examples which can be executed both on your local machine or externally hosted services.
(source: Nielsen Book Data)

Discover over 70 recipes that provide the solutions you need to know to face every challenge in Angular 2 head on About This Book * A first-rate reference guide with a clear structure and intuitive index that gives you as a developer exactly the information you want in exactly the way you want it * Covers no legacy material from the outdated Angular release candidates; it is up-to-date with the latest release of Angular 2.4 * All the code in the book is explicitly written out, and every piece of code shown is a step towards building a simple working example Who This Book Is For This book is for developers who are competent with JavaScript and are looking to dive headfirst into the TypeScript edition of Angular 2. This book is also geared towards developers with experience in Angular 1 who are looking to make the transition. What You Will Learn * Understand how to best move an Angular 1 application to Angular 2 * Build a solid foundational understanding of the core elements of Angular 2 such as components, forms, and services * Gain an ability to wield complex topics such as Observables and Promises * Properly implement applications utilizing advanced topics such as dependency injection * Know how to maximize the performance of Angular 2 applications * Understand the best ways to take an Angular 2 application from TypeScript in a code editor to a fully function application served on your site * Get to know the best practices when organizing and testing a large Angular 2 application In Detail Angular 2 introduces an entirely new way to build applications. It wholly embraces all the newest concepts that are built into the next generation of browsers, and it cuts away all the fat and bloat from Angular 1. This book plunges directly into the heart of all the most important Angular 2 concepts for you to conquer. In addition to covering all the Angular 2 fundamentals, such as components, forms, and services, it demonstrates how the framework embraces a range of new web technologies such as ES6 and TypeScript syntax, Promises, Observables, and Web Workers, among many others. This book covers all the most complicated Angular concepts and at the same time introduces the best practices with which to wield these powerful tools. It also covers in detail all the concepts you'll need to get you building applications faster. Oft-neglected topics such as testing and performance optimization are widely covered as well. A developer that reads through all the content in this book will have a broad and deep understanding of all the major topics in the Angular 2 universe. Style and approach This book follows a cookbook approach-each recipe presents a unique problem to which the solution is presented in a clear, concise, and manner step-by-step manner. With practical hands-on guidance in each and every recipe, you'll be able to get to grips with the concepts.
(source: Nielsen Book Data)

• Cover; Copyright; Credits; About the Authors; About the Reviewers; www.PacktPub.com; Table of Contents; Preface;
• Chapter 1: Getting Started; What is ResearchKit?; Privacy; Identification, authentication, and authorization; Informed consent; Relationship with HealthKit; Features not provided by ResearchKit; The anatomy of a ResearchKit-based application; Summary;
• Chapter 2: ResearchKit Hello World; Hello World App; Create project; Checkout ResearchKit from GitHub; Import ResearchKit; Enable Data Protection; Hello World!; Introducing Softwareitis; Summary;
• Chapter 3: Building Surveys

• ResearchKit object modelTasks and steps; Task view controller and results; Building surveys; Instruction step; Question step; Form step; Considerations for real-world surveys; BONUS: Appearance customization; Summary;
• Chapter 4: ResearchKit Informed Consent; Consent document; Visual consent step; Consent review step; Consent sharing; Consent process; Obtaining results; Summary;
• Chapter 5: Active Tasks; Active tasks; Short walk task; Sample code; Results; Screenshot; Two-finger tapping interval task; Sample code; Results; Screenshot; Fitness task; Sample code; Results; Screenshot

• Spatial memory taskSample Code; Results; Screenshot; Sustained phonation task; Sample code; Results; Screenshot; Data formats; Pedometer data; Location data; Device motion data; Accelerometer data; Audio data; Summary;
• Chapter 6: Navigable and Custom Tasks; Navigable ordered tasks; Custom tasks; Summary;
• Chapter 7: Backend Service; Why is backend service needed?; Security and privacy; Introduction to Sage Bionetworks and the Bridge service; Introduction to sample ResearchKit backend server; Serialization of task results; The serialization of survey responses; Serialization of file results

Enter the era of medical research using mobile devices with the help of this guide on ResearchKit! About This Book * Create a simple clinical research app using most aspects of ResearchKit * Build a simple survey with various data types with the results printed on the screen. * A step-by-step guide introducing Apple's ResearchKit and techniques to incorporate it into various apps. Who This Book Is For This book is aimed at medical researchers with basic iOS coding knowledge and iOS developers looking to create clinical research apps. What You Will Learn * Learn to create customized consent form * Get introduced to two backend services: a simple backend server using Sinatra and Sage Bridge * Build a custom task (a conditional survey example) and a navigable task * Get an Overview of ResearchKit's open source repository and App Core * Interaction with the hardware of the device including the gyro and the motion sensors * Learn the basics of this revolutionary technology * Get introduced to the barebones app and learn to write your first code In Detail ResearchKit is an open source software development framework from Apple that lets you easily create mobile applications for clinical research studies. ResearchKit provides you the ability to orchestrate the administration of tasks and recording of the results. ResearchKit provides tasks in order to perform informed consent, active tasks, and surveys. Starting with the basics of the ResearchKit framework, this books walks you through the steps of creating iOS applications that could serve as the basis of a clinical research mobile app. This book will introduce readers to ResearchKit and how to turn your iPhone into into a clinical research tool. The book will start off by installing and building the research framework in line with the researcher's needs; during this, the reader will learn to embed ResearchKit in the application and create a small task. After this, the book will go a little deeper into creating modules for surveys, consents, and so on. The book will also cover the various aspects of privacy and security with regard to participant data, and how to build dashboards for visualizing medical data and results in line with the researcher's requirements: data backends, JSON serialization and deserialization, and so on. Readers will be able to fully utilize ResearchKit for medical research, will be able to get more and more patients to participate in their surveys, and will gain insights from the surveys using the dashboards created. Style and approach A hands-on guide with ample screenshots for you to follow and learn about ResearchKit. Each topic is explained sequentially and placed in context so that you can get a better understanding of every step in the process of creating clinical research apps.
(source: Nielsen Book Data)

• Introduction xxiii
• 1 DevOps: An Overview 1 DevOps: Origins 2 DevOps: Roots 4 Addressing Dev versus Ops 7 DevOps: Practices 10 Continuous Integration 11 Continuous Delivery 16 Supporting Practices 20 Shift Left 29 Architecture and Risk Mitigation 31 Continuous Improvement 33 Metrics 33 Business Drivers 34 DevOps: Culture 35 Summary 37
• 2 Adopting DevOps 39 Developing the Playbook 41 Identifying the Target State (Business Goals and Drivers) 42 Assessing the Current State 45 Choosing the Transformation Plays 60 Adopting the Transformation Plays 61 Summary 65
• 3 Developing a Business Case for a DevOps Transformation 67 Developing The Business Case 68 Completing The Business Model Canvas 71 Customer Segments 72 Line of Business 72 IT Organization 74 Value Propositions 75 Line of Business 75 IT Organization 77 Channels 80 Line of Business 80 IT Organization 80 Customer Relationships 80 Line of Business 80 IT Organization 81 Revenue Streams 81 Line of Business 81 IT Organization 81 Key Resources 82 Line of Business 82 IT Organization 82 Key Activities 82 Line of Business 83 IT Organization 83 Key Partnerships 84 Line of Business 84 IT Organization 84 Cost Structures 85 Line of Business 85 IT Organization 85 Summary 85
• 4 DevOps Plays for Optimizing the Delivery Pipeline 87 DevOps as an Optimization Exercise 88 Business Intent: Optimization versus Innovation 89 Core Themes 95 Minimizing Cycle Time 95 Reducing Batch Size 98 Establishing the Right Culture 102 The DevOps Plays 106 Play: Establishing Metrics and KPIs 106 Play: Agile Adoption 113 Play: Integrated Delivery Pipeline 117 Play: Continuous Integration 123 Play: Continuous Delivery 128 Play: Shift Left Testing 142 Play: Shift Left Ops Engagement 149 Play: Continuous Monitoring and Feedback 155 Play: Release Management 161 Specializing Core Plays 165 Play: DevOps for Mobile 165 Play: DevOps for Mainframe 173 Play: DevOps for Internet of Things 177 Play: DevOps for Big Data and Analytics 180 Summary 186
• 5 DevOps Plays for Driving Innovation 189 Optimize to Innovate 190 The Uber Syndrome 192 Innovation and the Role of Technology 192 Innovating for New Business Models 193 Business Model Experimentation 194 Innovating for New User Engagement Models 195 Core Themes 198 Achieving Multi-Speed IT 198 Building the Right Thing 202 Enabling Experimentation 206 Delivering Antifragile Systems 208 IT Systems and Antifragility 211 Play: Build a DevOps Platform 216 Application Delivery and Antifragile Systems 218 Environment Abstraction 219 Cloud-Hosted DevOps Platform 221 Infrastructure as a Service 226 OpenStack Heat as an Abstraction Layer 232 Platform as a Service 233 Containers 238 Play: Deliver Microservices Architectures 241 Microservices Architecture 243 12-Factor App 245 Cloud Native 247 Microservices and Containers 249 Migrating to Microservices 249 Play: Develop an API Economy 253 Deployment Automation and APIs 255 DevOps Platform and APIs 255 Play: Organizing for Innovation 257 Developing an Innovation Culture in Large Organizations 259 Summary 260
• 6 Scaling DevOps for the Enterprise 261 Core Themes 263 Organizational Culture 263 Standardization of Tools and Practices 264 Organized Adoption 265 Breaking Down Organizational Silos266 Play: DevOps Center of Competency 267 Capabilities and Goals of a DevOps CoC 268 Core CoC Roles 269 The DevOps Coach 270 Setting Up a CoC 272 Play: Developing Culture of Innovation at Scale 273 The Offering Management Team 276 Play: Developing a Culture of Continuous Improvement 278 Developing an Adoption Roadmap 280 Continuous Improvement and Value Stream Mapping 282 Play: Team Models for DevOps 284 Play: Standardization of Tools and Processes 287 Standardization of an Integrated DevOps Platform 289 Play: Security Considerations for DevOps 291 Managing Security-Related Risks 292 Addressing Security for DevOps Processes and Platforms 295 The API Economy and Security 299 Play: DevOps and Outsourcing 301 Strategic Outsourcing 302 IT Supply Chain 303 Enabling DevOps with Outsourcing 304 Summary 304
• 7 Leading DevOps Adoption in the Enterprise 307 Play: DevOps as a Transformation Exercise 309 Compelling Reasons to Act 311 DevOps Transformation Anti-patterns 312 Play: Developing a Culture of Collaboration and Trust 315 Visibility Enables Trust 316 It s All about the People 317 Play: DevOps Thinking for the Line of Business 318 Line of Business IT Engagement 319 Engaging in the DevOps Transformation 321 Move Shadow IT out of the Shadows 321 Play: Starting with Pilot Projects 322 Pilot Project Selection 324 Executive Sponsorship 325 Play: Rearing Unicorns on an Aircraft Carrier 325 Fostering Ideas 327 Summary 329 Appendix Case Study: Example DevOps Adoption Roadmap 331 Organization Background 331 Roadmap Structure332 DevOps Optimization and Innovation Workshop 333 Background and Context 334 Adoption Roadmap 336 Business Drivers 336 Existing IT Initiatives 337 Bottlenecks 338 Root Causes 340 DevOps Practices 341 Roadmap Adoption 346 Index 347.
• (source: Nielsen Book Data)

Achieve streamlined, rapid production with enterprise-level DevOps The DevOps Adoption Playbook provides practical, actionable, real-world guidance on implementing DevOps at enterprise scale. Author Sanjeev Sharma heads the DevOps practice for IBM; in this book, he provides unique guidance and insight on implementing DevOps at large organizations. Most DevOps literature is aimed at startups, but enterprises have unique needs, capabilities, limitations, and challenges; "DevOps for startups" doesn't work at this scale, but the DevOps paradigm can revolutionize enterprise IT. Deliver high-value applications and systems with velocity and agility by adopting the necessary practices, automation tools, and organizational and cultural changes that lead to innovation through rapid experimentation. Speed is an advantage in the face of competition, but it must never come at the expense of quality; DevOps allows your organization to keep both by intersecting development, quality assurance, and operations. Enterprise-level DevOps comes with its own set of challenges, but this book shows you just how easily they are overcome. With a slight shift in perspective, your organization can stay ahead of the competition while keeping costs, risks, and quality under control. * Grasp the full extent of the DevOps impact on IT organizations * Achieve high-value innovation and optimization with low cost and risk * Exceed traditional business goals with higher product release efficiency * Implement DevOps in large-scale enterprise IT environments DevOps has been one of IT's hottest trends for the past decade, and plenty of success stories testify to its effectiveness in organizations of any size, industry, or level of IT maturity, all around the world. The DevOps Adoption Playbook shows you how to get your organization on board so you can slip production into the fast lane and innovate your way to the top.
(source: Nielsen Book Data)

• Cover
• Copyright
• Credits
• About the Author
• About the Reviewer
• www.PacktPub.com
• Customer Feedback
• Table of Contents
• Preface
• Chapter 1: Ready... Steady... Go!
• A little bit of history
• Installing Go
• Linux
• Go Linux advanced installation
• Windows
• Mac OS X
• Setting the workspace
• Linux and Apple OS X
• Starting with Hello World
• Integrated Development Environment
• IDE
• Types
• Variables and constants
• Operators
• Flow control
• The if{u2026} else statement
• The switch statement
• The for{u2026}range statement
• Functions
• What does a function look like?
• What is an anonymous function?
• Closures
• Creating errors, handling errors and returning errors.
• Function with undetermined number of parameters
• Naming returned types
• Arrays, slices, and maps
• Arrays
• Zero-initialization
• Slices
• Maps
• Visibility
• Zero-initialization
• Pointers and structures
• What is a pointer? Why are they good?
• Structs
• Interfaces
• Interfaces
• signing a contract
• Testing and TDD
• The testing package
• What is TDD?
• Libraries
• The Go get tool
• Managing JSON data
• The encoding package
• Go tools
• The golint tool
• The gofmt tool
• The godoc tool
• The goimport tool
• Contributing to Go open source projects in GitHub
• Summary
• Chapter 2: Creational Patterns -Singleton, Builder, Factory, Prototype, and Abstract Factory Design Patterns
• Singleton design pattern
• having a unique instance of a type in the entire program
• Description
• Objectives
• Example
• a unique counter
• Requirements and acceptance criteria
• Writing unit tests first
• Implementation
• A few words about the Singleton design pattern
• Builder design pattern
• reusing an algorithm to create many implementations of an interface
• Description
• Objectives
• Example
• vehicle manufacturing.

• Requirements and acceptance criteria
• Unit test for the vehicle builder
• Implementation
• Wrapping up the Builder design pattern
• Factory method
• delegating the creation of different types of payments
• Description
• Objectives
• The example
• a factory of payment methods for a shop
• Acceptance criteria
• First unit test
• Implementation
• Upgrading the Debitcard method to a new platform
• What we learned about the Factory method
• Abstract Factory
• a factory of factories
• Description
• The objectives
• The vehicle factory example, again?
• Acceptance criteria
• Unit test
• Implementation
• A few lines about the Abstract Factory method
• Prototype design pattern
• Description
• Objective
• Example
• Acceptance criteria
• Unit test
• Implementation
• What we learned about the Prototype design pattern
• Summary
• Chapter 3: Structural Patterns
• Composite, Adapter, and Bridge Design Patterns
• Composite design pattern
• Description
• Objectives
• The swimmer and the fish
• Requirements and acceptance criteria
• Creating compositions
• Binary Tree compositions
• Composite pattern versus inheritance
• Final words on the Composite pattern
• Adapter design pattern
• Description
• Objectives
• Using an incompatible interface with an Adapter object
• Requirements and acceptance criteria
• Unit testing our Printer adapter
• Implementation
• Examples of the Adapter pattern in Go's source code
• What the Go source code tells us about the Adapter pattern
• Bridge design pattern
• Description
• Objectives
• Two printers and two ways of printing for each
• Requirements and acceptance criteria
• Unit testing the Bridge pattern
• Implementation
• Reuse everything with the Bridge pattern
• Summary
• Chapter 4: Structural Patterns
• Proxy, Facade, Decorator, and Flyweight Design Patterns.

• Proxy design pattern
• Description
• Objectives
• Example
• Acceptance criteria
• Unit test
• Implementation
• Proxying around actions
• Decorator design pattern
• Description
• Objectives
• Example
• Acceptance criteria
• Unit test
• Implementation
• A real-life example
• server middleware
• Starting with the common interface, http.Handler
• A few words about Go's structural typing
• Summarizing the Decorator design pattern
• Proxy versus Decorator
• Facade design pattern
• Description
• Objectives
• Example
• Acceptance criteria
• Unit test
• Implementation
• Library created with the Facade pattern
• Flyweight design pattern
• Description
• Objectives
• Example
• Acceptance criteria
• Basic structs and tests
• Implementation
• What's the difference between Singleton and Flyweight then?
• Summary
• Chapter 5: Behavioral Patterns
• Strategy, Chain of Responsibility, and Command Design Patterns
• Strategy design pattern
• Description
• Objectives
• Rendering images or text
• Acceptance criteria
• Implementation
• Solving small issues in our library
• Final words on the Strategy pattern
• Chain of responsibility design pattern
• Description
• Objectives
• A multi-logger chain
• Unit test
• Implementation
• What about a closure?
• Putting it together
• Command design pattern
• Description
• Objectives
• A simple queue
• Acceptance criteria
• Implementation
• More examples
• Chain of responsibility of commands
• Rounding-up the Command pattern up
• Summary
• Chapter 6: Behavioral Patterns
• Template, Memento, and Interpreter Design Patterns
• Template design pattern
• Description
• Objectives
• Example
• a simple algorithm with a deferred step
• Requirements and acceptance criteria
• Unit tests for the simple algorithm
• Implementing the Template pattern
• Anonymous functions.

• How to avoid modifications on the interface
• Looking for the Template pattern in Go's source code
• Summarizing the Template design pattern
• Memento design pattern
• Description
• Objectives
• A simple example with strings
• Requirements and acceptance criteria
• Unit test
• Implementing the Memento pattern
• Another example using the Command and Facade patterns
• Last words on the Memento pattern
• Interpreter design pattern
• Description
• Objectives
• Example
• a polish notation calculator
• Acceptance criteria for the calculator
• Unit test of some operations
• Implementation
• Complexity with the Interpreter design pattern
• Interpreter pattern again
• now using interfaces
• The power of the Interpreter pattern
• Summary
• Chapter 7: Behavioral Patterns
• Visitor, State, Mediator, and Observer Design Patterns
• Visitor design pattern
• Description
• Objectives
• A log appender
• Acceptance criteria
• Unit tests
• Implementation of Visitor pattern
• Another example
• Visitors to the rescue!
• State design pattern
• Description
• Objectives
• A small guess the number game
• Acceptance criteria
• Implementation of State pattern
• A state to win and a state to lose
• The game built using the State pattern
• Mediator design pattern
• Description
• Objectives
• A calculator
• Acceptance criteria
• Implementation
• Uncoupling two types with the Mediator
• Observer design pattern
• Description
• Objectives
• The notifier
• Acceptance criteria
• Unit tests
• Implementation
• Summary
• Chapter 8: Introduction to Gos Concurrency
• A little bit of history and theory
• Concurrency versus parallelism
• CSP versus actor-based concurrency
• Goroutines
• Our first Goroutine
• Anonymous functions launched as new Goroutines
• WaitGroups
• Callbacks
• Callback hell
• Mutexes.

• An example with mutexes
• concurrent counter
• Presenting the race detector
• Channels
• Our first channel
• Buffered channels
• Directional channels
• The select statement
• Ranging over channels too!
• Using it all
• concurrent singleton
• Unit test
• Implementation
• Summary
• Chapter 9: Concurrency Patterns
• Barrier, Future, and Pipeline Design Patterns
• Barrier concurrency pattern
• Description
• Objectives
• An HTTP GET aggregator
• Acceptance criteria
• Unit test
• integration
• Implementation
• Waiting for responses with the Barrier design pattern
• Future design pattern
• Description
• Objectives
• A simple asynchronous requester
• Acceptance criteria
• Unit tests
• Implementation
• Putting the Future together
• Pipeline design pattern
• Description
• Objectives
• A concurrent multi-operation
• Acceptance criteria
• Beginning with tests
• Implementation
• The list generator
• Raising numbers to the power of 2
• Final reduce operation
• Launching the Pipeline pattern
• Final words on the Pipeline pattern
• Summary
• Chapter 10: Concurrency Patterns
• Workers Pool and Publish/Subscriber Design Patterns
• Workers pool
• Description
• Objectives
• A pool of pipelines
• Acceptance criteria
• Implementation
• The dispatcher
• The pipeline
• An app using the workers pool
• No tests?
• Wrapping up the Worker pool
• Concurrent Publish/Subscriber design pattern
• Description
• Objectives
• Example
• a concurrent notifier
• Acceptance criteria
• Unit test
• Testing subscriber
• Testing publisher
• Implementation
• Implementing the publisher
• Handling channels without race conditions
• A few words on the concurrent Observer pattern
• Summary
• Index.

Learn idiomatic, efficient, clean, and extensible Go design and concurrency patterns by using TDD About This Book * A highly practical guide filled with numerous examples unleashing the power of design patterns with Go. * Discover an introduction of the CSP concurrency model by explaining GoRoutines and channels. * Get a full explanation, including comprehensive text and examples, of all known GoF design patterns in Go. Who This Book Is For The target audience is both beginner- and advanced-level developers in the Go programming language. No knowledge of design patterns is expected. What You Will Learn * All basic syntax and tools needed to start coding in Go * Encapsulate the creation of complex objects in an idiomatic way in Go * Create unique instances that cannot be duplicated within a program * Understand the importance of object encapsulation to provide clarity and maintainability * Prepare cost-effective actions so that different parts of the program aren't affected by expensive tasks * Deal with channels and GoRoutines within the Go context to build concurrent application in Go in an idiomatic way In Detail Go is a multi-paradigm programming language that has built-in facilities to create concurrent applications. Design patterns allow developers to efficiently address common problems faced during developing applications. Go Design Patterns will provide readers with a reference point to software design patterns and CSP concurrency design patterns to help them build applications in a more idiomatic, robust, and convenient way in Go. The book starts with a brief introduction to Go programming essentials and quickly moves on to explain the idea behind the creation of design patterns and how they appeared in the 90's as a common "language" between developers to solve common tasks in object-oriented programming languages. You will then learn how to apply the 23 Gang of Four (GoF) design patterns in Go and also learn about CSP concurrency patterns, the "killer feature" in Go that has helped Google develop software to maintain thousands of servers. With all of this the book will enable you to understand and apply design patterns in an idiomatic way that will produce concise, readable, and maintainable software. Style and approach This book will teach widely used design patterns and best practices with Go in a step-by-step manner. The code will have detailed examples, to allow programmers to apply design patterns in their day-to-day coding.
(source: Nielsen Book Data)

Leverage the power of the Functional Reactive Programming paradigm with Swift to develop robust iOS applications About This Book * Build highly responsive applications with this practical introduction to Reactive programming * This book uses ReactiveCocoa, the most popular solution for Reactive Programming on iOS to install, debug, and develop a framework with Swift * Switch from the traditional programming style to the reactive paradigm to code your first reactive applications with ease Who This Book Is For Reactive Programming with Swift is for Swift developers who want to start making more powerful and efficient applications. You need a basic understanding of Swift to follow along. This book takes a first-principles approach to what Reactive Programming is and how you can start implementing it in your next iOS applications. What You Will Learn * Switch your programming concepts from imperative to Functional reactive programming * Improve your app's maintenance by developing with a different paradigm * Create unit tests and automation tests using the ReactiveCocoa framework * Create clear code that is very easy to read * Get accustomed to migrating mobile apps to the Reactive way of programming * Perform asynchronous calls and join them later In Detail Reactive programming helps you write applications that are more powerful and efficient. You can write more software, help more people, and create applications that scale. Reactive programming is a growing paradigm that we will help you set to work in Swift. Reactive Programming with Swift guides you through migrating from the traditional way of developing to the new ReactiveCocoa framework, which uses Swift as its main programming language. You will learn how to develop with this framework, debug code, create unit tests, use additional frameworks, and convert a traditional framework into a ReactiveCocoa one. Starting with a crash course on the fundamental concepts of Reactive programming, we'll set you up so you're ready to create reactive applications. We'll then move on to topics such as Graphical events, Streaming, and Core data, which will help you dive deeper with advanced programming. The concept of switching your programming concepts from imperative to functional reactive programming will also be covered. By the end of this book, you will be able to successfully create highly functional apps using Swift. Style and approach This book is a fast-paced, practical guide compiled with ample images and screenshots that explain how to create apps and demonstrate their logic.
(source: Nielsen Book Data)

• Cover; Copyright; Credits; About the Author; About the Reviewer; www.PacktPub.com; Table of Contents; Preface; Chapter 1: Your First Unit Tests; Building your first automatic unit test; What are unit tests?; Implementing a unit test example; Important built-in assert functions; Understanding TDD; The TDD workflow
• red, green, and refactor; Red; Green; Refactor; TDD in Xcode; An example of TDD; Red
• example 1; Green
• example 1; Refactor
• example 1; Red
• example 2; Green
• example 2; Refactor
• example 2; A recap; Finding information about tests in Xcode; Test Navigator; Tests overview

• Running testsThe setUp() and tearDown() methods; Debugging tests; Breakpoint that breaks on test failure; Test again feature; Advantages of TDD; Disadvantages of TDD; What to test; Summary;
• Chapter 2: Planning and Structuring Your Test-Driven iOS App; Task list view; Task detail view; Task input view; Structure of the app; The Table View Controller, the delegate and the data source; Table view cells; A model; Other view controllers; Development strategy; Getting started with Xcode; Setting useful Xcode behaviors for testing; Useful build behaviors; Testing behaviors; Summary

• Chapter 3: A Test-Driven Data ModelImplementing the ToDoItem struct; Adding a title property; Adding an itemDescription property; Removing a hidden source of bugs; Adding a timestamp property; Adding a location property; Implementing the Location struct; Adding a coordinate property; Implementing the ItemManager class; Count; Adding and checking items; Equatable; Removing all items; Ensuring uniqueness; Summary;
• Chapter 4: A Test-Driven View Controller; Implementing ItemListViewController; Implementing ItemListDataProvider ; Conducting the first tests; Fake objects; Using mocks

• Checking and unchecking itemsImplementing ItemCell; Implementing DetailViewController; Implementing InputViewController; Summary;
• Chapter 5: Testing Network Code; Implementing asynchronous tests; Implementing a login request to a web service; Handling errors; Summary;
• Chapter 6: Putting It All Together; Connecting parts; The initial View Controller; Showing the input view; Showing the detail view; Serialization and deserialization; Functional tests; Adding a UI test target; Recording and testing; Summary;
• Chapter 7: Code Coverage and Continuous Integration; Enabling code coverage

• Code coverage in XcodeWhat code coverage is enough?; Continuous integration; Installing and setting up Xcode Server; Adding bots; Automatic deployment with fastlane; Installing fastlane; Setting up; Summary;
• Chapter 8: Where to Go from Here; What we have learned so far; Integration tests; UI tests; Behavior-Driven Development; TDD in existing projects; More information about TDD; Summary; Index

Create fully-featured and highly functional iOS apps by writing tests first About This Book * Learn test-driven principles to help you build apps with fewer bugs and better designs * Become more efficient while working with Swift to move on to your next project faster! * Learn how to incorporate all of the principles of test-driven development (TDD) in to your daily programming workflow Who This Book Is For If debugging iOS apps is a nerve-racking task for you and you are looking for a fix, this book is for you. What You Will Learn * Implement TDD in swift application development * Get to know the fundamentals, life cycle, and benefits of TDD * Explore the tools and frameworks to effectively use TDD * Develop models and controllers driven by tests * Construct the network layer using stubs * Use functional tests to ensure the app works as planned * Automate and streamline the building, analysing, testing, and archiving of your iOS apps In Detail Test-driven development (TDD) is a proven way to find software bugs early. Writing tests before your code improves the structure and maintainability of your app. Test-Driven iOS Development with Swift will help you understand the process of TDD and how it impacts your applications written in Swift. Through practical, real-world examples, you'll start seeing how to implement TDD in context. We will begin with an overview of your TDD workflow and then deep-dive into unit testing concepts and code cycles. We will showcase the workings of functional tests, which will help you improve the user interface. Finally, you will learn about automating deployments and continuous integration to run an environment. Style and approach This is an easy-to-follow example-driven tutorial, packed with lots of tips and tricks that explore TDD bit-by-bit in the process of making an iOS application.
(source: Nielsen Book Data)

• Cover; Copyright; Credits; About the Author; Acknowledgments; About the Reviewers; www.PacktPub.com; Table of Contents; Preface;
• Chapter 1: Team Project Setup; Introduction; Connecting to TFS using Team Explorer; Setting up your user profile in TFS; Creating a Team Project using the Scrum Template; Assigning a license, adding users, and auditing user access; Configuring Dashboards in Team Project; Setting up a welcome page for a Team Project; Creating and setting up a Team Room; Renaming a Team Project; Creating a new Team Project through the command line; Deleting a Team Project

• Chapter
• 2: Setting Up and Managing Code RepositoriesIntroduction; Creating a Git repository in an existing TFVC Team Project; Enabling code analysis check-in policy; Performing a baseless merge between sibling branches in TFVC; Reparenting a branch in TFVC; Unlocking files checked out by someone else; Unshelving a shelveset created in one branch to another branch; Ignoring file types from check-in using .tfignore and .gitignore; Conducting code reviews in TFS; Setting up policies for branches in Git; Conducting Pull requests in TFS; Analyzing code churn with TFS analysis services cube

• Chapter 3: Planning and Tracking WorkIntroduction; Selecting the backlog levels displayed on the Team Portal; Mapping, assigning, and tracking Work Items shared by multiple Teams; Adding additional columns to the Kanban board; Customizing cards displayed on the boards; Setting up the Team's capacity and activity for a sprint; Querying Work Items by Tags; Creating charts using Work Item Queries; Using Service Hooks to integrate with Trello boards; Deleting Work Items in TFS permanently; Using Microsoft Feedback Client to provide feedback;
• Chapter 4: Building Your Application; Introduction

• Configuring TFBuild Agent, Pool, and QueuesSetting up a TFBuild Agent using an unattended installation; Creating a continuous integration build definition in TFBuild; Pinning a build badge to the welcome page in Team Portal; Managing build resources using role-based access; Using the build retention policy to automate build deletion; Using user capabilities to identify a build agent in a pool; Version DLLs in build output with build number; Creating a new build task using the TFBuild Extensibility framework; Integrating SonarQube with TFBuild to manage technical debt

• Building GitHub code repositories with TFBuild
• Chapter 5: Testing Your Application; Introduction; Running NUnit tests in the CI Pipeline using TFBuild; Creating and setting up a Machine Group; Deploying a test agent through the TFBuild task; Distributing test execution on a Lab Machine Group; Triggering Selenium Web Tests on a Selenium Test Grid using TFBuild; Integrating the Cloud Load Testing Service in TFBuild; Analyzing test execution results from the Runs view; Exporting and importing test cases in Excel from TFS; Copying and cloning test suites and test cases

Over 80 hands-on DevOps and ALM-focused recipes for Scrum Teams to enable the Continuous Delivery of high-quality Software... Faster! About This Book * Release high quality, reliable software quickly through building, testing, and deployment automation * Improve the predictability, reliability, and availability of TFS in your organization by scheduling administration and maintenance activities * Extend, customize, and integrate tools with TFS, enabling your teams to manage their application lifecycles effectively Who This Book Is For This book is aimed at software professionals including Developers, Testers, Architects, Configuration Analysts, and Release Managers who want to understand the capabilities of TFS to deliver better quality software faster. A working setup of TFS 2015 and some familiarity with the concepts of software life cycle management is assumed. What You Will Learn * Creating a Team Project with Dashboards, Assigning License, Adding users, and Auditing Access * Setting up a Git repository in an existing TFVC-based Team Project * Setting up branch policies and conducting Pull requests with code reviews * Mapping, assigning and tracking work items shared by multiple teams * Setting up and customizing Backlogs, Kanban board, Sprint Taskboard, and dashboards * Creating a Continuous Integration, Continuous Build, and Release Pipeline * Integrating SonarQube with TFBuild to manage Technical Debt * Triggering Selenium Web Tests on a Selenium Test Grid using TFBuild * Using Visual Studio Team Services Cloud load testing capability with new Build framework * Extending and customizing the capabilities of Team Foundation Server using API and Process Editor In Detail Team Foundation Server (TFS) allows you to manage code repositories, build processes, test infrastructure, and deploy labs. TFS supports your team, enabling you to connect, collaborate, and deliver on time. Microsoft's approach to Application Lifecycle Management (ALM) provides a flexible and agile environment that adapts to the needs of your team, removes barriers between roles, and streamlines processes. The book introduces you to creating and setting up team projects for scrum teams. You'll explore various source control repositories, branching, and merging activities, along with a demonstration of how to embed quality into every code check-in. Then, you'll discover agile project planning and management tools. Later, emphasis is given to the testing and release management features of TFS which facilitate the automation of the release pipeline in order to create potentially shippable increments. By the end of the book, you'll have learned to extend and customize TFS plugins to incorporate them into other platforms and enable teams to manage the software lifecycle effectively. Style and approach This book is a recipe-based guide that uses a problem-solution format to call out inefficiencies in the software development lifecycle and then guides you, step-by-step, on how you can use Team Foundation Server to your advantage in those areas.
(source: Nielsen Book Data)