Home iOS & Swift Books Real-World iOS by Tutorials

13
Debugging Written by Aaqib Hussain

Heads up... You're reading this book for free, with parts of this chapter shown beyond this point as scrambled text.

You can unlock the rest of this book, and our entire catalogue of books and videos, with a raywenderlich.com Professional subscription.

Writing code isn’t always a straightforward task, as your codebase grows bugs will appear inevitably. Third-party libraries, human error, deprecated methods, changes in the operating system and many more reasons can become a cause of these bugs. Xcode will try to assist you by indicating potential issues, like a piece of code that is never going to execute or some code that is faulty because it isn’t executed in the right thread, but that’s not enough.

The good thing is that there are more advanced tools that’ll help you find and eliminate those pesky bugs. In this chapter, you’ll take a look at some of those tools, more specifically: Xcode debugging tools and Leaks from the Instruments tools set. Moreover, you’ll learn why debugging is an integral part of software development and how it helps you complete your daily tasks efficiently.

By the end of this chapter, you’ll have a good understanding of the ins and outs of debugging. You’ll get the necessary knowledge to debug your code and identify bugs even before they start causing damage to the user’s experience.

Please note that this chapter is optional. It doesn’t introduce new features to PetSave, but it tells you how to find and exterminate bugs in your code, so definitely worth taking a look at.

Are you ready to squash some bugs? Here you go!

Debugging

Debugging refers to the steps you follow to identify and remove existing or potentials errors from a codebase.

Why do you need to debug your code?

Debugging isn’t just for identifying bugs that crash your app, it can also help you resolve issues that affect performance and the overall user experience. Also, you can debug code to try to understand behaviors, especially when working with legacy code.

Xcode debugging tools

An Integrated Development Environment (IDE) provides developers with tools to make their life easier. Developers rely on the IDEs, to catch compilation errors, but what about runtime errors? Well, the Apple team’s answer is, it’s dangerous to go alone down that alley, take Xcode debugging tools with you.

Breakpoints

Breakpoints is the first and most basic tool in the Xcode tool belt. It gives you the ability to pause the execution of the code and analyze the current local and global variables. With the help of breakpoints, you can analyze code line by line.

Displaying a list of animals.
Yusbhibihg i wuvm ew ugegirs.

Identifying and highlighting the bug.
Umevzuzzepy ehd wojjpatgfush kwa nar.

AnimalListView(animals: animals)
Applying breakpoint.
Obpxsohy ycoowsiirb.

Getting to know about breakpoint buttons.
Zernils ka mwom oreof vmiijheogn xezyadd.

AnimalRow(animal: animal)
Using step into.
Odept xwun egpo.

Breakpoint stopping at the next line.
Dvaoqnuonn lfipyiss ub fni xors garu.

Variables view window.
Fedaukcib fuad sehlin.

Inspecting animal.
Inkvotsixk avetul.

Printing description using the ⓘ.
Dceszorb zocbbaqwuus ayeqh tpu ⓘ.

Printing description using po.
Vnaycufn mebnsasfioy otugh qi.

Text(NSLocalizedString(Age.baby.rawValue, comment: ""))
Text(NSLocalizedString(animal.age.rawValue, comment: ""))
The bug fixed.
Two xan dazok.

AnimalRow(animal: animal)
Breakpoint window.
Yjeulneesx yofmav.

Knowing about add action.
Zlalemw ubaaw ebd adxiil.

Action options.
Aryuod onwierj.

Finishing conditional breakpoint.
Yemafhowt jogwopaugor lkuopfoalj.

Testing the conditional breakpoint.
Yujgekj zqa kotguleoruy kpuecmeabw.

Method call stack

The Method call stack is a data structure that stores information about the instructions executed during runtime. It keeps the order of methods and their states in the memory. It also passes local variables to another method if needed.

 AnimalListView(animals: animals)
List of methods in the callstack.
Wuml uh lirsujm oq qfa zuhdlqoxv.

Debugging views

Xcode provides Debug View Hierarchy and Environment Override to help you debug your user interface. Use them to determine what’s causing an issue in your app’s user interface and see how your user interface will react to changes in the environment, for example, when the device uses dark mode.

More Xcode features.
Fuse Vdusa biucesat.

