You'll be writing lots of code. Some of it from scratch, while some will need to fit into an existing code base. In either case, you'll need to make sure you are producing high quality work!
Specifics of quality code
Often, judgement of software development skills is limited to knowledge of programming languages. And, to typing speed of typing... just kidding! 😜
Knowing programming languages is important, however it's not necessary to know absolutely every trick. Most programming techniques are available to look up on the Internet as a need arises.
In addition to simply solving problems by writing code in a programming language, you must ensure that the code you're producing is of high quality - code that can be easily understood by other developers and seamlessly integrated within an existing code base.
The key characteristics of a good developer are:
an ability to programmatically solve a problem at hand
and an ability to produce quality code while solving that problem.

When a solution to a problem can be found on the Internet, producing quality code is on you! 😎
There are two ways to approach this:
Reactive
and Proactive.
Reactive approach
A reactive approach implies identifying and eliminating bugs. This is when we write lots and lots of code and hope that it works. When we discover that it doesn't, we attempt to fix the issues. In doing so, we often create more issues - which we'll discover later. This process revolves around extensive testing, debugging, and, of course, more coding!
Proactive approach
A proactive approach promotes developing with sustainability in mind, preventing bugs from occurring in the first place.
This is done by creating tests - additional elements that verify the correctness of the production code.
Why do I have to test? Aren’t there Quality Control teams for that?
You've probably heard about the Quality Assurance (QA) or Quality Control (QC) teams. As their names suggest, they are responsible for ensuring the quality of software. Their job is, indeed, to test and identify all the bugs! And, believe me, you'll keep them busy. 😉
Still, as professional developers, we must do everything possible to guarantee that our code works as intended.
Imagine going to a dental clinic to fix your tooth. What if they simply put a filling in your tooth and send you home without asking you to bite to ensure the level is right and let you identify all the issues?!
Let's imagine further, when the freezing's gone and you try to close your mouth, you realize that you can't! It's likely because the level of the filling is too high. So you go back to your dentist again. They shave a layer off and send you home again. You try chewing and realize you can't... because the level of the filling is still too high. 🙄 You go back to your dentist... This time, the original dentist may not be available to take you right away, so you get someone else to fix your problem so that you don't go hungry! You get the idea!
Don't be that dentist! ALWAYS test!
Introducing the project
To learn how to test in this course, we are going to use a variation of a well-known game: Tic-Tac-Toe. That’s the one where we draw Crosses and Zeros on a 3x3 grid. A player who gets three crosses or three zeros in line - wins!
Here's what the initial app looks like:
Game intensions and assumptions:
As the app loads, it presents a brand new game available for 2 players.
The first player is always assigned crosses and the second zeroes.
The header panel marks the next player.
in the beginning of the game, the next turn is always for the first player.
Players may play unlimited number of games.
When a player wins a game, the corresponding score increases.
If the game result is a draw, the game is over with no effect on the score.
Tapping on a square marks it with a cross or a zero depending on whether it's Player 1 or Player 2's turn.
A game can be restarted with no effect on the score.
The app is designed for iPhone portrait orientation.
The game is over when 3 of the same items are marked in one of the rows, one of the columns, or one of the diagonals.
Getting started
We've got an Xcode project available to us as a starting source code to work with. What it is, how good it is, and what we need to do about it, we’ll discover throughout the rest of this course!
Make sure to download the TicTacToe project and get ready for the next chapter!
Let's Recap!
Developers must do their best to ensure the high quality of their code.
The key characteristics of a good developer are:
an ability to programmatically solve a problem at hand
and an ability to produce quality code while solving that problem.

There are two ways to ensure correctness of the code:
Reactive - identifying and eliminating bugs
Proactive - preventing bugs from occurring
This course is based on an application that implements a variation of a well-known game: Tic-Tac-Toe.
