All videos. All books. One low price.

Get unlimited access to all video courses and books on this site with the new Ultimate Subscription. Plans start at just $19.99/month.

Home iOS & Swift Tutorials

Instruments Tutorial: Getting Started

Learn how to use Instruments to catch and fix memory issues and performance bugs in your apps to make them faster and more responsive.

5/5 13 Ratings


  • Swift 5, iOS 13, Xcode 11
Update note: Fabrizio Brancati updated this tutorial for iOS 13, Xcode 11 and Swift 5.1. Nicholas Sakaimbo wrote an earlier update and Matt Galloway wrote the original.

Besides improving their apps by adding features, there is one thing that all good app developers should do: Instrument their code!

This Instruments tutorial will show you how to use the most important features of the Instruments tool that ships with Xcode. It allows you to check your code for performance issues, memory issues, reference cycles and other problems.

All set? Get ready to dive into the fascinating world of Instruments!

Getting Started

For this Instruments tutorial, you won’t go through the process of creating an app from scratch. Instead, the download materials include a complete sample project for you. Your task is to go through the app and improve it using Instruments as your guide, much like you would do for your own apps!

Download the project materials using the Download Materials button at the top or bottom of this tutorial. Open the starter project in Xcode.

This sample app uses the Flickr API to search for images. To use the API, you need an API key. For demo projects, you can generate a sample key on Flickr’s website. Simply perform any search in the Flickr API Explorer and copy the API key from the URL at the bottom. It follows the “&api_key=” all the way to the next “&”.

For example, if the URL is:

Then the API key is: ff417a50b95180cb0c7e3b68a8749fba.

Open FlickrAPI.swift and replace the existing API key value with your new value.

Note that the API key changes every day or so, so you’ll occasionally have to regenerate a new key. The app will alert you whenever the key is invalid.

Build and run, perform a search, click the result and you’ll see something like this:

The starter project for this tutorial

Play with the app and check out its basic functions. You might be tempted to think that once the UI looks great, the app is ready for store submission. However, you’re about to see the value that using Instruments can add to your app.

The rest of this tutorial shows you how to find and fix the issues that still exist in the app. You’ll see how Instruments can make debugging problems a whole lot easier!

Time for Profiling

The first instrument you’ll look at is the Time Profiler. At measured intervals, Instruments will halt the execution of the program and take a stack trace on each running thread. Think of it as clicking the pause button in Xcode’s debugger.

Here’s a sneak preview of the Time Profiler:

Time Profiler - Call Tree

This screen displays the Call Tree. The Call Tree shows the amount of time spent executing various methods within an app. Each row is a different method the program’s execution path has followed. Instruments approximates the time spent in each method by counting the number of times the profiler stops in each method.

For instance, if you take 100 samples at 1 millisecond intervals and a particular method appears at the top of the stack in 10 samples, you can deduce that the app spent approximately 10% of the total execution time — 10 milliseconds — in that method. It’s a fairly crude approximation, but it works!

Note: In general, you should always profile your app on an actual device, instead of the simulator. The iOS simulator has all of the horsepower of your Mac behind it, whereas a device will have all of the limitations of mobile hardware. Your app may seem to run just fine in the simulator, but you might discover a performance issue once it’s running on a real device.

So without any further ado, time to get instrumenting!


From Xcode’s menu bar, select Product ▸ Profile or press Command-I. This builds the app and launch Instruments. You’ll see a selection window that looks like this:

Xcode Time Profiler Selection

These are all different templates that come with Instruments.

Select the Time Profiler instrument and click Choose. This opens a new Instruments document. Click the red record button at the top left to start recording and launch the app. macOS may ask for your password to authorize Instruments to analyze other processes. Fear not, it’s safe to provide here!

In the Instruments window, you can see the time counting up and a little arrow moving from left to right above the graph in the center of the screen. This indicates the app is running.

Now, start using the app. Search for some images, and drill down into one or more of the search results. You have probably noticed that going into a search result is tediously slow, and scrolling through a list of search results is also incredibly annoying. It’s a terribly clunky app!

Well, you’re in luck. You’re about to embark on fixing it! However, you’re first going to get a quick rundown on what you’re looking at in Instruments.

First, make sure the view selector on the right-hand side of the toolbar has both options selected, like so:

Instruments - View Selector

That ensures all panels are open. Now, study the screenshot below and the explanation of each section beneath it:

