The first step was identifying the culprit. Was it the garlic that hadn’t properly initialized? Or maybe the tomatoes were failing their integration test with the spices. I realized I needed a singleton ingredient—something reliable that could unify the flavor without causing side effects. Enter the butter. A carefully measured dollop, injected at just the right moment, and suddenly the sauce wasn’t just edible—it was stable, cohesive, and running smoothly on my taste buds.

Of course, like any good programmer-chef, I documented the process. Next time, I’d know exactly when to inject each dependency: the salt before compilation (aka simmering), the vinegar after unit testing (tasting), and the herbs during deployment (plating). And just like debugging a tricky app, there’s a strange satisfaction in watching something once broken transform into perfection, thanks to a well-placed intervention.

In the end, my sauce was more than just dinner—it was a reminder that whether in the kitchen or in code, timing and dependencies matter. A missing ingredient, like a missing module, can cause chaos. But with a little attention, a dash of creativity, and a well-timed injection, even the messiest situations can turn into something delicious. And if nothing else, I learned that sometimes programming concepts taste a lot better when butter is involved.

“This article was written by Cédric Bahirwe with editorial assistance from AI.”

Introduction

When working on a recent client project, I encountered a serious performance issue: the app was consuming excessive memory, leading to slow performance, crashes, and issues with lists rendering large images. Profiling the app revealed that image handling was a major culprit, especially with high-resolution assets stored in the project and fetched from the server. Through debugging, I discovered a shocking crucial detail: an image's in-memory representation can be significantly larger than its file size on disk.

In this article, I'll break down why this happens and share practical strategies on how you can optimize image memory usage in iOS apps.

Why Do Images Take Up So Much Memory?

The key to understanding image memory usage lies in how images are stored on disk versus how they are processed in memory.

Compressed Image (On Disk) vs. Uncompressed Image (In Memory)

Images on disk are often stored in compressed formats like JPEG or PNG, which significantly reduce file size. However, when an image is loaded into memory, it needs to be decompressed into a raw format that the system can render efficiently.

For example, let’s consider a 500KB JPEG image with a resolution of 3000x2000 pixels:

1. JPEG file size (on disk): 500KB (compressed)

2. Decompressed size (in memory):

   • Each pixel typically requires 4 bytes (RGBA: Red, Green, Blue, Alpha)

   • Total pixels: 3000 x 2000 = 6,000,000 pixels

   • Memory required: 6,000,000 x 4 bytes = 24MB

If the image has a higher resolution or uses more color data, this can easily double, leading to 48MB or more of memory usage per image!

Now, imagine rendering multiple high-resolution images in a list, the memory usage quickly adds up, causing performance issues, lag, and even crashes on devices with limited RAM.

Debugging the Issue

How I Discovered the Problem

During development, I noticed that:

• The app became slower when loading images from the API.

• Scrolling lists with images lagged or caused crashes.

• Xcode Instruments showed high memory usage and warnings.

To isolate the issue, I tried:

• Removing all resource-intensive work (but the issue persisted).

• Disabling media loading completely, and suddenly, the app became much faster.

This confirmed that images were the primary cause of excessive memory consumption.

Optimizing Image Memory Usage

To solve this issue, I applied several best practices that significantly reduced memory usage and improved performance.

1. Downsample Large Images Before Displaying

Instead of loading full-resolution images into memory, downsample them to a smaller size that matches the display size. This ensured that images use only as much memory as needed, significantly reducing their footprint while maintaining visual quality.

2. Cache Images to Avoid Re-Loading

Repeatedly decoding and rendering images is expensive. Using an image caching solution prevents redundant memory usage by storing images in memory or disk after they are first loaded, reducing the need for repeated decoding. Using NSCache in my case

3. Use Efficient Rendering Techniques

Avoid keeping multiple large images in memory at the same time. Instead, I used lazy loading and remove images that are no longer visible. Additionally, I ensured that image views reuse existing memory rather than creating new instances repeatedly.

