In a previous post, we talked about what it means to have “high quality code” and why that matters to our clients’ businesses. Focusing on high-quality code in the app development process creates long-term time and budget savings and a better, more sustainable product. Our dedication to developing and designing high-quality apps sets us apart from our competitors, and we have some principles and specific practices that we adhere to in order to ensure our code truly is high quality.

Full Transparency

We use Git and GitHub throughout every project so that everyone on the team can see what is being written, what changes are being made and who is making those changes. This helps us to keep each other sharp, and to make sure we have many sets of eyes on what’s being written on the project. We believe in the benefits of this GitHub flow, and have even written about it a few times.

Peer Review

Pull requests, or “PRs”, are a standard part of our development process. What this means is that no one adds code without a review from a teammate. Once a peer review has happened and feedback has been given, the code then must be approved by multiple people before it can be merged into the “master branch,” or main body of the code. Our use of the GitHub flow model ensures that our developers are free to try new ideas and experiment with the code in a safe environment, without breaking the main codebase.

Shared Accountability

Both writer and reviewer are responsible for the quality of the code, which helps avoid the natural personal bias and ensure everyone is held to a high standard. Writer and reviewer often pair—that is, meet in person or via Google Hangouts—to talk through feedback. This way, when the code in question is finally merged into the master branch, everyone involved in the writing and review process shares accountability.

Testing

Science y’all. As part of development, we write tests along the way that check that the code we are writing does exactly what it is supposed to do. If our code passes the test, it’s able to move forward. This is part of test-driven development, in which a computer can check thousands of lines of code for errors much faster than a programmer. As we create increasingly complex codebases, this allows us to ensure that the code quality stays high without dedicating hundreds of hours to review.

These tests become a permanent part of the codebase so they can continue to ensure that future work does not break parts of the code. Without tests, we would have to rely on constant, manual quality assurance testing. At Big Nerd Ranch, we don’t ship code if tests are failing because we hold to our principles—to save you time and money in the long run.

A Few Notes on Testing

We won’t go too far into this subject here since it is extensive enough to be its own blog post series, but there are a few types of testing we employ.

• Unit tests: These test smaller, more targeted bits of the code.
• Integration tests: These test the interactions between pieces.
• Testing of the UI: This is a mix of automated and manual testing, depending on what makes sense.

A note on test coverage—we don’t aim for 100% coverage. We target the most complex areas of the app with unit tests, and test the UI either manually or with automated tests. This helps us ensure that we’re spending our time (and your budget) effectively.

Documentation

When our developers work on projects, documentation is vital. We always include a README in each codebase, which is an introduction and roadmap that exists within GitHub and helps developers get up-to-speed with the project.

In addition, inline comments are used whenever there is something that we think may cause confusion later down the road. Think of these as akin to notes in page margins—they allow other developers to understand what a piece of code is used for or why it is placed in a certain section. This is useful not only for our own developers as they transition on and off of projects, but also for your developers as they take over the code once the project is complete.

Refactoring

In my last post, we talked about technical debt, which is the pile of inconsistencies that accumulate between existing code and newer code as changes are made to the app. Ideally, we allow a little time in every sprint to address the natural amount of technical debt that builds up as we go. This idea of refactoring along the way is important—it ensures that our code is not bogged down with issues and works efficiently, which prevents backtracking and maintains a more solid codebase at any given time.

Why The Fuss?

All this seems like a lot of extra work, and it is. But the fact of the matter is that we care a lot about our clients’ bottom lines and solving their business challenges. It’s part of who we are and our shared company values of being hardworking, brilliant and kind.

All of the practices mentioned above help us produce code of the highest quality, which helps you meet your current business needs and prepare for the future as the technology—and your codebase—continues to change.

The post How We Make Sure Our Code Meets Our High Standards appeared first on Big Nerd Ranch.

When we work with our app development clients, we find that they often want to get to a solution as quickly and cost-effectively as possible. And we want the same thing—but not by letting the quality of our work slip.

Sometimes clients ask us why they should spend the time and budget for that higher-quality code. Isn’t “good enough” really good enough? We don’t think so.

We want to ensure that we develop incredibly high quality code that delivers long-term value for our clients. And spending the time and money up front to ensure high quality saves time and money many times over in the long run.

In this post, we’ll take a look at what high-quality code is and why having it in your product matters—to you, to your app and to your business.

What Does “High-Quality Code” Mean?

Having “high-quality code” sounds like a good thing, but it is an ambiguous phrase. To explain why this matters to your pocket and your product, we need to first define what we’re talking about here. When we say “high-quality code” at Big Nerd Ranch, we mean a few things.

High-Quality Code is Easy to Read by Other Developers

Your product is built using code, and we know that when we finish our work that it will need to be handed off to other developers for maintenance and continued development. That means that others will need to be able to easily pick up where we left off.

Because of this, we work hard to write code in a way that meets the goals and requirements of the product as simply and elegantly as possible. As we write our code, we document it with embedded comments so that other developers who read it in the future can understand what we wrote and why.

High-Quality Code is Built for Scalability