Time Profiler Main Window

  1. Recording controls: The red ‘record’ button stops and starts the app currently under test. The pause button pauses the current execution of the app.
  2. Run timer: The timer counts how long the profiled app has been running and how many times it has run. Click the stop button, then restart the app. You’ll see the display now shows Run 2 of 2.
  3. Instrument track: In the case of the Time Profiler template you selected, there’s only one instrument, so there’s only one track. You’ll learn more about the specifics of the graph later in the tutorial.
  4. Detail panel: Shows the main information about the particular instrument you’re using. In this case, it shows the methods which are “hottest” — that is, the ones which have used the most CPU time.

    At the top of the detail panel, click Profile and select Samples. Here you can view every single sample. Click on a few samples; you’ll see the captured stack trace appear in the Extended Detail inspector to the right. Switch back to Profile when you’re done.

  5. Inspectors panel: There are two inspectors — Extended Detail and Run Info — which you’ll learn more about shortly.

Drilling Deep

Perform an image search, and drill into the results. I personally like searching for “dog”, but choose whatever you wish — you might be one of those cat people!

Now, scroll up and down the list a few times so that you’ve got a good amount of data in the Time Profiler. You should notice the numbers in the middle of the screen changing and the graph filling in. This tells you your app is using CPU cycles.

No collection view is ready to ship until it scrolls like butter!

To help pinpoint the problem, you’ll set some options. Click Stop and, below the detail panel, click Call Tree. In the popover that appears, select Separate by Thread, Invert Call Tree and Hide System Libraries. It will look like this:

Time Profiler Call Tree Settings

Here’s what each option is doing to the data displayed in the table to the left:

  • Separate by State: This option groups results by your app’s life cycle state and is a useful way to inspect how much work your app is doing and when.
  • Separate by Thread: Treat each thread separately. This enables you to understand which threads are responsible for the greatest amount of CPU use.
  • Invert Call Tree: With this option, the stack trace show the most recent frame first.
  • Hide System Libraries: When you select this option, only symbols from your own app are displayed. It’s often useful to select this option since usually you only care about where the CPU is spending time in your own code — you can’t do much about how much CPU the system libraries are using!
  • Flatten Recursion: This option shows recursive functions, ones which call themselves, with one entry in each stack trace, rather than multiple times.
  • Top Functions: Enabling this makes Instruments consider the total time spent in a function as the sum of the time directly within that function, as well as the time spent in functions called by that function. So if function A calls B, then Instruments reports A’s time as the time spent in A plus the time spent in B. This can be really useful, as it lets you pick the largest time figure each time you descend into the call stack, zeroing in on your most time-consuming methods.

Scan the results to identify which rows have the highest percentage in the Weight column. Notice that the row with the Main Thread is using up a significant proportion of CPU cycles. Unfold this row by clicking the small arrow to the left of the text and drill down until you see of one of your own methods, marked with the “person” symbol. Although some values may be slightly different, the order of the entries should be similar to the table below:

Call Tree Results

Well, that certainly doesn’t look good. The app spends the vast majority of time in the method that applies the “tonal” filter to the thumbnail photos. That shouldn’t come as too much of a shock to you, as the table loading and scrolling were the clunkiest parts of the UI, and that’s when the table cells are constantly being updated.

To find out more about what’s going on within that method, double-click its row in the table. Doing so will bring up the following view:

Time Profiler Code

applyTonalFilter() is a method added to UIImage in an extension, and it spends a lot of time invoking the method that creates the CGImage output after applying the image filter.

There’s not really much you can do to speed this up. Creating the image is an intensive process and takes as long as it takes. Try stepping back to see where the app callsapplyTonalFilter(). Click Root in the breadcrumb trail at the top of the code view to get back to the previous screen:

Call Tree Breadcrumb

Now, click the small arrow to the left of the applyTonalFilter row at the top of the table. This will show the caller of applyTonalFilter — you may need to unfold the next row too. When profiling Swift, there will sometimes be duplicate rows in the Call Tree, prefixed with @objc. You’re interested in the first row that’s prefixed with the “person” icon, which indicates it belongs to your app’s target:

Tonal Filter Call Tree

In this case, this row refers to the results collection view’s (_:cellForItemAt:). Double-click the row to see the associated code from the project.