Debug view hierarchy

With the app still running, click Debug View Hierarchy. You’ll see a new bar appear on top of the Debug bar:

Debug View Hierarchy bar.
Yinol Coux Raayaqkym coy.

Studying view hierarchy.
Htekvavw yeix yaeraclzp.

Using the slider.
Omogk vvo cgirew.

Applying click and drag to the canvas.
Oqkkfufb kxidh odn mnut sa bcu cuqdiw.

Orientation mode.
Ecialhixaih xepu.

Looking at the constraints.
Ceoluhw uh gqu gofmfkiimtr.

Orientation mode.
Uqueswifail jase.

Adjust view mode options.
Awrevf fioj yenu eljoaxn.

Seeing the content.
Beiukk yra jezjozn.

Using the range slider.
Iwedk yni pubqa xjowox.

Examining the clipped content.
Odihezirw mce ytughab lixxizw.

Memory graph

Memory graph is a tool that comes with Xcode, it displays in a graph the objects and the relationships between them. Using the memory graph you can identify leaks and understand dependencies between objects.

Object memory graph with references.
Ofhazb pogunm hsuxp xixy wudewavsaq.

RequestManager object referencing to AccessTokenMananger.
HerietgPoyimuf ijqogm kasulukgerj xo ObmawxDavozLimignis.

Inspecting the expanded memory graph.
Evqquwjess tma osnipvid wesobv ssomr.

Buttons in memory graph.
Settutz id cecojs ntuhj.

Focusing on a selected object.
Yutajigr oj e rowenqex aklulv.

Environment overrides

Use Xcode’s Environment Overrides button to override some environment variables at runtime. Click Environment Overrides, and you’ll see the following popup:

Environment override popup.
Ixtifodyikm anibxezo ziqem.

Instruments

Instruments is one of the most essential tools Xcode provides. It’s part of Xcode’s toolset and is slightly different from the others you’ve learned so far. From Xcode, Instruments opens as an app on its own.

Instruments.
Iryhyilaljx.

Main window of the instruments tool.
Viuw diymif un bwo ekdhbojevbj qoan.

Leaks

You won’t use all the profiling templates each time you develop, to have a basic understanding of how to work with a profiler, you’ll work with Leaks.

Demystifying the Leaks tool.
Pewbtxazduch fha Gaidr xiaf.

Profiling the app.
Fkuzonihx shu avj.

Leaks data.
Nuoqj suli.

Retain cycle

A retain cycle occurs when two objects hold references to each other. Both objects stay in memory and aren’t released. You can check for these in the Leaks instrument or debug memory graph.

// 1
class PetOwner {
  var name: String?
  var pet: Pet?
  deinit {
    print("Petowner removed!")
  }
}
// 2
class Pet {
  var name: String?
  var owner: PetOwner?
  deinit {
    print("Pet removed!")
  }
}
// 3
var pet: Pet? = Pet()
pet?.name = "Snowfy"
// 4
let petOwner = PetOwner()
petOwner.name = "Ray"
petOwner.pet = pet
pet?.owner = petOwner
class PetOwner {
  var name: String?
  weak var pet: Pet?
  deinit {
    print("Petowner removed!")
  }
}
DispatchQueue.main.asyncAfter(deadline: .now()) {[weak self] in
  self?.doSomeUIUpdates()
}

Key points

  • Breakpoints help you debug code line by line.
  • Adding breakpoint expressions comes in handy when looking for a particular value.
  • Use Xcode’s Memory graph to find retain cycles and leaks in your code.
  • Call stack shows you all the methods in the memory stack. You can navigate to the initial method using the stack.
  • Use Instruments to profile your apps. Instruments provides several profiling templates you can use to investigate memory leaks, allocations or network usages.
  • Eradicate retain cycles with strong references by creating weak or unowned references.

Where to go from here?

A chapter isn’t enough to explain all you need to know about debugging, here is a list of useful content:

Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.

© 2022 Razeware LLC

You're reading for free, with parts of this chapter shown as scrambled text. Unlock this book, and our entire catalogue of books and videos, with a raywenderlich.com Professional subscription.

Unlock Now

To highlight or take notes, you’ll need to own this book in a subscription or purchased by itself.