Dotnetcat » .NET Books » Performance books

Pro ASP.NET for SQL Server: High Performance Data Access for Web Developers explains how to use ASP.NET 2.0 and SQL Server 2005 most efficiently together. It covers all crucial performance issues and illustrates optimal techniques with enterprise-quality development.

Performance is always an issue, and optimizing database access is one of the most daunting performance challenges facing web developers. With Brennan Stehling as your guide, youll explore the many overlaps of web and database technologies, including configuration, programming, performance tuning, and deployment. You’ll learn how to make high-performance database access not just a goal, but a reality.

What you’ll learn

• Discover what impedes ASP.NET 2.0 access to SQL Server 2005 and how to make web applications and databases work blindingly fast together.
• Learn to make the subtle choices between DataSets, DataReaders, and DataObjects, to simplify code and maximize performance.
• Optimize data-bound controls and create your own.
• See when a custom database provider is advisable and how to build one.
• Understand how to monitor and measure web/database performance.
• Learn to build, deploy, and configure enterprise-level web applications against SQL Server 2005.

Who is this book for?

Anyone involved in .NET web development will find this book invaluable. Whether you’re struggling just to handle traffic or scaling up to meet demand, you’ll find all the tools, tips, and techniques you need for high-performance web access to databases. If you want to build enterprise-level web database applications 100% of the time, this book will telland showyou how to do it.

About the Apress Pro Series

The Apress Pro series books are practical, professional tutorials to keep you on and moving up the professional ladder.

You have gotten the job, now you need to hone your skills in these tough competitive times. The Apress Pro series expands your skills and expertise in exactly the areas you need. Master the content of a Pro book, and you will always be able to get the job done in a professional development project. Written by experts in their field, Pro series books from Apress give you the hard-won solutions to problems you will face in your professional programming career.

There is a huge amount of information available on the how's and why's of performance testing .NET applications, but it is often fairly subjective, narrow in scope, or doesn't quite cover everything you were hoping to learn. The Complete Guide to Performance Testing and Optimizing .NET Applications (by Paul Glavich and Chris Farrell) covers everything from why you should test, through the steps of setting up your test environment, all the way to how to actually run and record tests, and what you should be looking for. Once you're up and running, Paul and Chris cover the fine details of tips and techniques to make the most of your performance testing, and some good ways to get fast results. With all this detail, you will have everything you need to make the most of your .NET code.

Integrate proven performance and scalability techniques throughout the .NET application life cycle—and gain an edge in building better-performing products. This guide presents a robust framework organized by task and role, helping developers, architects, testers, and administrators prioritize and implement the best options at the appropriate time. It offers focused, end-to-end guidance?including processes for modeling performance and techniques for measuring, testing, and fine-tuning your applications. You’ll also get tips direct from Microsoft development teams for improving the performance and scalability of managed code; Microsoft ASP.NET, ADO.NET, and SQL Server; Web services; .NET Remoting; XML; and more. The book features a "How To" section that details the steps for a number of specific performance-related tasks, such as adding performance counters and using the common language runtime (CLR) profiler. PATTERNS & PRACTICES guides are reviewed and approved by Microsoft engineering teams, consultants, partners, and customers?delivering accurate, real-world information that’s been technically validated and tested.

Foreword by .NET Remoting guru Ingo Rammer

BACK IN 1999, the ACM published a study1 that presented a comparison of 40 independent implementations of a computationally intensive problem, created by different programmers in either Java&emdash;the then-current managed runtime environment&emdash;or C/C++. It concluded with the finding that interpersonal differences between the developers "are much larger than the average difference between Java and C/C++" and that "performance ratios of a factor of 30 or more are not uncommon between the median programs from the upper half versus the lower half."

This should teach you something: If you are not a guru-level C++ programmer, then the chance is quite high that a managed code implementation performs as well as the average C++ solution&emdash;especially given the fact that most .NET languages simply allow you fewer possibilities to introduce subtle memory related or performance-related issues. And keep in mind that this study was conducted several years ago, and that Just-In-Time Compilation (JIT) as well as memory management and garbage collection (GC) technologies have been improved in the meantime!

This however doesn't mean that you can't create horribly slow, memory-eating applications with .NET. That's why you should be really concerned about the other part of the study's conclusion, namely that "interpersonal differences . . . are much larger." In essence, this means that you have to know about how to optimize your applications so that they run with the expected performance in a managed environment. Even though .NET frees you from a lot of tasks that in C++ would have been your responsibility as a developer, these tasks still exist; these "little puppets" have only cleared the main stage and now live in some little corner behind the scenes.

If you want your application to run in the top performance range, you will still need to find the right strings to pull to move these hidden figures and to basically keep them out of the way of negatively affecting your application's performance. (Lutz Prechtelt, "Comparing Java vs. C/C++ Efficiency Differences to Interpersonal Differences," Communications of the ACM 42, no. 10 [October 1999]: 109–112.)

But knowing about the common language runtime's internals is still not enough, as lots of performance issues actually turn up during application design and not just during the coding stage. Collections, remoting, interoperability with unmanaged code, and COM components are not the only things that come to my mind in this regard.

It is the aim of Nick's book to enable you to understand the design issues as well as the underlying CLR mechanisms in order to create the programs that run on the better side of the 30-times performance difference quoted in the ACM study. Nick really managed to create a book that addresses these issues, which will otherwise turn up when carelessly coding to a managed environment.

