Hello HN community!

In my free time I'm writing a book on "Software Performance and Scalability" and would like your feedback and input.

One section in the outline is structured around a list of patterns and techniques which can improve or harm performance and scalability. The idea is to provide a single unified document which can remind the reader of all the techniques to consider, the trade-offs, how to apply them, give before-vs-after case studies, as well as talk about useful measuring and simulation tools, benchmarks and then recommendations of specific components, services, products, packages, languages, etc.

Any things to add to my list below? Change? Improve? Disagree?

Please discuss or give feedback in the comments below, or, you can also email me privately (my address is in my HN profile.)

1. Static Not Dynamic

2. Cached

3. Distributed

4. Parallelized

5. Asynchronous

6. Incremental

7. Queues with Worker Pools

8. Step Minimization

9. Complexity Optimal Algorithms

10. Event-Driven Not Polled

11. Non-Blocking IO

12. Paginated Results

13. Web Page Component Request Minimization

14. Network Locality

15. Machine Task-to-Data Locality

16. Precompute Predicted Requests

17. Eager Init vs Lazy Init

18. Beefier Hardware

19. Do Tasks in Hardware Rather than Software

20. Leaner Languages & Runtimes

21. Tuning OS Parameters

22. Custom OS Kernel Builds

23. Non-Virtual OS Instance

24. No OS

25. Minimize Context Switching

26. Avoid Swapping, Especially Thrashing

27. Minimize Chattiness of Comm Protocols

28. Pass Smaller Messages

29. Avoid Lock Contention

30. Pass and Store Diffs Rather Than Complete Snapshots

31. Client-Server Architecture

32. Function Inlining

33. Loop Unrolling

34. Less Memory Churn and Background GC Inside Your Process

35. Local Function Calls Rather Than RPC or Web Service Requests

thanks!

Mike Kramlich