The Curious Engineer

All blogs / Performance / optimization

Rico Mariani's Performance Tidbits

learn.microsoft.com/en-us/archive/blogs/ricom

Implying no warranties and conferring no rights: "AS IS" since 1988

Performance / optimizationC# / .NETDev tools / editors / IDEsMicrosoft blogsMSDN archive

’05’10’15’20’25
Posts
257 from 1 Dec 2003 to 25 Sep 2024
Posting
archived, read-only
Kind
personal blog
Feed
https://learn.microsoft.com/en-us/archive/blogs/ricom/feed.xml

2024 1

  1. Forwarding address

2017 3

  1. Less Loosely Coupled Than Meets The Eye
  2. Going to Internet Explorer
  3. Measure!

2016 2

  1. A little 64 bit follow-up
  2. 64-bit Visual Studio -- the "pro 64" argument

2015 11

  1. Revisiting 64-bit-ness in Visual Studio and elsewhere
  2. Pit of Success for Organizations
  3. Performance and Design Guidelines for Data Access Layers
  4. Improving .NET Application Performance and Scalability
  5. Ngen or not? The rules haven't changed very much since 2004
  6. Coding in Marble
  7. Measuring IE Performance
  8. Coding in Marble (Part 2)
  9. Some nice performance features in Visual Studio 11
  10. On adopting high end perf tools to study micro-architectural phenomena
  11. To preload or not to preload...

2014 16

  1. You don't have to write it (all) first...
  2. Wow I love git-tf!
  3. Performance Quiz #14: Memory Locality, x64 vs. x86, Alignment, and Density
  4. Performance Quiz #14: Memory Locality etc. Bonus Round!
  5. Career advice for anyone who cares to listen :)
  6. Non-Properties of floating point numbers
  7. Using telemetry to reveal, prevent, and act on real problems in the wild
  8. Career advice part 2
  9. A Personal History of Microcomputing (Part 2)
  10. How to make ANY code in ANY system unit-test-friendly
  11. Example of a transform for unit testing something tricky
  12. Anybody want a peanut?
  13. Use Symbol Filtering to get symbols you care about from your server instead of getting the kitchen sink
  14. Low Level Considerations for VS of the Future (an old memo)
  15. Holistic approaches to performance analysis
  16. "Linq to Memory": another old idea

2012 7

  1. Shortest Proof of Elegance
  2. What you really need to know about regular expressions before using them
  3. If working on Microsoft Edge with me is something you could get excited about then read on
  4. A brief excerpt from mail to my team today
  5. The many types of asserts and their meaning, and dealing with assert bugs
  6. Rico Mariani Women in Computer Science Scholarship
  7. Supporting Women in Computer Science (Part 2)

2011 2

  1. symbol filter redux
  2. Discovered comments

2010 7

  1. Final Posting
  2. Debugging Multi-threaded Applications: Some Tidbits
  3. A few words about Micro-Benchmarks
  4. My History of Visual Studio (Epilog)
  5. Variability in Benchmarks
  6. My Annual Personal Posting
  7. Why you really want to avoid catching and rethrowing exceptions

2009 16

  1. VSX Keynote posted
  2. VS2010 Beta2 performance and other issues
  3. Inside Visual Studio Beta 2 - Performance and Reliability
  4. My History of Visual Studio (Part 8)
  5. My History of Visual Studio (Part 7)
  6. My History of Visual Studio (Part 6)
  7. My History of Visual Studio (Part 5)
  8. My History of Visual Studio (Part 2)
  9. My History of Visual Studio (Part 1)
  10. The Visual Studio Documentary on Channel 9
  11. Development Tools Ecosystem Summit
  12. I'm not 30 yet, I'm only 0x2d :)
  13. Visual Studio 2010 Performance Part 3: A Technical Update
  14. CLR Performance Questionnaire
  15. Visual Studio 10 -- Your Performance Feedback plus Beta 1
  16. Visual Studio -- working on performance

2008 19

  1. Visual Studio Today, Tomorrow and Beyond
  2. Visual Studio Futures -- Extensibility Video
  3. The Visual Studio Tech Roadmap -- Starring Visual Studio 2010
  4. Patterns and Practices Performance "PAG"
  5. Performance by Design at PDC2008!
  6. Is Performance a "functional" requirement?
  7. Linq Compiled Queries Q & A
  8. Hard and Soft Mode Debugging or The Woes of Soft Mode
  9. Celebrating Twenty with a Pint
  10. Rebecca Norlander on Behind the Code
  11. Visual Studio Extenders Conference
  12. My Last Words to Bill
  13. Just another day in the perf lab
  14. Shutdown Is No Time For Spring Cleaning
  15. Cycles in Computer Science, or Am I Ancient?
  16. Sara Ford goes retro
  17. Computer Measurement Group offers past papers to the public!
  18. Performance Quiz #13 -- Linq to SQL compiled query cost -- solution
  19. Performance Quiz #13 -- Linq to SQL compiled queries cost