4. Monitor and Profile Memory Usage

Using Xcode’s Instruments (especially the Memory Profiler and Leaks tool) to analyze how the app handles images. This helped identify excessive memory consumption and potential leaks, allowing me to fine-tune the app performance.

Key Takeaways from This Experience

Here are some key takeaways I learned from debugging, researching, and understanding these issues:

• In-memory images are much larger than their file size on disk due to decompression.

• Profiling tools like Xcode Instruments is a friend, and can help identify excessive memory usage.

• Optimizing image handling with downsampling, caching, and efficient formats significantly improves performance.

By applying these strategies, I was able to reduce memory usage and improve responsiveness in a client’s app. If you're facing similar issues, these techniques could help ensure a smoother experience for users.

Further Reading & References

If you want to dive deeper into optimizing memory usage in iOS, check out these resources:

• Apple Developer Documentation on Reducing Memory Usage

• WWDC 2018: iOS Memory Deep Dive

• SwiftLee: Memory Consumption When Loading UIImage

• Medium: Downsampling images for better memory consumption and UICollectionView performance

• Short Reddit Discussion: How to optimize memory usage when loading images

What’s Next?

If you found this article helpful, feel free to share your thoughts! Have you faced similar memory issues in your apps? Let’s discuss in the comments! 🚀

For more insights into my work and interests, feel free to connect with me on LinkedIn, Twitter or explore my projects on GitHub.

Fostering Innovation Under Time Constraints

Witnessing participants develop functional solutions within a limited timeframe was truly inspiring. The hackathon's structure encouraged rapid ideation and execution, pushing teams to think critically and collaborate effectively. As a mentor, I guided teams in refining their ideas, ensuring alignment with community needs, and navigating technical challenges. This mentorship was crucial in helping participants transform concepts into viable prototypes.

Evaluating for Real-World Impact

In my role as a judge, I assessed projects based on innovation, technical execution, functionality, theme alignment, and documentation. (CodeXtreme 2025)
The emphasis was on creating solutions that not only showcased technical prowess but also addressed pressing community issues. Projects ranged from AI-driven healthcare applications to blockchain-based financial tools, all aiming to make a tangible difference in society.

Celebrating Collaborative Problem-Solving

CodeXtreme 2025 highlighted the power of collaboration and mentorship in driving technological innovation. The event provided a platform for participants to learn from industry experts, exchange ideas, and develop solutions with the potential for significant community impact. As both a mentor and judge, I was honored to contribute to this environment of learning and growth.

Looking Ahead

The creativity and dedication demonstrated at CodeXtreme 2025 reaffirm my belief in the potential of technology to address societal challenges. I look forward to seeing these young innovators continue to develop their projects and drive positive change within their communities.

I extend my heartfelt gratitude to Cédric Murairi, Founder of CodeXtreme, and the entire CodeXtreme team for their unwavering support and commitment. Their efforts have been crucial in creating an environment where young talents can thrive and make a meaningful impact.

I am excited to witness how these projects evolve and contribute to solving real-world problems.

For more insights into my work and interests, feel free to connect with me on LinkedIn, and Twitter or explore my projects on GitHub.

Just a note: The content of this article comes from my own experiences as a mentor and judge at CodeXtreme 2025.

Static analysis tools, also known as linting tools such as ES Lint (for JavaScript) or SwiftLint (for Swift), are software programs that analyze source code for potential issues, such as bugs, security vulnerabilities, and coding standards violations, without actually executing the code. While these tools can be very effective in finding and fixing problems in code, they are not perfect and can suffer from both false negatives (i.e. missed issues) and false positives (i.e. reported issues that are not actually problems).

False negatives can occur when a static analysis tool fails to detect an issue that is present in the code. This can be due to limitations in the tool's ability to accurately analyze the code, or because the tool does not have enough information to detect the issue.

False positives can occur when a static analysis tool reports an issue that is not actually a problem. This can happen because the tool is not able to accurately distinguish between valid and invalid code patterns, or because the tool is not able to properly interpret the intended behaviour of the code.

