💃 Calculate the performance of your Apex 🕺

Good morning, Salesforce Nerds!

Today I thought we’d dive 🤿 into something a little extra fun! 🎡 

We’re check out how the code we’re writing can be mathematically proven to be considered 🔥 or 💩!

We may need to dust off whatever part of our brains 🧠 is holding on to those high school algebra 🏫 memories, but I think we’ll be okay!

I’m not going to try to boil the ocean 🌊 - I’ll keep as high-level and light as I can!

Performance Profiling

• Intro to Big O Notation

• Know Thy Complexities

PARDON THE INTERRUPTION

Survey Season

The ChaCha wants to be your valued resource, and we need your feedback to give you the best content possible.

Can you please take this 2 minute survey 🥹

If you’ve already completed the survey, please disregard and thank you so much ❤️❤️❤️

INTRO TO BIG O NOTATION

I know right? 🤯

Don’t stress, let’s break this down a bit … 🧩 

Think of Big O notation as a way we can analyze the amount of complexity there is within a particular function. 📈 

This is going to help us understand the magnitude (or scale) of said function. ⏳️ 

Some basics to know:

✅ The O stands for Order (order = growth rate of a function)

✅ It follows the convention of writing O and then the complexity (# of operations) in parenthesis - O(1), O(n), O(n²), etc.

✅ n denotes the size or number of items input into the function

So … we’re measuring the growth rate (O) of a function as it executes relative to the size of its input (n). 😴 

Whatever … I know, math sucks sometimes. 😡 

But, hang in there. Some examples will help. I promise. 👇️ 

KNOW THY COMPLEXITIES

I’m just going to talk about what the three (3) notations I think will intro the topic sufficiently, give y’all an understanding how they work, and why they’re important. 📑 

Then we’ll call it day. 🍻 

There’s a wealth of knowledge out there on this topic if you’re interested in more. ℹ️ 

🚀 O(1)

Known as a constant-time function. ⏲️ 

Order 1 functions are the least complex. 💯 These execute in a constant amount of time regardless of the how big the input size is. 🎯 

Take this example:

☝️ This function is rated O(1) because, given a list of any size, it simply logs the length of the collection.

We can pass in 1 account or 1000 accounts. It won’t matter. The number of operations run will stay the same. It’s a fixed constant. 💪 

🚀 O(n)

AKA a linear-time constant. 📈 

Order N functions add a bit of complexity to things. 😬 They’re super common, though - especially in the world of Salesforce. 🙂 

These execute in differing amounts of time depending on the size of what’s passed in. 📦️ 

What if we wrote a function similar to the one up there ☝️ but with one difference:

Check what we changed. ✅ 

Instead of just a single operation happening on the collection of accounts, now we’re looping over each account and logging the name. ✍️ 

We’re good if we pass 1 account in, but if we pass 1000 … we’ve added 1000 operations. 😰 

🚀 O(n²)

While the AKA sounds awesome - 💥💥 QUADRATIC-TIME FUNCTION 💥💥 - you want to avoid these whenever you can. 🛑 

Sometimes you can’t … so you may need to mitigate. 🔀 

In the case of an Order N² function, the number of operations performed scales in proportion to the square of the input size. 🤔 

Basically, be wary of nested loops. 🐉 

What happens here is you have a collection of items that you’re iterating over and for each iteration, you need to iterate over the collection again to perform some operation. 😅 

Check this example out 👇️

Super basic code, iterating over a list of accounts to see if duplicate names exists or not. 👍️ 

This is the type of thing that can quickly get out of control. 😱 

If you can - avoid this! 🛑 

However, if you can’t, be sure to proactively leave a loop(s) when you’re done with your operation. ⏩️ 

In this case here, we could have simply added a break statement to the innermost loop after finding the duplicate. 🔍️ 

Like so:

if(outerAcct.Name == innerAcct.Name) {
    hasDupes = true;
    break;
}

WHY IS THIS IMPORTANT

They say a picture is worth a thousand words. 🖼️ 

Still? What’s so important here? 🤔 

The answer is that studying Big O notation makes you grasp the very important concept of efficiency in your code. 📈 

So when you do work with huge data sets, you will have a good sense of where major slowdowns are likely to cause bottlenecks, and where more attention should be paid to get the largest improvements. 📉 

Daily Principle

and now....Your Daily Memes