Now you can see what the problem is. Take a look at line 70: The method to apply the tonal filter takes a long time to execute, and you call it directly from collectionView(_:cellForItemAt:). This will block the main thread and, therefore, the entire UI each time it asks for a filtered image.

Offloading the Work

To solve this, you’ll take two steps: First, offload the image filtering onto a background thread with Then, cache each image after it’s generated. There is a small, simple image caching class — with the catchy name ImageCache — included in the starter project, that simply stores images in memory and retrieves them with a given key.

You could now switch to Xcode and manually find the source file you’re looking at in Instruments. But, there’s a handy Open in Xcode button in Instruments. Locate it in the panel just above the code and click it:

Open In Xcode Button

There you go! Xcode opens at exactly the right place. Boom!

Now, within collectionView(_:cellForItemAt:), replace the call to loadThumbnail(for:completion:) with the following:

ImageCache.shared.loadThumbnail(for: flickrPhoto) { result in
  switch result {
  case .success(let image):
    if cell.flickrPhoto == flickrPhoto {
      if flickrPhoto.isFavourite {
        cell.imageView.image = image
      } else {
        // 1
        if let cachedImage = 
          ImageCache.shared.image(forKey: "\(") {
          cell.imageView.image = cachedImage
        } else {
          // 2
            if let filteredImage = image.applyTonalFilter() {
                                    forKey: "\(")
              DispatchQueue.main.async {
                cell.imageView.image = filteredImage
  case .failure(let error):
    print("Error: \(error)")

The first section of this code is the same as it was before and loads the Flickr photo’s thumbnail image from the web. If the photo is a favorite, the cell displays the thumbnail without modification. However, if the photo isn’t a favorite, it applies the tonal filter.

This is where you changed things:

  1. Check to see if a filtered image for this photo exists in the image cache. If yes, great; display that image.
  2. If not, dispatch the call to apply the tonal filter onto a background queue. This allows the UI to remain responsive while the filter runs. When the filter completes, save the image in the cache and update the image view on the main queue.

That’s the filtered images taken care of, but there’s still the original Flickr thumbnails to resolve. Open Cache.swift and find loadThumbnail(for:completion:). Replace it with the following:

func loadThumbnail(for photo: FlickrPhoto,
                   completion: @escaping FlickrAPI.FetchImageCompletion) {
  if let image = ImageCache.shared.image(forKey: {
  } else {
    FlickrAPI.loadImage(for: photo, withSize: "m") { result in
      if case .success(let image) = result {
        ImageCache.shared.set(image, forKey:

This is quite similar to the way you handled filtered images. If an image already exists in the cache then you call the completion closure straight away with the cached image. Otherwise, you load the image from Flickr and store it in the cache.

Press Command-I to run the app in Instruments again. Notice this time Xcode doesn’t ask you which instrument to use. This is because you still have a window open for your app, and Instruments assumes you want to run again with the same options.

Perform a few more searches. The UI is not quite so clunky now! The app now applies the image filter in the background and caches the result, so images only have to be filtered once. You’ll see a number of dispatch_worker_threads in the Call Tree. These are handling the heavy lifting of applying image filters.

Looks great! Is it time to ship it? Not yet!

Allocations, Allocations and Allocations

So what bug are you going to track down next?

There’s something hidden in the project that you probably don’t know is there. You’ve likely heard about memory leaks. But what you may not know is that there are actually two kinds of leaks:

  1. True memory leaks: Occur when an object is no longer referenced by anything but is still allocated. That means the memory can never be re-used.

    Even with Swift and ARC helping manage memory, the most common kind of memory leak is a retain cycle or strong reference cycle. This occurs when two objects hold strong references to one another so that each object keeps the other one from being deallocated. As a result, their memory is never released.

  2. Unbounded memory growth: Occurs when memory is allocated continuously and never given a chance to be deallocated. If this continues unchecked, you’ll run out of memory. On iOS, this means the system will terminate your app.

Now you’re going to explore the Allocations instrument. This instruments gives you detailed information about all the objects your app creates and the memory that backs them. It also shows you retain counts of each object.

Instrumenting Allocations

To start fresh with a new instruments profile, quit the Instruments app. Don’t worry about saving this particular run. Now, press Command-I in Xcode, select Allocations from the list and click Choose.

Instruments Allocations

After a moment, you’ll see the Allocations instrument. It should look familiar to you, because it looks a lot like the Time Profiler.

Instruments Allocations Start

Click the Record button on the top left to run the app. This time you’ll notice two tracks. For the purposes of this tutorial, you’ll only be concerned with the one called All Heap and Anonymous VM.

Allocations Started

With the Allocations instrument running on the app, make five different searches in the app but do not drill down into the results yet. Make sure the searches have some results. Now, let the app settle a bit by waiting a few seconds.

You should have noticed the graph in the All Heap and Anonymous VM track has been rising. This tells you your app is allocating memory. It’s this feature that will guide you in finding unbounded memory growth.

Generation Analysis

What you’re going to perform is a generation analysis. To do this, click the button labeled Mark Generation at the bottom of the detail panel:

Mark Generation Button

Click it and you will see a red flag appear in the track, like so:

Red Flag

The purpose of generation analysis is to perform an action multiple times, and see if memory is growing in an unbounded fashion. Open the results of a search, wait a few seconds for the images to load, then go back to the main page. Mark the generation again. Do this repeatedly for different searches.

After examining several searches, Instruments will look like this:


At this point, you should be getting suspicious. Notice how the blue graph goes up with each search you drill into. Well, that certainly isn’t good. But wait, what about memory warnings? You know about those, right?

Simulating a Memory Warning

Memory warnings are iOS’s way of telling an app that things are getting tight in the memory department and that you need to clear out some memory.

It’s possible that this growth is not just due to your app. It could be something in the depths of UIKit that’s holding onto memory. Give the system frameworks and your app a chance to clear their memory first before pointing a finger at either one.

Simulate a memory warning by selecting Instrument ▸ Simulate Memory Warning in Instruments’ menu bar, or Hardware ▸ Simulate Memory Warning from the simulator’s menu bar. You’ll notice that memory usage dips a little, or perhaps not at all. Certainly not back to where it should be. So there’s still unbounded memory growth happening somewhere.

You marked a generation after each iteration of examining a search so you can see what memory is allocated between each generation. Take a look in the detail panel and you’ll see a bunch of generations.

Within each generation, you’ll see all the objects that were allocated and still resident at the time that generation was marked. Subsequent generations will contain just the objects since the previous generation was marked.

Look at the Growth column and you’ll see that there is definitely growth occurring somewhere. Open one of the generations and you’ll see this:

Generation Analysis

Wow, that’s a lot of objects! Where do you start?

Easy. Click the Growth header to sort by size. Make sure the heaviest objects are at the top. Right near the top of each generation, you’ll notice a row labeled VM: CoreImage, which certainly sounds familiar! Click the arrow to the left of VM: CoreImage to display the memory addresses associated with this item. Select the first memory address to display the associated stack trace in the Extended Detail inspector on the panel to the right:

This stack trace shows you the point when this specific object was created. The parts of the stack trace in gray are in system libraries. The parts in black are in your app’s code. Hmm, something looks familiar: Some of the black entries show your old friend collectionView(_:cellForItemAt:). Double-click any of those entries; Instruments will bring up the code in its context.

Take a look through the method. It calls set(_:forKey:) on line 79. Remember, this method caches an image in case it’s used again in the app. That certainly sounds like it could be a problem!

Again, click Open in Xcode to jump back into Xcode. Open Cache.swift and take a look at the implementation of set(_:forKey:):

func set(_ image: UIImage, forKey key: String) {
  images[key] = image

This adds an image to a dictionary, keyed on the photo ID of the Flickr photo. But, you’ll notice the image is never cleared from that dictionary!

That’s where your unbounded memory growth is coming from. Everything is working as it should, but the app never removes things from the cache — it only ever adds them!

To fix the problem, all you need to do is have ImageCache listen for the memory warning notification UIApplication fires. When ImageCache receives this, it must be a good citizen and clear its cache.

To make ImageCache listen for the notification, open Cache.swift and add the following initializer to the class:

init() {
    forName: UIApplication.didReceiveMemoryWarningNotification,
    object: nil,
    queue: .main) { [weak self] notification in
      self?.images.removeAll(keepingCapacity: false)

This registers an observer for UIApplicationDidReceiveMemoryWarningNotification to execute a closure which clears images.

All that the code needs to do is remove all objects in the cache. This ensures nothing is holding onto the images anymore and they will be deallocated.

To test this fix, fire up Instruments again and repeat the steps you followed previously. Don’t forget to simulate a memory warning at the end.

Note: Make sure you launch from Xcode, triggering a build, rather than just hitting the red button in Instruments, in order to make sure you’re using the latest code. You may also want to build and run first before Profiling. Sometimes Xcode doesn’t seem to update the build of the app in the simulator to the latest version if you just Profile.

This time, the generation analysis should look like this:

You’ll notice the memory usage dropped after the memory warning. There’s still some memory growth overall, but nowhere near as much as before.

The reason there’s still some growth is really due to the system libraries, and there’s not much you can do about those. It appears the system libraries are not freeing all of their memory, which may be by design or may be a bug. All you can do in your app is free up as much memory as possible, and you’ve already done that!

Well done! One more issue patched up! It must be time to ship by now! Oh, wait — there’s still the issue of the first type of leak that you haven’t yet addressed.

Strong Reference Cycles

As mentioned earlier, a strong reference cycle occurs when two objects hold strong references to each other, preventing both from being deallocated. You can detect these cycles using the Allocations instrument in a different way.

Close Instruments and return to Xcode. Choose Product ▸ Profile once again, and select the Allocations template.

This time, you won’t be using generation analysis. Instead, you’ll look at the number of objects of different types that are hanging around in memory. Click the Record button to start this run. You should already see a huge number of objects filling up the detail panel — too much to look through! To help narrow down only the objects of interest, type “Instruments” as a filter in the field in the bottom-left corner.

The two columns worth noting in Instruments are # Persistent and # Transient. The # Persistent column keeps a count of the number of objects of each type that currently exist in memory. The Transient column shows the number of objects that existed but have since been deallocated. Persistent objects are using up memory; transient objects are not.

Finding Persistent Objects

You should see there is a persistent instance of ViewController. This makes sense because that’s the screen you’re currently looking at. There’s also an instance of the app’s AppDelegate.

Back to the app! Perform a search and drill into the results. Notice that a bunch of extra objects are now showing up in Instruments: The SearchResultsViewController and the ImageCache among others. The ViewController instance is still persistent, because it’s needed by its navigation controller.

Now tap the back button in the app. This pops the SearchResultsViewController off the navigation stack, so it should be deallocated. But it’s still showing a # Persistent count of 1 in the Allocations summary! Why is it still there?

Try performing another two searches and tap the back button after each one. There are now three SearchResultsViewControllers?! The fact that these view controllers are hanging around in memory means that something is keeping a strong reference to them. Looks like you have a strong reference cycle!

Your main clue in this situation is that not only is the SearchResultsViewController persisting, but so are all the SearchResultsCollectionViewCells. It’s likely that the reference cycle is between these two classes.

Thankfully, the Visual Memory Debugger, introduced in Xcode 8, is a neat tool that can help you further diagnose memory leaks and retain cycles. The Visual Memory Debugger is not part of Xcode’s Instrument’s suite but is nevertheless such a useful tool that it’s worth including in this tutorial. Cross-referencing insights from both the Allocations instrument and the Visual Memory Debugger is a powerful technique that can make your debugging workflow a lot more effective.

Getting Visual

Quit Instruments.

Before starting the Visual Memory Debugger, enable Malloc Stack logging in the Xcode scheme editor like this: Option-Click the InstrumentsTutorial scheme at the top of the window (next to the stop button). In the pop-up that appears, click the Run section and switch to the Diagnostics tab. Check the box that says Malloc Stack and select the Live Allocations Only option and click Close.

Visual Memory Debugger Scheme

Start the app directly from Xcode. As before, perform at least three searches to accumulate some data.

Now, activate the Visual Memory Debugger like this:

Memory Graph

  1. Switch to the Debug navigator.
  2. Click this icon and choose View Memory Graph Hierarchy from the pop-up.
  3. Click the entry for the SearchResultsCollectionViewCell.
  4. You can click any object on the graph to view details on the inspectors pane.
  5. You can view details in this area. Switch to the Memory inspector here.

The Visual Memory Debugger pauses your app and displays a visual representation of objects in memory and the references between them.

As highlighted in the screenshot above, the Visual Memory Debugger displays the following information:

  • Heap contents (Debug navigator pane): This shows you the list of all types and instances allocated in memory at the moment your app was paused. Clicking a type unfolds the row to show you the separate instances of the type in memory.
  • Memory graph (main window): The main window shows a visual representation of objects in memory. The arrows between objects represent the references between them (strong and weak relationships).
  • Memory inspector (Utilities pane): This includes details such as the class name and hierarchy, and whether a reference is strong or weak.

Notice how some rows in the Debug navigator have a bracketed number next to them. The number in brackets indicates how many instances of that specific type are in memory. In the screenshot above, you can see that after a handful of searches, the Visual Memory Debugger confirms the results you saw in the Allocations instrument. In other words, anywhere from 20 to — if you scrolled to the end of the search results — 60 SearchResultsCollectionViewCell instances for every SearchResultsViewController instance are being retained in memory.

Use the arrow on the left side of the row to unfold the type and show each SearchResultsViewController instance in memory. Clicking an individual instance will display that instance and any references to it in the main window.

Visual Memory Debugger

Notice the arrows pointing to the SearchResultsViewController instance. It looks like there are a few Swift closure contexts instances with references to the same view controller instance. Looks a little suspect, doesn’t it? Take a closer look. Select one of the arrows to display more information in the Utilities pane about the reference between one of these closure instances and the SearchResultsViewController.

Visual Memory Debugger

In the Memory Inspector, you can see the reference between the Swift closure context and the SearchResultsViewController is strong. If you select the reference between the SearchResultsCollectionViewCell and the Swift closure context, you will see this is marked strong as well. You can also see that the closure’s name is “heartToggleHandler.” A-ha! SearchResultsCollectionViewCell declares this!

Select the instance of SearchResultsCollectionViewCell in the main window to show more information on the inspector pane.

Visual Memory Debugger

In the backtrace, you can see that the cell instance was initialized in collectionView(_:cellForItemAt:). When you hover over this row in the backtrace, a small arrow will appear. Clicking the arrow will take you to this method in Xcode’s code editor.

In collectionView(_:cellForItemAt:), locate where each cell’s heartToggleHandler property is set. You’ll see the following lines of code:

cell.heartToggleHandler = { isStarred in
  self.collectionView.reloadItems(at: [indexPath])

This closure handles when the user taps the heart button in a collection view cell. This is where the strong reference cycle lies, but it’s kind of hard to spot unless you’ve come across one before. But thanks to the Visual Memory Debugger, you were able to follow the trail all the way to this piece of code!

The closure cell refers to the SearchResultsViewController using self, which creates a strong reference. The closure captures self. Swift actually forces you to explicitly use the word self in closures, whereas you can usually drop it when referring to methods and properties of the current object. This helps you be more aware of the fact you’re capturing it. The SearchResultsViewController also has a strong reference to the cells, via its collection view.

Break That Cycle

To break a strong reference cycle, you define a capture list as part of the closure’s definition. A capture list can be used to declare instances that are captured by closures as being either weak or unowned:

  • Weak: Use when the captured reference might become nil in the future. If the object it refers to is deallocated, the reference becomes nil. As such, they are optional types.
  • Unowned: Use when the closure and the object it refers to will always have the same lifetime and will be deallocated at the same time. An unowned reference can never become nil.

To fix this strong reference cycle, add a capture list to the heartToggleHandler like this:

cell.heartToggleHandler = { [weak self] isStarred in
  self?.collectionView.reloadItems(at: [indexPath])

Declaring self as weak means that the SearchResultsViewController can be deallocated even though the collection view cells hold a reference to it, as they are now just weak references. And deallocating the SearchResultsViewController will deallocate its collection view and, in turn, the cells.

From within Xcode, press Command-I again to build and run the app in Instruments.

Look at the app again in Instruments using the Allocations instrument as you did before. Remember to filter the results down to show only the classes that are part of the starter project. Perform a search, navigate into the results and back again. You should see that the SearchResultsViewController and its cells are now deallocated when you navigate back. They show transient instances, but no persistent ones.

Cycle broken! Ship it!

Where to Go From Here?

You can download the finished project using the Download Materials button at the top or bottom of this tutorial.

Now that you have the knowledge from this Instruments tutorial under your belt, go and instrument your own code and see what interesting things appear! Also, try to make Instruments a part of your usual development workflow.

You should be running your code through Instruments relatively often and performing a full sweep of your app before release to ensure that you’ve caught as many memory management and performance issues as possible.

Now, go and make some awesome — and efficient — apps!

Average Rating


Add a rating for this content

13 ratings

More like this