Example (in Python)

Here's a simple example in Python to demonstrate the concept of false negatives and false positives in static analysis tools.
Consider the following code:

def divide(a, b):
    return a / b

print(divide(10, 2))
print(divide(10, 0))

A static analysis tool might run on this code and report no issues because it cannot detect that the second call to divide will raise a ZeroDivisionError exception in Python or a runtime error in Swift . This is an example of a false negative because the issue of dividing by zero is present in the code, but the static analysis tool fails to detect it.

On the other hand, if the static analysis tool reports an issue with the following code:

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

print(divide(10, 2))
print(divide(10, 0))

because it may not recognize that raising an error in response to a divide by zero is the intended behaviour. This would be an example of a false positive, as the code is correct, but the static analysis tool reports a problem where none exists.

Conclusion

To reduce the number of false negatives and false positives, it's important to choose a static analysis tool that is well-suited to the programming language and application being analyzed and to configure the tool appropriately for your specific needs.
Additionally, it's important to regularly review the results of the static analysis and carefully evaluate each reported issue to determine whether it is a true problem or a false positive.

I hope you learned something new from this post, more to come but if you have a question or a suggestion leave a comment or find me on Twitter

Today, we are going to build a simple music-matching recognizer. The idea is to build a component that is independent of the UI framework being used (SwiftUI or UIKit).

We will create a Swift class named creatively ShazamRecognizer that will have some simple tasks to perform:

1. Create the properties that are going to help us in building our class
2. Request Permission to record audio using the AVFoundation framework
3. Start Recording and Send the record to ShazamKit for recognition matching
4. Handle the response from ShazamKit (Success when a match was found or Error when no match was found)
5. Display our result in a UI (e.g: SwiftUI or UIKit)

Create the properties that are going to help us in building our class

final class ShazamRecognizer: NSObject, ObservableObject {
    // 1. Audio Engine
    private let audioEngine = AVAudioEngine()

    // 2. Shazam Engine
    private let shazamSession = SHSession()

    // 3. UI state purpose
    @Published private(set) var isRecording = false

    // 4. Success Case
    @Published private(set) var matchedTrack: ShazamTrack?

    // 5. Failure Case
    @Published var error: ErrorAlert? = nil
}

In the above declarations, we have:

1. We create the audioEngine which is used to start and stop the recording.
2. We create the shazamSession which is used to perform the matching process.
3. We use isRecording to track whether or not there is an ongoing recording operation. This value can be used for example to show different UI for each state.
4. We create a variable of custom type (ShazamTrack) to store our result in case of success (when a match was found).
5. In case of failure, we store the error in the error variable of type ErrorAlert which can be used to display an Alert or a UI, etc.

Request Permission to record audio using the AVFoundation framework

In our class, we proceed by adding the listenToMusic() function.

func listenToMusic() {
    // 1.
    let audioSession = AVAudioSession.sharedInstance()
    // 2. 
    audioSession.requestRecordPermission { status in
        if status {
            // 3.
            self.recordAudio()
        } else {
            // 4. 
            self.error = ErrorAlert("Please Allow Microphone Access !!!")
        }
    }
}

In our listenToMusic() function:

1. We use an audioSession to communicate to the operating system the general nature of our app’s audio without detailing the specific behaviour or required interactions with the audio hardware.
2. Using the audioSession, We request user's permission to record audio. At this point, we have to add a new property (NSMicrophoneUsageDescription) in our Info.plist, with a message that tells the user why the app is requesting access to the device’s microphone otherwise our app might crash at runtime.
3. In case the user gives permission we start the recording operation in our recordAudio() function that we are going to build in the next section.
4. In case the user has denied permission, we simply store the error in our error variable.

AVAudioSession: An audio session acts as an intermediary between your app and the operating system — and, in turn, the underlying audio hardware.

Start Recording and Send the record to ShazamKit for recognition