2007 31

  1. Rico's Instrumentation Aphorisms
  2. Linq to SQL Compiled Queries are thread-safe
  3. Visual Studio 2008 and .NET 3.5 ship today
  4. Performance Threat Models
  5. File Open Performance -- Beware of 'Extensions'
  6. Some things to visit
  7. Gamefest 2007: The Costs of Managed Code: The Avoidable and the Unavoidable
  8. Performance Improvements in Visual Studio 2008
  9. Emma Williams on Channel 9
  10. Performance Testing Guidance for Web Applications
  11. Behind the Code in August
  12. DLinq (Linq to SQL) Performance (Part 5)
  13. News About Me
  14. DLinq (Linq to SQL) Performance (Part 4)
  15. DLinq (Linq to SQL) Performance (Part 3)
  16. Caching Redux
  17. DLinq (Linq to SQL) Performance (Part 1)
  18. My time in the spotlight is over :)
  19. Partly sunny, chance of showers, bring an umbrella
  20. Everything I ever needed to know about programming I learned in Gamergarten
  21. Krzysztof Cwalina on Framework Design
  22. Synchronization Complexity in the .NET Framework, Part 2
  23. Behind The Code
  24. Synchronization Complexity in the .NET Framework
  25. .NET Framework Allocation Complexity Graph
  26. Performance Quiz #12 -- The Cost of a Good Hash -- Solution
  27. Performance Quiz #12 -- The Cost of a Good Hash -- Some Help
  28. Performance Quiz #12 -- The Cost of a Good Hash
  29. Good Advice Scorned
  30. Five Things About Me
  31. Memory leaks 101: Objects anchored by event generators

2006 38

  1. Costs, Modelling, and Managing Risk
  2. The True Cost of .NET Exceptions -- Solution
  3. The True Cost of .NET Exceptions
  4. Performance Quiz #11: Ten Questions on Value-Based Programming : Solution
  5. NameValueCollection vs. Hashtable performance considerations
  6. Performance Quiz #11: Ten Questions on Value-Based Programming
  7. My 18th anniversary at MS
  8. Introducing Performance Console
  9. Rico's thought for today
  10. A nice little article on the fallacy of premature optimization
  11. Performance Signatures: A Qualitative Approach to Dependency Guidance
  12. Throughput and Latency Considerations: Errata
  13. Throughput and Latency Considerations
  14. Glass Houses
  15. quiz10.cs
  16. Performance Quiz #10 -- Thread local storage -- Solution
  17. System.Diagnostics.Stopwatch -- always remeber to use Reset
  18. Should you move to a 64 bit platform?
  19. Posting suggestions for the future
  20. Cost of array bounds checking -- one experiment
  21. MSDNWiki beta is live!
  22. Performance Quiz #10 -- Thread local storage
  23. Using ReaderWriterLock part 3 (last in this set)
  24. Using ReaderWriterLock part 2
  25. Using ReaderWriterLock -- are you getting what you think you're getting?
  26. Putting your synchronization at the correct level -- solution
  27. Putting your synchronization at the correct level
  28. Simplify your locking strategy -- simpler is better
  29. Locking -- Isolation -- Unit of Work -- Performance -- Solution
  30. Locking -- Isolation -- Unit of Work -- Performance
  31. First rate posting on mem analysis
  32. Same Resource, Same Lock or else locking won't give you the protection you need
  33. Performance Quiz #9 : IList<T> List and array speed
  34. Winning performance on Winforms from Milena
  35. I guess he's worth reading now :)
  36. Constant Soft Faults per second -- another old Sidewalk Story
  37. Unmanaged Memory Fragmentation -- an old story
  38. Buckle up: it’s going to be a bumpy ride

