Changing an app’s architecture is one of the most important things you can do as an iOS developer. This article will talk about some reasons why changing how your apps are organized, structured, and compartmentalized is so crucial, and then give you tips on how to change the structure of an existing project or start a new one from scratch.

Thinking about the reason architecturally changes matter comes down to two concepts — vertical separation and horizontal segregation.

Vertical separation means organizing your code into different folders or packages that each have their own set of functions. For example, if your app requires login functionality, you would probably create a package for accounts and another for users.

Horizontal segregation refers to dividing up features of your application by groupings. If your app has lots of interactive components like buttons and forms, you could put those in one folder, functional logic in another, and mobile-specific UI elements in another.

This article will go more in depth about both vertical separation and horizontal segregation, but first we must discuss what makes an effective organization.

Look at your project structure

A close look at your project folder structures will tell you if there is something wrong with how your app is set up. If you are using the standard templates, then it’s very likely that they don’t match what we recommend for professional development.

Many of these templates use an “Artifacts” directory as their root. This can be confusing because most people refer to this as the “Build” or “Distribution” directory.

This isn’t necessarily bad, but it doesn’t represent our recommendations for architecture either. We suggest replacing the artifacts directory with an “Intermediate Files” directory. These files include things like interface assets and content files (XML documents, JSON data).

By separating out intermediate files from build output, it becomes much easier to manage file versions. You no longer have to worry about whether newer software has compatibility issues with older files.

Also, many developers organize their projects into different folders by domain — maybe users store their settings in one place, while profiles and apps stored in another. By keeping all of these separate, you end up wasting space copying and merging across domains which only adds overhead.

We believe this approach is not good for developing high quality applications. It may work well for smaller projects, but as your project grows more complex, this can add unnecessary overhead.

Try to be consistent

Changing the overall structure of your app is not easy, nor does it happen quickly. It takes time to get into the habit of doing it consistently, which makes it more difficult to do when you have to suddenly change how an app functions or structures itself.

If possible, try to stick to using the default settings for each feature until you feel comfortable changing them. This will help you gain consistency as well as familiarity with the tool!

There are many ways to achieve this, but my favorite way is to use the Settings tab within Xcode’s Source Control panel. This lets you easily revert back to the original state of any element in your source code- including navigation bars, action buttons, and header files.

By adding reset points into your development process, you will eventually reach a stable version that stays the same day after day.

Use the project structure for organization

For those who have spent hours configuring files, working with groups, and creating new documents or layouts, you may be experiencing something different when it comes time to develop your app.

The settings that apps use to store their data and user interface components can make developing and organizing projects very difficult. Different file types, location-based preferences, and organizational structures are mixed together without any clear hierarchy.

Xcode helps mitigate this by giving you the chance to organize your source code into folders using the project structure. By doing so, however, you lose some of the control over how your app is organized.

By understanding the project structure and how to change it, you will once again have access to all of the features that iOS developer tools offer. In this article, we will discuss everything you need to know about changing the architecture of an existing project in Xcode.

Make use of the project hierarchy

In any large-scale development process, one key element is constantly changing – the architecture or structure of your app.

This can happen for many reasons: new features are needed, there’s a need to separate out functionality into different apps, or you want to test and improve upon an existing product.

Whatever the reason may be, one of the first things that get thrown out when designing and developing iOS applications is the project hierarchy.

A project hierarchy refers to the folders within your source code directory where each folder represents one part of your application. For example, if your app has a login screen, a navigation controller, and a dashboard page, then those would be three separate folders in your source code.

The most common way to manage this is by creating these various components inside their own individual folders which then are organized similarly to what we talked about before with git.

For instance, if our previous examples were saved as LoginScreen, NavigationController, and Dashboard, then their respective parent directories could be Desktop (or whatever name you choose), SourceCode, and Other.

Always use the most specific file/folder location

As mentioned before, project files can be very confusing! There are many settings within Xcode that contribute to how your app functions and what kind of structure it has. Changing the setting for one item often changes something else about the app or may even create another app with different features.

That is why it is important to understand the settings inside Xcode well. You will likely come across them frequently as you develop apps.

The first setting we will look at is always use the most specific file or folder location. This applies when two items refer to the same thing. For example, if A refers to B and B refers to A then they cannot both exist because there is no way to differentiate which one you mean.

In this case, only one can exist so Xcode picks the least ambiguous option and removes the other. In other words, it chooses B over A.

Always use the version control system

It is very important to have a good revision control tool set up so that you can keep an eye on what changes are being made to your app at all times.

This way, you will know who changed which files and when, and you can go back later and see what edits were made.

For example, if someone makes a change to a function in a source file and then sends it out for review, they can be sure that their code has been seen before.

Xcodeproject suggests using Git as the most reliable VCS solution. You can check out a free account here: https://www.atlassian.com/software/git/.

Know the differences between the schemes and targets

There are two main things you will be doing when changing an app’s architecture- either moving some resources (like images, files, or apps) outside of the deployment target, or adding a new one.

When choosing which scheme to use for your project, make sure it is using the latest version of iOS that your application needs to run on!

By setting this as the default, Xcode will automatically update the settings if there is ever a change in the operating system level. For example, if you create an iPad app then switch over to iPhone mode, Xcode will switch the default scheme to match.

This can easily be done by going into Project Settings -> General and picking Default Scheme from within the Build Configuration drop down menu.

Know what to do when there is a conflict

As mentioned before, project members have different levels of expertise, which can create conflicts around how to handle certain issues. This happens more frequently as teams get larger, especially with people having separate roles within the organization.

As an architect or team leader, you may find it difficult to convince other individuals that your approach is the best one. It’s important to be aware of this so you don’t take any actions that could hurt the project, but at the same time you need to stick up for what you believe will help the project succeed.

If someone comes to you with objections, ask them why they feel the way they do. Listen to their reasoning, acknowledge their points, and then come up with alternatives. If necessary, repeat these reasons until they seem reasonable to you — remember, you want to win this argument!

But whatever you do, don’t attack individual contributors directly – design is a process that often involves many rounds of feedback and revisions. Even if a person seems like they are trying to prevent you from making changes, let them finish their work and see what effects your changes have before getting into a debate about why theirs were better.