[Performance] Top 10 performance problems

ArticleDirectory

• #1: Too Export Database CILS
• #2: synchronized to death
• #3: too chatty on the remoting Channels
• #4: Wrong usage of O/R-mappers
• #5: memory leaks
• #6: problematic 3rd party code/components
• #7: wasteful handling of scarce resources
• #8: bloated web frontends
• #9: Wrong cache strategy leads to excessive garbage collection
• #10: intermittent Problems
• (Bonus problem) #11: Expensive serialization
• Learning from Zappos, monster & Co

This article is awesome! Cool Bi! The author not only lists 11 common performance problems in summary, but also provides links to articles (further reading part) to solve these problems. It is worth collecting and reading!

Address: http://blog.dynatrace.com/2010/06/15/top-10-performance-problems-taken-from-zappos-monster-and-co/

~~~~~~~~~~~~~~~~~~~~~~~

Top 10 performance problems taken from Zappos, monster, Thomson and Coby Andreas Grabner, Jun 15, 10

For a recent edition of the Swiss Computerworld magazine we listed our top 10 performance problems as we have seen them over the years when working with our clients. I hope this list is enlightening-and I 've got ded follow-up links to the blogs to help better understand how to solve these problems:

#1: Too Export Database CILS

The problem we see the most are too your database query per request/transaction. There are 3 specific phenomena to witness

1. More data is requested is than actually required in the context of the current transaction, e.g.: requesting all account information instead of those that we need to display on the current screen.
2. The same data is requested multiple times. this usually happens when different components involved in the same transaction act independently from one another and each requests the same set of data. it is unknown what type of data has already been loaded in the current context so we end up with the same queries multiple times.
3. Multiple queries are executed to retrieve a certain set of data. This is often a result of not taken full advantage of complex SQL statements or stored procedures to retrieve the data in one batch.

Further reading: blog on linq2sql performance issues on database, video on performance anti-patterns

#2: synchronized to death

There is no question that synchronization is necessary to protect shared data in an application. too often developers make the mistake to over-Synchronize, e.g.: excessively-Large Code sequences are synchronized. under low load (on the local developers workstation) performance won't be a problem. in a high-load or production environment over-synchronization results in severe performance and scalability problems.

Further reading: how to identify synchronization problems under load

#3: too chatty on the remoting Channels

Many libraries out there make remote communication seem like a piece of cake. there is hardly any difference for the developer to call a local. remote method. the lack of understanding of what is really going on under the remoting-Hood makes people forget about things like latency, serialization, network traffic and memory usage that come with every remoting call. the easy way of using these technologies results in too when callacross these remoting boundaries and in the end causes performance and scalability problems.

Further reading: Performance Considerations in distributed applications

#4: Wrong usage of O/R-mappers

Object-relational mappers take a big burden off developers 'shoulders-loading and persisting objects in the database. as with any framework there usually are using configuration options to optimize the usage of the O/R mapper for current application use cases. faulty settings and incorrect usage of the framework itself too often results in unexpected performance and scalability problems within these frameworks. make sure you make yourself familiar with all options and learn about the internals of these libraries that you rely on.

Further reads: Understanding hibernate session cache, understanding the query cache, understanding the second level cache

#5: memory leaks

Managed runtime environments such as Java and. net have the advantage of helping with memory management by offering garbage collectors. a gc, however, does not prevent memory leaks. objects that are "forgotten" will stick around in memory and ultimately lead to a memory leak that may cause an outofmemoryexception. it is important to release object references as soon as they are no longer needed.

Further read: Understanding and finding memory leaks

#6: problematic 3rd party code/components

Nobody is writing all of the functionality of a new application on their own. we use existing 3rd party libraries to speed up our development process. not only do we speed up our output-but we also increase performance risks introduced by these components. even though most frameworks are well formed ented and have been thoroughly tested, there is no guarantee that these frameworks run as expected in every use case they are supported ded. 3rd party code is often used incorrectly or in ways that have not been tested. it is therefore important to make an in-depth check of every framework before introducing it into your code.

Further read: Top SharePoint performance mistakes

#7: wasteful handling of scarce resources

Resources such as memory, CPU, I/O or the database are scarce. wasteful handling of these resources results in lack of access to these resources by others and ultimately leads to performance and scalability issues. A good example: database connections that are kept open for too long. connections must only be used for the time period they are really needed, e.g.: For a query-and then returned to the connection pool. we often see that connections are requested early on in the request handler and are not released until the very end which leads to a classic bottleneck situation.

Further read: resource leak detection in. Net Applications

#8: bloated web frontends

Thanks to high-speed Web access extends users have a better end-user experience in the World Wide Web. the downside of this trend is that your applications get packed with too much stuff-they become bloated-which ultimately leads to bad browsing behavior. participant ularly users that do not yet have high-speed Internet access suffer the most. too success images that are too large; failure to use or incorrect usage of the browser cache; or overly-aggressive usage of JavaScript/Ajax-all result in performance problems in the browser. following the existing best practices on web site performance optimization can solve most of these problems:

Further read: How better caching wocould help speed up Frankfurt airport web site

#9: Wrong cache strategy leads to excessive garbage collection

Caching objects in memory to avoid constant roundtrips to the database is one way to boost performance. caching too prepare objects-or objects that are hardly ever used quickly changes the advantage of caching into a disadvantage due to higher memory usage and increased GC activity. before implementing a caching strategy you have to figure out which objects to cache and which objects not to cache in order to avoid these types of performance and scalability problems:

Further reads: Java memory problems, identify GC bottlenecks in distributed applications

#10: intermittent Problems

Intermittent problems are hard to find. these are usually problems that occur with specific input parameters or only happen under certain load conditions. full test coverage-functional as well as load and Performance Coverage-will uncover most of these problems early on before they become real problems for real users.

Further reads: Tracing intermittent errors by Lucy Monahan from Novell, how to find invisible performance problems

(Bonus problem) #11: Expensive serialization

With remoting communication-such as Web Services, RMI or WCF-objects need to serialized by the caller in order to be transferred over the network. the callee on the other side needs to de-serialize the object before it can be used. transformation therefore happens on both sides of the call resulting in some overhead while doing so. it is important to understand what type of serialization is required by both ends and what the optimal choice of serialization and transport type is. different types of serialization have a different impact on performance, scalability, memory usage and network traffic.

Further read: Performance Considerations in distributed applications

Learning from Zappos, monster & Co

we often ask our MERs to tell their stories in a webinar. they share their challenges with performance management, how they overcame those challenges, and, the best practices they 've developed from those experiences. I recommend listening in to the stories from Zappos, monster, insight, Novell, peopleclick, smithmicro or Thomson Reuters. you can listen to these recorded webinars and learn to what they have to say