Dotnetcat » .NET Books » Performance books

This book constitutes the refereed proceedings of the 29th International Conference on Applications and Theory of Petri Nets and Other Models of Concurrency, PETRI NETS 2008, held in Xi'an, China, in June 2008.

The 23 revised full regular papers and 4 revised tool papers presented together with 5 invited papers were carefully reviewed and selected from 75 submissions. All current issues on research and development in the area of Petri nets and modeling of concurrent systems are addressed.

This book constitutes the refereed proceedings of the 28th International Conference on Applications and Theory of Petri Nets and Other Models of Concurrency, ICATPN 2007, held in Siedlce, Poland, in June 2007.

The 22 revised full papers and 3 revised tool papers presented together with 5 invited papers were carefully reviewed and selected from a total of 70 submissions. All current issues on research and development in the area of Petri nets and modeling of concurrent systems are addressed, in particular system design and verification, analysis, synthesis, structure and behaviour of nets, net theory and relations, causality/partial order theory of concurrency, semantic Web, logical and algebraic calculi, symbolic net representation, tools for nets, experience reports and case studies, educational issues, higher-level net models, timed and stochastic nets, as well as standardization of nets.

Initially, computer systems performance analyses were carried out primarily because of limited resources. Due to ever increasing functional complexity of computational systems and user requirements, performance engineering continues to play a major role in software development. This book assesses the state of the art in performance engineering. Besides revised chapters drawn from two workshops on performance engineering held in 2000, additional chapters were solicited in order to provide complete coverage of all relevant aspects. The first part is devoted to the relation between software engineering and performance engineering; the second part focuses on the use of models, measures, and tools; finally, case studies with regard to concrete technologies are presented. Researchers, professional software engineers, and advanced students interested in performance analysis will find this book an indispensable source of information and reference.

Four expert authors give a comprehensive look at the ATL Server library designed for building high-end web applications and web services. Other books on ATL do not go into depth on the ATL Server portion of the library (web services and web applications). Other books on ISAPI do not provide insight into the one library designed to make ISAPI development much easier. This is the only book written by the very people who created the ATL Server library.

The CPU meter shows the problem. One core is running at 100 percent, but all the other cores are idle. Your application is CPU-bound, but you are using only a fraction of the computing power of your multicore system. What next?
The answer, in a nutshell, is parallel programming. Where you once would have written the kind of sequential code that is familiar to all programmers, you now find that this no longer meets your performance goals. To use your system’s CPU resources efficiently, you need to split your application into pieces that can run at the same time. This is easier said than done. Parallel programming has a reputation for being the domain of experts and a minefield of subtle, hard-to-reproduce software defects.
Everyone seems to have a favorite story about a parallel program that did not behave as expected because of a mysterious bug. These stories should inspire a healthy respect for the difficulty of the problems you face in writing your own parallel programs. Fortunately, help has arrived. Microsoft Visual Studio® 2010 introduces a new programming model for parallelism that significantly simplifies the job. Behind the scenes are supporting libraries with sophisticated algorithms that dynamically distribute computations on multicore architectures. Proven design patterns are another source of help. A Guide to Parallel Programming introduces you to the most important and frequently used patterns of parallel programming and gives executable code samples for them, using the Task Parallel Library (TPL) and Parallel LINQ (PLINQ).

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.

Make the right architectural decisions up front—and improve the quality and reliability of your results. Led by two enterprise programming experts, you’ll learn how to apply the patterns and techniques that help control project complexity—and make systems easier to build, support, and upgrade—right from the start.

Get pragmatic architectural guidance on how to:

• Build testability, maintainability, and security into your system early in the design
• Expose business logic through a service-oriented interface
• Choose the best pattern for organizing business logic and behavior
• Review and apply the patterns for separating the UI and presentation logic
• Delve deep into the patterns and practices for the data access layer
• Tackle the impedance mismatch between objects and data
• Minimize development effort and avoid over-engineering—and deliver more robust results

Get code samples on the Web.

Creating robust, highly available, highly scalable database applications is absolutely critical in today's web-based economy. Integrating various non-Microsoft database servers with Microsoft tools and technologies has not always proven to be an easy task. The new-paradigm of .NET development further complicates the issue, but also provides a powerful set of tools and technologies to build these mission-critical systems. With Building Highly Scalable database Applications with .NET, readers will be able to:
* Integrate .NET-based solutions with Oracle and DB2 and MySQL
* Harness the power of Microsoft's ADO.Net for high performance computing
* Build efficient components for maximum scalability
* Integrate with existing COM-based applications
* Maximize transaction speed and message queue efficiency
* Scale applications to a much higher level, resulting in an increase in the number of users or transactions

This text provides an up-to-date treatment of the fundamental techniques and algorithms for numerical analysis of deterministic and stochastic Petri nets, a particular stochastic modelling formalism, and the application of this modelling formalism to performance analysis for parallel computer architectures.