Sponsored by
Hello friends!
Welcome to this week’s Sloth Bytes. I hope you had a great week.
Typing is a thing of the past
Typeless turns your raw, unfiltered voice into beautifully polished writing - in real time.
It works like magic, feels like cheating, and allows your thoughts to flow more freely than ever before.
With Typeless, you become more creative. More inspired. And more in-tune with your own ideas.
Your voice is your strength. Typeless turns it into a superpower.
Profilers For Dummies
Every developer will encounter this situation one day:
You write some code, it works and you’re proud!
But… It’s super slow.
Now you stare at the code and suffer in silence because you have no idea what’s wrong.
This is where where profilers come in.
What’s a Profiler?
A profiler is a tool that tells you exactly where your program is spending its resources: time, CPU, or memory.
Think of it like a fitness tracker for your code.
Fitness trackers don’t just say you did exercise, It shows what type of exercise:
You spent 20% of your run walking,
10% climbing stairs,
30% sitting on the couch,
and 40% scrolling TikTok.
For code, this means you can see:
Which functions are running the most
How much CPU they burn each call
Whether you’re allocating memory and never giving it back
How long your program sits around waiting for a database or network
A profiler doesn’t just tell you something is slow, it shows you where and why.
Types of Profilers (and when you’d use them)
I’ll be using Python (as usual) since it’s easier to understand the examples.
CPU Profilers
Use case: Your app works but it feels slow. Are you looping too much? Sorting data inefficiently? CPU profilers help by showing you where the program is spending the most time.
# cpu_example.py
import time
def slow_function():
time.sleep(3)
def fast_function():
sum(range(1000000))
slow_function()
fast_function()
Run with Python’s built-in CPU profiler:
python -m cProfile cpu_example.pyOutput example
Memory Profilers
These track memory allocation over time.
Use case: Your app starts fine but slows down after an hour… or crashes with “out of memory.” Memory profiling helps you catch leaks.
# memory_exmple.py
from memory_profiler import profile
@profile
def my_func():
a = [1] * (10 ** 6)
b = [2] * (2 * 10 ** 7)
del b
return a
if __name__ == '__main__':
my_func()Run with the memory_profiler package:
pip install memory_profiler
python -m memory_profiler memory_example.pyOutput example
Sampling Profilers
Instead of tracing every function call, sampling takes periodic snapshots.
Use case: You want a lightweight view of hotspots without slowing your app down too much.
Output example
Real-World Profilers
Python: cProfile, PySpy, line-profiler
JavaScript: Chrome DevTools Performance tab, Node.js built-in profiler
Java: VisualVM, JProfiler
Go: pprof
C/C++: gprof, Valgrind
If your language has a runtime, it probably has a profiler.
What Developers Usually Look For
When developers run a profiler, they’re not scanning every number.
They’re hunting for patterns:
Hotspots: “Where’s my code spending most of its time?”
I/O Bottlenecks: “Is my app waiting on something external?”
A slow SQL query, a network request to an API, or reading a giant file can all block performance.Memory Leaks: “Am I hoarding memory?”
In languages with garbage collection (Python, JS, Java), this can creep in through forgotten references. In C/C++, leaks are even deadlier.Garbage Collection Pressure: “Is the runtime constantly cleaning up?”
If the GC runs too often, performance tanks. Profilers show how much time is spent collecting trash vs. doing real work.Inefficient Loops/Recursion: “Did I accidentally build an algorithm that’s O(n²) instead of O(n)?”
(Spoiler: probably yes, at least once in your career.)Expensive Library Calls: “Is this ‘helper function’ from a third-party library actually hiding a huge cost?”
When to Use a Profiler
When your code runs too slow and you can’t tell why
When you suspect a memory leak
Before optimizing (so you don’t waste effort)
After big changes, to catch regressions early
During performance reviews or stress tests
A Simple Profiler Workflow
If you’ve never used a profile that’s fine!
Here’s a simple workflow just in case you feel like trying one:
Reproduce the problem
Run your code under normal conditions so the profiler captures the issue.
Start the profiler
Look for hotspots
Focus on the areas that have issues in CPU or memory usage.
Ask why
Is this function being called too often? Is it waiting on something external?
Fix one thing
Optimize, restructure, or cache. Don’t fix everything at once.
Rerun the profiler
Check if performance actually improved.
Optimizing performance is not always simple and the problems aren’t always obvious, but a profiler gives you the map.
It shows you where a slowdown is and it’s often in places you’d never expect.
So if you’re ever in a situation where your code feels slow, try a profiler!
If you want me to dive deeper into specific profilers let me know!
Thanks to everyone who submitted!
grcc492, JunKaiPhang, AryanTheIndoDev, jmartinl, Wakorithegreat, NeoScripter, AspenTheRoyal, alfalconetti, SanjnaSukirti, and jsjasee.
Looks like graph like problems are difficult for you all 😏
So let’s do another one!
Can You Exit the Maze?
You are given a 2D matrix representing a maze, where 0 is a walkable path and 1 is a wall.
You start at the top-left corner and you have to reach the bottom-right corner.
Write a function that returns true if a path exists.
You can only move up, down, left and right. You cannot move diagonally.
Examples
canExit([
[0, 1, 1, 1, 1, 1, 1],
[0, 0, 1, 1, 0, 1, 1],
[1, 0, 0, 0, 0, 1, 1],
[1, 1, 1, 1, 0, 0, 1],
[1, 1, 1, 1, 1, 0, 0]
])
output = True
canExit([
[0, 1, 1, 1, 1, 1, 1],
[0, 0, 1, 0, 0, 1, 1],
[1, 0, 0, 0, 0, 1, 1],
[1, 1, 0, 1, 0, 0, 1],
[1, 1, 0, 0, 1, 1, 1]
])
output = False
# This maze only has dead ends!
canExit([
[0, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0],
[1, 1, 1, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 0],
[1, 1, 1, 1, 1, 1, 1]
])
output = False
# Exit only one block away, but unreachable!
canExit([
[0, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0],
[1, 1, 1, 0, 0, 0, 0],
[1, 0, 0, 0, 1, 1, 0],
[1, 1, 1, 1, 1, 1, 0]
])
output = TrueThat’s all from me!
Have a great week, be safe, make good choices, and have fun coding.
If I made a mistake or you have any questions, feel free to comment below or reply to the email!
See you all next week.
What'd you think of today's email?
Want to advertise in Sloth Bytes?
If your company is interested in reaching an audience of developers and programming enthusiasts, you may want to advertise with us here.