Even after we complete our work together, it’s pretty likely that you’ll want to build upon your product in the future. Maybe you’ll need to support an expanding user base, or to add new features. We understand this and always assume that your app will need to continue to grow and change.

As a result, we write the code for your app in a way that ensures the structure is sound. Your app will be built and organized in a way that allows it to scale. You need a solid frame to build on into the future, not a house of cards that will eventually collapse.

High-Quality Code Manages Technical Debt

You may want new features along the way that weren’t anticipated. Problems we thought we would solve one way may need a different solution than originally planned for. This kind of learning and pivoting toward the best approach is not only inevitable, it’s vital.

That said, a natural result of this process is the accumulation of what is called “technical debt.” Put simply, it is the pile of inconsistencies that accumulate between existing code and newer code that’s been written as changes are made to the app.

And it’s called debt for a reason: it has to be paid at some point. The longer you wait, the more it costs to resolve—often much more, in both time and money.

There are times where you have to make some trade-offs about how quickly technical debt is addressed, but you should be cautious about putting it off. Think of technical debt as sludge: the higher it piles up around the code, the longer it will take you to make updates and add new features later. An important part of building high-quality code means resolving technical debt often, in order to keep building on top of your codebase foundation as fast and easy as possible.

But Is It Really Necessary?

So if an app works, isn’t high-quality code just developer preference and unnecessary polish? The answer is no—it actually matters to your product and business:

• You save on time, money, and effort in the end. Caring about code quality now saves you money over the life of your app; rather than investing large chunks of time backtracking to fix things, you spend a little time along the way.
• You have a product that is easier to expand upon down the road because we built a solid foundation.
• When we finish our part in your product, any developers that work on it next can pick up where we left off, with minimal effort.
• You have a product that is healthier and you spend less time and money thrashing with untraceable bugs or figuring out how to make updates.
• You have fewer mistakes or errors in your codebase, because code written had multiple sets of eyes on it before ever becoming part of your product.

What’s the Short of It?

The tl;dr here is that having high-quality code in your app actually saves time and budget in the long term and gets you an overall better, more sustainable product.

Sure, it takes more time than cranking out something that “just works”—but that’s usually the case with quality products. Together, we can work with you to make smart decisions to meet your business needs and to ensure we build you a sound, healthy product ready to grow into the future.

The post Why ‘Good Enough’ Isn’t Good Enough for Our Clients appeared first on Big Nerd Ranch.

Custom app development can get complicated, fast. Business needs and use cases must be taken into account, and technologies change rapidly. When projects enter stormy seas, they can often be steered back to safety, but not without costing time and money. The first step to preventing these challenges is awareness, so today I’m outlining five common trends that can sink your app development project.

Not Being Prepared to Set Sail

Before we start development on your app with you, we’ll first help you identify a list of prerequisites. Do you have pre-existing designs for your app? Grab ‘em. Is there a specific API that will need to be used? Send over the documentation. Is every team member on your company’s side available to start?

With this information in hand before kickoff, we avoid stalls and costly guesses around important information. So make sure you take the time to collect and provide the necessary info and resources for your team before weighing anchor.

Expecting the Ship to Sail Itself

A ship, and your app development project, will not guide itself. We’re experts in app development and design, but in order to deliver the best app possible, we need your input as an expert on your business.

We work with our clients very closely throughout the entire development process, ensuring that the app we’re building supports the business’ and users’ needs. In order to be successful, you’ll need to give your project dedicated attention and focus, providing not only a high-level vision at the start of your project, but also your sustained direction and input as we work to develop your app together. Often this means weekly and daily interaction. If you won’t be able to dedicate this level of time and focus, it is vitally important that you dedicate someone on your team who does have time, and that you empower that person to make decisions.

Not Trusting Your Crew

As in any project, you need to trust the people working on it, especially when there are so many moving parts. We want you to feel confident in us: our processes, the quality of our work, and the project’s progress. By investing the time needed for communication with your Big Nerd Ranch team, asking questions and engaging in setting expectations on both sides, your project will move forward more steadily. We’ll understand what you need from us, and you’ll be able to rest easy knowing that we can maintain our course and momentum.

Prescribing Without Describing

Big Nerd Ranch hires amazingly brilliant, talented people, so you’re guaranteed to have a team of experts to consult with on your app’s development. Don’t squander your team’s expertise and skill by prescribing what you believe is a solution to your problem, and asking them to implement it. Instead, describe your problem to us (whether it’s a business need, or a technical issue) and let us help you come up with the best solution. That’s what we’re great at, and what you’re paying us to do!

Not having a “North Star”

You need to have a clear and guiding business model and use cases. The number one thing that sinks app development projects is when the product owner (that’s you or your dedicated person—see my second point) doesn’t have an intimate understanding of the need your app will meet, or who your users are.

A thorough understanding of how your app will be used serves as a North Star that we’ll refer to as decisions come up during development, in order to make sure we are spending time and effort wisely.

Anchors Aweigh

By avoiding these common pitfalls, you’ll be well on your way to smooth voyage and a successfully developed app. Want to learn more? Check out how we’ve helped our clients meet their business needs.

The post Five Common Challenges That Will Sink Your App Development Project appeared first on Big Nerd Ranch.