2005 45

  1. Amdahl's Law : Big Speedups From Bigger Fractions
  2. Exciting changes for me
  3. Performance Quiz #8 -- The problems with parsing -- Part 4
  4. Performance Quiz #8 -- The problems with parsing -- Part 2
  5. Performance Quiz #8 -- The problems with parsing -- Part 1
  6. Wow, we did it!
  7. The Performance War -- Win it 5% at a time
  8. Profiling API
  9. Performance Lifecycle
  10. Shared Bytes vs. Private Bytes
  11. My Second PDC05 Talk
  12. My First PDC05 Talk
  13. CLR Performance Tips Chat Transcript
  14. What I'll be doing at the PDC : Video
  15. Performance Quiz #7 -- Generics Improvements and Costs
  16. Mission (almost) accomplished
  17. LogDump: CLRProfiler Log analysis tool
  18. logdump.cs
  19. Private Bytes Performance Counter -- Beware!
  20. Join me at PDC!
  21. String Suggestions for Speed and Security
  22. Reflection : Dodge Common Performance Pitfalls to Craft Speedy Applications
  23. Narrowing Down Performance Problems in Managed Code
  24. How To Do A Good Performance Investigation
  25. Performance Quiz #6 -- Conclusion, Studying the Space
  26. Performance Quiz #6 -- Looking at the sixth cut
  27. Performance Quiz #6 -- Optimizing the Managed Version
  28. Performance Quiz #6 -- The fifth cut goes foul!
  29. Performance Quiz #6 -- Looking at the fourth cut
  30. Performance Quiz #6 -- Looking at the third cut
  31. Performance Quiz #6 -- Looking at the second cut
  32. Performance Quiz #6 -- Looking at the first cut
  33. Performance Quiz #6 -- Chinese/English Dictionary reader
  34. Three techniques for tracking down memory leaks due to undisposed objects
  35. Fat Free Bytes? Not here!
  36. Some new videos on Channel 9 (including one of me)
  37. Giving your customers a good deal
  38. I'll be in an MSDN Chat session tomorrow
  39. Class Specific Comments Plus Index of Conceptual Performance Content
  40. Designing .NET Class Libraries: CLR Performance Tips
  41. Common Sources of Processor Performance Penalties: Five Issues
  42. Qualitative Code Differences in Managed Code
  43. Collections too slow? When to write your own basic types
  44. Personal emails
  45. Performance Quiz #5: The performance cost of the garbage collector

2004 48

  1. Top Ten reasons you should subscribe to my blog
  2. Tracking down managed memory leaks (how to find a GC leak)
  3. When to call GC.Collect()
  4. Tidbits on video
  5. A performance tidbits reference
  6. Performance planning for Risk Management
  7. Six Questions about Generics and Performance
  8. "Generic" advice on using language features in library
  9. Tracking changes over time
  10. Performance Tidbits
  11. Performance Quiz #4 -- Of Sets and Sundry -- Solution
  12. Performance Quiz #4 -- Of Sets and Sundry
  13. Personal emails
  14. csc default options change (use /o+ now)
  15. When to create exception objects
  16. It's a feedback time of year
  17. foreach and performance rules
  18. Performance Quiz #3 -- Solution
  19. Performance Quiz #3
  20. Optimistic vs. Pessimistic Locking consequences
  21. Wow, someone was listening :)
  22. Of Strings and Services
  23. Engineering is a quantitative discipline
  24. Two quick hrefs
  25. A few questions and answers about using IDisposable
  26. Some thoughts/advice about databases and caching
  27. Improving .NET Application Performance and Scalability PDF format available
  28. [MethodImpl(MethodImplOptions.Synchronized)] promised followup
  29. MethodImplOptions.Synchronized
  30. Cache Invalidation and Database dependency?
  31. Enumerating over arrays with for vs. foreach
  32. Improving .NET Application Performance and Scalability
  33. Performance Planning
  34. Shipping Software
  35. What I do in my spare time
  36. Performance Quiz #2
  37. My mom doesn't care about space
  38. Performance Quiz #1 (of a series?)
  39. He will triumph who knows when to wrap and when not to
  40. Sometimes it's all in the numbers
  41. (#ifdef DEBUG)++
  42. Predictable Payment Per Procedure
  43. Bad Analysis Worse Than None
  44. Some Maxims
  45. A like-minded performance person
  46. Caching Implies Policy
  47. Some Thoughts About Inlining
  48. Reusable code vs. Performant code

2003 11

  1. Exception Cost: When to throw and when not to
  2. More StringBuilder advice
  3. Designing for Performance
  4. Another bad lock pattern
  5. Mid-life crisis
  6. My new home
  7. Locality of reference and performance
  8. Two things to avoid for better memory usage
  9. Good talk on performance culture
  10. Concatenating with StringBuilders vs. Strings
  11. Loop unrolling for speed