Here is what our recordAudio() function looks like! Hmmm!!!, Quite a function~

private func recordAudio() {
    // 1. If the `audioEngine` is running, stop it and return
    if audioEngine.isRunning {
        self.stopAudioRecording()
        return
    }

    // 2. Create a inputNode to listen to
    let inputNode = audioEngine.inputNode

    // 3. Create the format to use for our inputNode 
    /// We are using .zero as a bus for this example
    let format = inputNode.outputFormat(forBus: .zero)

    // 4. Removes the tap if already installed on the node
    inputNode.removeTap(onBus: .zero)

    // 5. Install an audio tap on the bus using our inputNode
    // Record, monitor, and observe the output of the node.
    // This will listen to music continuously
    inputNode.installTap(onBus: .zero,
                         bufferSize: 1024,
                         format: format)
    { buffer, time in
        // 6. Start Shazam Matching Operation,
        // Converts the audio in the buffer to a signature and 
        // searches the reference signatures in the session catalog.
        self.shazamSession.matchStreamingBuffer(buffer, at: time)
    }

    // 7. Prepare the audio engine to start
    audioEngine.prepare()

    do {
        // 8. Start the audio engine
        try audioEngine.start()

        DispatchQueue.main.async {
            // 9. Set the recording state to true
            self.recording = true
        }
    } catch {
        // 10. Handle any error that may occur
        self.error = ErrorAlert(error.localizedDescription)
    }
}

After going, through the above function, the question to be asked is, how do we handle the response that the shazamSession will return?

No worries, that's the topic for our next exciting section.

In case, you are wondering what the stopAudioRecording() function mentioned above looks like, here you go:

private func stopAudioRecording() {
    audioEngine.stop()
    isRecording = false
}

Handle the response from ShazamKit

First, we need to tell the shazamSession, where to delegate its result!

As you can see below, we are using our ShazamRecognizer class as the delegate for the session so that we can be informed when there is a successful result or a failure.

override init() {
    super.init()
    // Sets delegate to be ShazamRecognizer class
    shazamSession.delegate = self
}

By doing the above, we are obliged to conform to the SHSessionDelegate protocol, and implement its delegate methods. So We extend our class and add the following:

extension ShazamRecognizer: SHSessionDelegate {
    func session(_ session: SHSession, didFind match: SHMatch) {
        DispatchQueue.main.async {
            // 1.
            if let firstItem = match.mediaItems.first {
               // 1.
                self.matchedTrack = ShazamTrack(firstItem)
                // 2.
                self.stopAudioRecording()
            }
        }
    }

    func session(_ session: SHSession, didNotFindMatchFor signature: SHSignature, error: Error?) {
        DispatchQueue.main.async {
            // 3.
            self.error = ErrorAlert(error?.localizedDescription ?? "No Match found!")
            // 4. Stop Audio recording
            self.stopAudioRecording()
        }
    }
}

Our first delegate method is func session(_ session: SHSession, didFind match: SHMatch), It is called when a match was found. Here, we:

1. Get the first item in the match's mediaItems(An array of the media items in the catalog that match the query signature, in order of the quality of the match); We then convert the firstItem of type SHMatchedMediaItem into our own custom model ShazamTrack
2. We stop the audio recording by calling our stopAudioRecording() which stops our audioEngine.

Our second delegate method is func session(_ session: SHSession, didNotFindMatchFor signature: SHSignature, error: Error?), It is is called when no match was found. Here, we:

1. Send the error message to our error variable.
2. We stop the audio recording by calling our stopAudioRecording() which stops our audioEngine.

At this point, We are pretty much done with our audio recognition system!👏🏻💪🏼. We are ready to use it in our application, no matter the UI framework.

For this example, I've used SwiftUI for a quick prototype, but you can use UIKit as well without any particular effort.

You can find the full demo project

Conclusion

ShazamKit framework has a lot to offer, but in this article, we have just scratched the tip of the iceberg, I hope you have learned something today :)