This book will allow you to get into the details without being overwhelmed by the underlying complexity of the common language runtime. The only thing you have to resist after reading the book is the urge to over optimize your code. I was delighted to see that Nick begins with a discussion of identifying an application's performance-critical sections and only later turns towards isolating and resolving these real performance bottlenecks. This is, in my opinion, one of the most important tasks&emdash;and also one of the most complex ones&emdash;when working with large-scale applications.

And now read on and enjoy the ride to the better side of a 30-fold performance difference.

Ingo Rammer, author of Advanced .

About the Book

Maximizing .NET Performance is the first book dedicated entirely to providing developers and architects with information on .NET Framework performance. .NET is a technology with a vast surface area, and coverage of every aspect of performance relevant to all .NET technologies is not possible within a single volume. This book concentrates on the performance of .NET Framework technologies like garbage collection, .NET Remoting, and Code Access Security. Because these technologies form the building blocks upon which all .NET applications run, the information in this book is relevant to all .NET developers.

In addition to providing high-level material on achieving software with good performance characteristics, the books aims to enhance your knowledge of the design and implementation of the Framework, and to provide the tools and techniques to allow you to conduct your own investigation into performance problems. Rather than taking a "tips and tricks" approach, the book aims to provide a detailed exploration of each topic and explore the "why" and "by how much" aspects of performance that are often overlooked.

Performance tuning is increasingly important as desktop applications move to a Web-centric, software-as-a-service model. Performance analysis and turning ensures that .NET-based applications perform as well as or better than traditional desktop applications. Direct from a team at Microsoft that has analyzed hundreds of Web-based and .NET-based applications, this book shows developers how to plan and execute performance tests, configure profile tools, analyze data from Microsoft Internet Information Services, analyze transaction costs, and more.

The technical book market today is flooded with a slew of titles on how to build applications with the .NET technology, and many are undoubtedly very good. But the majority of these titles simply take a "how-to" approach on programming with the .NET Framework. They often pay little more than cursory attention to the real-world issues and challenges that developers face. Performance is one of those challenges.

This book is for intermediate to advanced .NET developers who need answers to the hard questions on how to build high-performance ASP.NET applications. Authors Jeffrey Hasan and Kenneth Tu focus on how to make good design decisions for performance. They discuss how to develop applications with performance in mind. And they pay special attention to the tools available to developers to quantify and monitor performance issues and to diagnose performance problems more quickly.

Infused with the authors' collective experiences, gathered from years of building high-performance web applications, this is a book that developers will want to keep on the shelf for a long time.

Provides a clear and systematic introduction to the use of stochastic Petri nets in communications systems engineering and the analysis techniques and algorithms used in performance evaluation.
The field of communication systems is full of complex design questions concerning performance and reliability. Since data traffic and errors occur in a random fashion, stochastic models are used for developing and comparing systems. In particular, stochastic Petri nets have become a popular tool for the description and automatic evaluation of such models. The use of non-Markovian models has become important as they allow more flexibility.
This book
* Provides a clear exposition of the use of stochastic Petri nets in communication systems engineering
* Introduces the reader to the analysis techniques and algorithsm used in performance evaluation
* Provides an accompanying example to clarify the use of each definition, concept and algorithm
* Mathematica routines used for implementing the algorithms are available on the Wiley ftp site
The text will appeal to researchers, industrial engineers, and graduate students studying communication systems and stochastic modeling. The numerous examples will benefit those working in performance evaluation, reliability, operations research, queueing theory and computer science.
The Mathematica routines used for implementing the algorithms are available for downloading on the following Wiley ftp site: ftp://ftp.wiley.co.uk/pub/books/german

Coloured Petri Nets (CPN) is a graphical language for modelling and validating concurrent and distributed systems, and other systems in which concurrency plays a major role. The development of such systems is particularly challenging because of inherent intricacies like possible nondeterminism and the immense number of possible execution sequences.

In this textbook Jensen and Kristensen introduce the constructs of the CPN modelling language and present the related analysis methods in detail. They also provide a comprehensive road map for the practical use of CPN by showcasing selected industrial case studies that illustrate the practical use of CPN modelling and validation for design, specification, simulation, verification and implementation in various application domains.

Their presentation primarily aims at readers interested in the practical use of CPN. Thus all concepts and constructs are first informally introduced through examples and then followed by formal definitions (which may be skipped). The book is ideally suitable for a one-semester course at an advanced undergraduate or graduate level, and through its strong application examples can also serve for self-study. An accompanying website offers additional material such as slides, exercises and project proposals.

Book website: http://www.cs.au.dk/CPnets/cpnbook/

Assesses the state of the art in performance engineering. Researchers, professional software engineers, and advanced students interested in performance analysis will find this book an indispensable source of information and reference. Softcover.

This book presents revised versions of tutorial lectures given at the IEEE/CS Symposium on modeling, analysis, and simulation of computer and telecommunication systems held in Orlando, FL, USA in October 2003.

The lectures are grouped into three parts on performance and QoS of modern wired and wireless networks, current advances in performance modeling and simulation, and other specific applications of these methodologies.

This tutorial book is targeted to both practitioners and researchers. The practitioner will benefit from numerous pointers to performance and QoS issues; the pedagogical style and plenty of references will be of great use in solving practical problems. The researcher and advanced student are offered a representative set of topics not only for their research value but also for their novelty and use in identifying areas of active research.