Introducing Faux Pas

Today I have released the Faux Pas public beta.

A big thanks to the people who tried it out in private beta and provided bug reports and other suggestions!

What

Faux Pas is a tool that inspects your Xcode project, and tries to find common errors: latent bugs, bad practices, or maintainability or style issues.

Why

I created Faux Pas because I wanted something like it, and nothing like it existed.

Existing tools

Apple’s standard toolchain already contains programs that inspect (parts of) your project and warn about many different kinds of issues:

• The Clang compiler contains many useful warnings (yes, I’m aware the documentation I’m linking to says “TODO” at the time of this writing :-) )
• The Clang Static Analyzer can detect many problems related to memory management and use of discouraged APIs
• The Xcode IDE can warn you about a few things, too — for example:
  • Misplaced views in Interface Builder files
  • Incorrect image asset catalog image resolutions
  • “Deprecated” build settings

These tools are all great, but there are valid reasons why many potentially useful warnings fall outside of their purview. Faux Pas, however, doesn’t suffer from the same restrictions:

Faux Pas is holistic

The Clang compiler and the static analyzer only look at your code, and the Xcode IDE only inspects a few other parts of your projects.

Faux Pas inspects all of these things together:

• Code
• Project configuration (e.g. build settings)
• Interface Builder files
• Static assets (e.g. images)
• Version control

This means it can warn you about errors that span the boundaries between these different parts of the project. For example:

• Code tries to load a resource file that doesn’t exist
• Code uses a localization key that is missing for some languages
• Project references a file that is outside of the version control root
• Project is missing an API usage description (e.g. NSContactsUsageDescription) while using that API in the code

Faux Pas is more liberal

Tools in Apple’s standard developer toolchain are used by everyone who writes software for Apple’s platforms. Everyone. This means that these tools cannot be very opinionated, and that they have to be quite conservative in what they warn about.

Faux Pas is a third-party tool, which means it has no such restrictions. This allows for warnings related to “best practices” that many — but not necessarily all — developers agree with. If a developer disagrees with a particular “best practice,” they can easily disable the associated rule in Faux Pas, and only apply the ones that they agree with and find useful. Many rules also contain configuration options for fine-tuning their behavior to match the preferences of different development teams.

Design Principles

These design principles may help you understand what you can expect from this tool:

Does not duplicate warnings in the standard toolchain

Some overlap is fine, but generally if Clang or Xcode can warn about something, Faux Pas shouldn’t warn about the same thing.

Does not require the user to modify their project or code

Faux Pas should be able to check unmodified Xcode projects — the user shouldn’t have to add e.g. special headers or configuration values to their project for it to work.

Having said that, these kinds of modifications may be required for optional features that could otherwise not be implemented (e.g. diagnostics suppression code annotations.)

GUI and CLI are both first-class citizens

All relevant features must be accessible from both the graphical user interface and the command-line interface.

Check it out

We all love maintainable codebases and hate shipping bugs — Faux Pas can help you with these.

If you want details, you can check out the descriptions of the 111 rules it includes.

The app is free to try out for 30 days — try it on your project today!