Performance Solutions: Solving Performance Problems Quickly and Effectively
Presented by: Dr. Connie U. Smith
Contact us for Scheduling In-House
If you've got performance problems, you need help to get out of trouble now. This 3-day course is designed to provide you with knowledge that you can immediately apply to improve the performance of your software. It presents a practical approach to identifying sources of performance problems and proven techniques for solving them. Whether you are involved in new development or upgrading a legacy system, this course will help you quickly and effectively achieve your requirements for responsiveness and scalability without sacrificing other quality objectives such as reliability, modifiability, or security. We'll also introduce techniques that help you determine whether a legacy system is worth fixing or beyond repair.
Once you've climbed out of the performance pit, it's important to make sure that you don't end-up back in there again. We'll show you a cost-effective way to avoid future performance failures and produce software that meets performance objectives on-time and within budget.
The material in this course is drawn from the book Performance Solutions: A Practical Guide to Creating Responsive, Scalable Software by Dr. Smith and Dr. Williams. It also includes new material that is not in their book. The techniques presented apply to a wide variety of systems including: Web applications, distributed systems, commercial off-the-shelf (COTS) systems, component-based systems, batch, and real-time systems.
A variety of case studies illustrate the techniques and their application.
I. Introduction: Defining the Mission
- What Are Your Performance Problems?
- Responsiveness and Scalability
- Establishing Performance Objectives
- The "Shotgun" Approach?
- What's My Return on Investment? Evaluating the Options
- Hardware versus Software
- Tuning versus Redesign versus Re-Architecting
II. Performance Measurement: Where Am I Now?
- Measurement? "We Don't Have Time for That"
- The What, Why and How of Measurement
- What Measurements Do-and Don't-Tell You
- Data Collection Techniques and Tools
- Instrumentation: How to Get the Information You Really Need
III. Performance Tuning: What Can I Do?
- Don't Make It Worse; It's Bad Enough
- What Tuning Can-and Can't-Do
- Systematic Tuning: Avoiding the "Shotgun" Approach
- Measurement-Based Tuning
- Tuning Solutions
- General Solutions
- Object-Oriented Solutions
- C++ Solutions
- Java Solutions
- Case Study
IV. Architecture and Performance: The Big Payoff
- What You Don't Know About Your Software Architecture Can Hurt You
- Architecture and Performance
- You Have An Architecure. Can You Tell What It Is From the Documentation?
- How Does It Work? Scenarios and Sequence Diagrams
- Assessing Your Architecture
V. Introduction to Performance Models: Can I Get There From Here?
- Models? "We Don't Need No Stinking Models!"
- How Do Models Help with Performance Improvement?
- Overview of Models
- Demonstration/Case Study
VI. Performance Principles: Righteous Solutions
- Nine Principles for Achieving High-Performance Software
- Performance Control Principles
- Independent Principles
- Synergistic Principles
- Using the Principles to Solve Performance Problems
VII. Performance Patterns: The Good
- What are Performance Patterns?
- Fast Path
- First Things First
- Alternate Routes
- Slender Cyclic Functions
VIII. Performance Antipatterns: The Bad and the Ugly
- What are Performance Antipatterns?
- The "god" Class
- Excessive Dynamic Allocation
- Circuitous Treasure Hunt
- One-Lane Bridge
- Traffic Jam
- Unnecessary Processing
- Unbalanced Processing
- The Ramp
IX. Case Study: Putting It All Together
- Nachtfliegen Enterprises: The Fly-By-Night Software Company
X. Managing Performance: Preventing Future Problems
- Overcoming the "Fix-It-Later" Syndrome
- Establishing a Performance Baseline
- Monitoring Software Changes
- Performance Testing: What and Why?
- Software Performance Engineering: Avoiding the Pitfalls
- Making It Happen
Questions This Seminar Will Answer
- Where are we now? What is the current performance under representative, controlled workloads?
- Where do we need to be? What is the desired performance today, in 1 year, and for the current planning horizon?
- Can we get there? How much improvement can we achieve?
- How do we get there? What are the hardware and software improvement options and how much improvement can we achieve with each?
- What will it cost? What is the cost of additional hardware? How much software development time is required? How long will it take to implement improvements?
This course will teach you:
- How to identify problems.
- How to approach the solution systematically.
- How to focus on software versus system choices.
- How to get effective results quickly.
- How to apply strategic and tactical solutions.
- How to gather the information you need to solve your problems.
- How to determine whether your architecture will support your performance objectives.
- How to apply Performance Principles to solve problems.
- How to use Performance Patterns to achieve responsiveness and scalability.
- How to use Performance Antipatterns to identify problems and fix them.
- How performance models can leverage the improvement process.
- How to prevent performance problems in the future.