Today, we will focus on how we can utilize combine's publishers and subscribers system to fetch remote data from a remote data source and populate the data to our UI.

We'll keep it simple and stupid!; I chose the Random Data API, and we'll be using their Users Endpoint which provides some mock information for a random user.

Step1: Create the data models for our API

We are going to need the RemoteUser and the Address models

// MARK: - RemoteUser
struct RemoteUser: Identifiable, Codable {
    let id: Int
    let firstName, lastName: String
    let username, email: String
    let phoneNumber: String
    let address: Address

    enum CodingKeys: String, CodingKey {
        case id
        case firstName = "first_name"
        case lastName = "last_name"
        case username, email
        case phoneNumber = "phone_number"
        case address
    }
}

// MARK: - Address
struct Address: Codable {
    let city: String
    let state: String
    let country: String

    enum CodingKeys: String, CodingKey {
        case city
        case state, country
    }

    func formatted() -> String {
       return "\(city), \(state), \(country)"
    }
}

Step2: Introduce a fetch function

This function does the heavy lifting for us, taking an input of type URLRequest as a parameter and returning an output of type AnyPublisher<T, Error>

func perform<T: Decodable>(_ request: URLRequest) -> AnyPublisher<T, Error> {
    return URLSession.shared
        .dataTaskPublisher(for: request) // Returns a publisher that wraps a URL session data task for a given URL request.
        .map { $0.data }
        .decode(type: T.self, decoder: JSONDecoder())
        .receive(on: DispatchQueue.main) // Receive elements on the Main Queue
        .eraseToAnyPublisher()
}

Step3: Build our simple UI and Run

Basically, in our ContenView, we will use a simple List where we shall be showing our user information represented by a UserRowView

import Combine
struct ContentView: View {
    @State private var users = [RemoteUser]() // Store our users
    @State private var isFetchingData = false // Manage the fetching spinner
    @State private var cancellables = Set<AnyCancellable>()

    var body: some View {
        NavigationView {
            List {
                ForEach(users) { user  in
                    UserRowView(user)
                }

                if isFetchingData {
                    ProgressView()
                        .frame(maxWidth: .infinity)
                }
            }
            .navigationTitle("\(users.count) Active Users")
            .onAppear(perform: fetchSomeData) // fetch data when view appears
        }
    }

    // Some raw URLRequest for testing purpose 
    private func getURLRequest() -> URLRequest {
        var request = URLRequest(url: URL(string: "https://random-data-api.com/api/v2/users")!)
        request.httpMethod = "GET"
        return request
    }

    // Perform network call
    private func fetchSomeData() {
        guard users.count < 50 else { return }
        let result: AnyPublisher<RemoteUser, Error> = perform(getURLRequest())
        isFetchingData = true

        result.sink { _ in
        } receiveValue: { item in
            print(item)
            self.users.append(item)
            isFetchingData = false
            fetchSomeData() // Fetch new data when request has completed
        }
        .store(in: &cancellables) // Stores a type-erasing cancellable instance.
    }
}

struct UserRowView: View {
    private let user: RemoteUser
    init(_ user: RemoteUser) {
        self.user = user
    }
    var body: some View {
        VStack(alignment: .leading, spacing: 10) {
            Text("Name: \(user.firstName) \(user.lastName)")
                .fontWeight(.bold)
            Text("Username: \(Text("@\(user.username)").foregroundColor(.accentColor))")
                .fontWeight(.semibold)
            Text("Tél: \(user.phoneNumber)")
                .fontWeight(.medium)
            Text("Address: \(user.address.formatted())")
                .italic()
                .foregroundColor(.secondary)
        }
        .padding(8)
        .frame(maxWidth: .infinity, alignment: .leading)
        .cornerRadius(10)
    }
}

You will observe that on every successful request, another request will be made until the number of users reaches 50 as specified in the code.

Conclusion

Combine framework has a lot to offer, but in this article, we have just scratched the tip of the iceberg, I hope you have learned something today :)