Developing Webapplications and proprietary applications that scale in terms of performance, code and team is challenging. Not only that these topics contrary in terms of ressources and goals, also they all have to be met in order to have a successful application. You got to be proactive. It sometime requires the Projectmanager is required to implement Quickwins to get back into business, but this is not a lasting strategy at all.
- Generally there are some great Tipps on Scaling an Application
Checklist for Webpage Speed:
- Use Y-Slow Browser Check for a general overview. A real insider is this the Y-Slow Scoremeter
- Get your self sure using the free Pingdom tools
- Check if your site validates correctly to make sure, your users don’t waste time locally
- Use Google Webmaster tools to analyze their view
Some good tweaks are:
Checklist for Application Scaling:
Information on Scaling, by Zend
- Efficiency – Traded Off for Scalability
- Efficiency is traded off for scalability. The most efficient thing is to write it in C and cram it into one process, but that’s not scalable.
- Focus on the macro level, your components, and how they break out. Does it makes sense to do this an RPC or do it inline? Break it into a subpackage and just someday this may be different.
- Focus on algorithms. In Python the effort to implement a good algorithm is low. There’s the bisect module, for example, where you can take a list, do something meaningful, and serialize it to disk and read it back again. There’s a penalty versus C, but it’s very easy.
- Measurement. In Python measurement is like reading tea leaves. There’s a lot of things in Python that are counter intuitive, like the cost of grabage colleciton. Most of chunks of their apps spend their time serializing. Profiling serialization is very depending on what you are putting in. Serializing ints is very different than serializing big blobs.
- Efficiency in Python – Knowing What Not to Do
- More about knowing what not to do. How dynamic you make things correlates to how expensive it is to run your Python app.
- Dummer code is easier to grep for and easier to maintain. The more magical the code is the harder is to figure out how it works.
- They don’t do a lot of OO. They use a lot of namespaces. Use classes to organize data, but rarely for OO.
- What is your code tree going to look like? He wants these words to describe it: simple, pragmatic, elegant, orthogonal, composable. This is an ideal, reality is a bit different