iOS Masterclass: Build An iOS AppStore-Quality App In Swift
- Descrição
- Currículo
- FAQ
- Revisões
→ Become An iOS Professional With Swift In One Course
Create a new Swift iOS Xcode project and mould it into an AppStore-quality iOS app! Our ‘123 Calc’ iOS app is available on AppStore now. Just search for ‘123 Calc’ and download it to see what you’ll B building with iOSBFree – an easy way to an iOS Swift Career building professional Xcode apps.
→ LEARN FROM ONE OF THE 1st iOS DEVELOPERS IN THE WORLD
Our instructor Matt, has 13 years of iOS experience and created the world’s first iPhone, iPad and Apple Watch apps. Now, he dedicates his time to recording iOS & Swift courses for iOSBFree (pronounced “iOS Be Free”).
→ In This iOS Swift Course
1. We introduce the concept of structuring your iOS Swift Xcode project to a professional level. Our Xcode project will adhere to an industry-grade standard (You wont find this anywhere else on Udemy!)
2. We teach how (and why) to layer your project into separate layers, known as layered architecture and is a mandatory coding practice for any iOS development job role.
3. We teach ‘The 6 Coding Principles’ used within the iOS industry, which any serious iOS developer MUST LEARN.
4. Build an iOS Swift AppStore-quality app (iPhone app).
5. Taught by one of the most experienced iOS developers in the world.
→ iOS Swift Learning Objectives
✔️ Structure Xcode project files (e.g. classes & structs) to an iOS industry-level standard
✔️ Organise the Xcode project to an iOS industry-level standard
✔️ Structure iOS code using layered architecture (a MUST in the industry)
✔️ Create an iOS app in Swift within Xcode
✔️ Create an iOS AppStore-quality mobile app (ours is available on the AppStore now)
✔️ To separate behaviours into independent .Swift files (e.g. classes & structs)
✔️ Learn ‘The 6 Coding Principles’ every iOS developer MUST understand to reach the top of their iOS career
✔️ Learn to think as an iOS engineer and not just a coder!
→ What Is An iOS Industry Standard?
An iOS industry-standard means writing Swift code and structuring your iOS files to the same level of quality as the professionals who work within the iOS industry. If you are serious about working within the iOS industry or want to enhance your mobile app career then you need to work to a high standard and learn from the professionals.
→ Xcode Sample Code (.swift files, .xcodeproj files, images too)
Xcode sample code is always included and attached to each video. We provide 2 Xcode projects. One for the beginning of the video and another for the end to include all the changes we have made. We also supply the finished AppStore-ready Xcode project at the beginning of the course.
→ This iOS & Swift Course Is Paid
This iOS & Swift course is paid for and helps us create more FREE content for our iOS students. We also supply FREE iOS career-building Career Guides on our website. FREE editable CV Templates used to earn 6 figures. FREE online iOS articles discussing the iOS industry and FREE online Swift courses providing unparalleled foundational knowledge you wont find anywhere else. By purchasing this iOS & Swift masterclass course you are helping others learn iOS too.
❤️❤️❤️❤️
Thank you so much for your support.
→ Our Service (iOSBFree Ltd) To Mobile App Developers
We are a unique iOS career-building service sharing over 14 years of successful experience shaping the mobile-app and iOS industry into what it is today. Our unique information, point-of-view and service can be utilised to build highly successful and profitable careers in iOS.
→ A Career In iOS Building Mobile Apps
iOS developers are the most sought after developers in the world! They can earn over £100,000 per year, work remotely and B in high demand for their mobile app skills! Subscribe to our YouTube channel and let us reveal all of our insider secrets completely for free.
→ What We Teach (Mobile iOS Apps, Swift, Xcode)
Career building, CV writing, interviewing skills, iOS industry secrets, iOS industry stories, real-life experience, iOS fundamentals, ARC memory management, Swift, Xcode & iOS architecture and best engineering practices.
Please show your support by enrolling in our course!
→ The Instructor
Check out our Instructor profile (just briefly) and glance over Matt’s incredible unparalleled iOS experience. After 14 years of specialising in iOS (and only iOS), he created a company helping people build their own successful and profitable careers in iOS too.
Our unique information cannot be found anywhere else on any platform. We teach code, syntax and architecture but also provide tried & tested strategies to BOOST your iOS mobile app career forwards and build a better future!
→ Want To Learn More iOS Topics?
Please send us an email with the mobile app related topic you’d like to learn and we’ll happily record, edit and publish it for you. Absolutely for free. Simply email community@iOSBFree.com with the subject heading, “iOS Topic I Want To Learn”.
→ First In The World
Not only is our instructor one of the first iOS developers in the world, but our service is also the first of its kind in the world!
iOSBFree is a truly unique one-of-a-kind service. There is no single other service offering Matt’s level of experience in any other coding course, software engineering tutorial, or career-building service anywhere in the world.
↓ More From iOSBFree
① Download Our FREE CV Template
② Download Our Career BOOSTER Pack
③ Enrol In FREE Online Courses (iOS & Swift)
④ Read Our Blog
⑤ Visit our website → iOSBFree dot com
❤️❤️❤️❤️
Much love.
The iOSBFree team.
Build a profitable iOS mobile app career with iOSBFree!
Let’s build some great swift apps together using Xcode, Swift, SwiftUI, Apple watch, UIKit, iPad, TVos, macos and all of the amazing Apple frameworks that are available.
Search Terms And Tags
iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone, iOS, Swift, Xcode, iOS, iPhone
-
1Watch Me!Vídeo Aula
Please watch me! In this video we outline what this course is all about. We showcase the app we'll be building together, its features and what happened when it was submitted to the App Store.
-
2The Project We'll B Building (A Sneak Peek)Vídeo Aula
We open the Xcode project and reveal the structure we'll be creating. We also show The 6 Coding Principles that are used in the iOS industry and in our project.
We have a .txt file specially created for each coding principle and they're all attached to each Xcode project (each and every project) x.
-
3The 6 Coding Principles - ExplainedVídeo Aula
We explain the core set of coding principles that are used and taught throughout this course. Each coding principle has been assigned a text document within the final Xcode project. We summarise each document in this video.
-
4Principle 1: Layered ArchitectureVídeo Aula
We discuss the coding principle: Having a layered architecture.
-
5Principle 2: KISS (Keep It Simple, Stupid)Vídeo Aula
We discuss the coding principle: KISS - Keep It Simple Stupid.
-
6Principle 3: DRY Code (Don't Repeat Yourself)Vídeo Aula
We discuss the coding principle: DRY - Don't Repeat Yourself.
-
7Principle 4: WET Code (Write Everything Twice)Vídeo Aula
We discuss the coding principle: WET - Write Everything Twice.
-
8Principle 5: Single Responsibility (For Each File)Vídeo Aula
We discuss the coding principle: Single Responsibility.
-
9Principle 6: Unit Testing (Test The Main API)Vídeo Aula
We discuss the coding principle: Unit Testing.
-
10The Calculator App - A Demo (How Beautiful)Vídeo Aula
We showcase the app we will be building in Xcode 13. We demonstrate the features such as the color themes (a feature only possible because we used architecture), saving to disk, principles like KISS, how to enforce Single Responsibility and more.
This is a course demonstrating how to create a professional-quality project that could be used as a coding test for a potential employer. We use industry-standard architecture and separation within our demonstration project to not only build an AppStore-quality product but to create it professionally using usual commercial level techniques.
-
11A Preview Of: Our Finished Xcode ProjectVídeo Aula
An over view of the Xcode project. We'll discuss the layout the files are stored and provide an overall summary for how things are pieced together.
-
12Take A Look Inside: How The UI Is ConnectedVídeo Aula
Download the attached Xcode project and follow this tutorial where we show how the UI communicates to the calculator engine (the brain of our app).
-
13Coding Principle: DRY Being UsedVídeo Aula
We refactor the code written in the last video demonstrating how we adopt the DRY coding principles to reduce code duplication.
-
14Copy & Paste Explained (Well, Paste anyway)Vídeo Aula
We demonstrate how the paste feature from the copy & paste menu has been created by following a brief tutorial on how it has been connected to the UI.
-
15Displaying The History Log ScreenVídeo Aula
We follow a brief tutorial and connect the calculators history log to the LogViewController. Once connected we will be able to view a list of equations performed by the calculator.
-
16User Experience: Adding Welcome AnimationsVídeo Aula
Together we add some basic animations to the initial experience of opening the app. If the calculator load a saved result for a previous equation then we present the LCD screen sliding in from the bottom of its container view. Otherwise the LCD screen simply fades into view.
-
17Explanation Of: Color ThemesVídeo Aula
We explain how the color theme feature has been implemented within the finished project. Once we've watched this video we will have a better understanding of how this solution has been written with the Xcode project.
-
18Explanation Of: The Layered ArchitectureVídeo Aula
We explain how the layered architecture has been implemented and how it is useful for future growth within the finished project. Once we've watched this video we will have a better understanding of how this solution has been written with the Xcode project.
-
19Explanation Of: The Calculator EngineVídeo Aula
We explain how the actual calculator (i.e. all the math stuff) has been implemented within the finished project. Once we've watched this video we will have a better understanding of how this solution has been written with the Xcode project.
-
20Explanation Of: The History Log ScreenVídeo Aula
We explain how the log screen (equation history) has been implemented within the finished project. Once we've watched this video we will have a better understanding of how this solution has been written with the Xcode project.
-
21Creating A New Xcode ProjectVídeo Aula
We create a new Xcode project to start our Calculator iOS app and setup the project ready to start editing the UI.
-
22Positioning Buttons Inside A Stack ViewVídeo Aula
In this video we will start to create the layout of the calculator. Each button will be placed and organised using a stack view inside the main storyboard. The stack views are a very special component because they can save a lot of coding time simply by embedding views and editing stack attributes rather than writing code to layout each button individually.
-
23Adding An LCD DisplayVídeo Aula
We spend some more time within the main storyboard file to add two views (UILabel and UIView) representing the LCD screen where we display the calculator input and result. We use UIConstraints as a layout system to manage the layout and position each view in the desired location.
-
24An Extra Large Zero ButtonVídeo Aula
We amend the layout of the zero button on the pin pad as it is almost twice the width of the other buttons. We use the UIConstraint system and change the aspect ratio of the button to accomplish this.
-
25.PDF Image ButtonsVídeo Aula
We add a .pdf document containing vector based graphics for our round calculator buttons. A vector based system uses points within a grid system rather than individual colored pixels and so it can be used at any size on any device. We absolutely recommend using .pdf vector based images where possible - it is the future!
-
26Creating A Color PaletteVídeo Aula
In this video we alter the colors of the UI (User Interface) by writing some code and we setup the infrastructure to apply a set color palette from a saved set of colors.
-
27Architecture That Will Become Color ThemesVídeo Aula
In this video we continue to grow the newly added color palette code, which has allowed us to divide the UI (User Interface) and how it is colored into separate areas. Due to this architectural decision we now have the ability to color the calculator display dependant upon a color palette file that can be set by a designer.
-
28Let's Tidy The UI (User Interface) A LittleVídeo Aula
We tidy the UI (User Interface) logic that we have just created. It is always good practice to iterate over our code looking for areas to improve or enhance in someway. Usually we focus on readability to ensure the easy maintenance of the codebase and help out other colleagues who may have to edit the code also.
-
29The Math Equation StructVídeo Aula
We create a new struct named MathEquation, which will serve to store the data for each math equation entered into our calculator app.
-
30Connecting IBActionsVídeo Aula
We connect the buttons of our calculator to functions in code. When ever a button is pressed by the user its associated function will also be called. This will allow use to move slowly away from the UI (User Interface) and direct our efforts more into the actual code for the calculator brain itself.
-
31Let's Build A Calculator Engine!Vídeo Aula
We create a new struct named CalculatorEngine. This struct will serve as the API (Application Programming Interface) between the UI and the calculator logic. In other words, the CalculatorEngine will become the type that is called by the UIViewController in order to trigger and control each feature of the calculator.
-
32Clear ButtonVídeo Aula
We implement the code for the clear button. When pressed the calculator logic will reset creating a brand new math equation and allow the user to start again with their input.
-
33Negate ButtonVídeo Aula
In this video we implement the logic for the negate button. When pressed the value entered by the user will be negated, which means that it will be multiplied by negative one (-1).
-
34Percentage ButtonVídeo Aula
In this video we implement the logic for the percentage button. When pressed we divide the entered value by one hundred. This feature allows the user to enter a whole number between 1 - 100 and view the decimal representation of that percentage. i.e. 50 would be represented by 0.5.
-
35Print Something In The Debug AreaVídeo Aula
We add a printout to the development console each time an equation is executed. This serves as a development tool to view the values of the equation in an area other than the calculators LCD display screen.
-
36Recording All EquationsVídeo Aula
As the user enters and executes each equation we add them to an array. This array will then serve as a log of history for each equation that has been entered and can be displayed in the future inside a UITableViewController.
-
37The MathInputControllerVídeo Aula
In this video we add some more layers of architecture to the calculator system. This extra layer of abstraction serves to separate our concerns and ensure that each type exists for solely one purpose or main task.
The Input Controller will exist to read and interpret each input from the user. This input will then be used to update the LCD display and set the values for the math equation.
-
38Pin PadVídeo Aula
In this video we implement the code to handle the numeric input from the user when they press each number on the pin pad.
-
39Formatting Our LCD DisplayVídeo Aula
In this video we refactor the method used to format the values displayed within the LCD display. All areas that apply formatting are centralised into one function allowing only one area of code to be in charge of generating values ready to be displayed to the user.
-
40Decimal ButtonVídeo Aula
In this video we implement the code for the decimal button. When pressed, the newly added Input Controller will change state for entering decimal values and will also reveal the positive decision we made in introducing it to our calculator architecture.
-
41BugsVídeo Aula
Now that we have evolved the behaviour and feature-set of our calculator the negate button logic has become a little out of sync. We have now introduced our first bug and must refactor the negate button in order to resolve it and bring the code into alignment with our new functionality.
-
42ValidationVídeo Aula
In this video we add some validation to our calculator system securing both the behaviour and also its use by developers when interacting with our exposed API (Application Programming Interface).
-
43Tidy The Project A LittleVídeo Aula
As code grows and evolves into something different there will always be areas that would benefit from a little more attention. In this video we tidy up some of our logic to improve ongoing maintenance and keep to our coding principles.
-
44Color Theme No.2Vídeo Aula
We add a second color theme to the CalcViewController proving that our architecture can easily support a variety of different themes.
-
45Color ThemesVídeo Aula
In this video we write the code to support separating each color theme into a different file that can be shared with designers or other members of the team who could set the color values independently of the development team.
The resources folder attached to this video contains 10 different color theme files which will be added to the project. Please download them to follow alongside the video add them to your own project also.
-
46Status Bar StylesVídeo Aula
We add a status bar style to our color theme system so that each theme can display either a light or dark styled status bar.
-
47Making The UI A Little BetterVídeo Aula
In this video we update the main storyboard tweaking a few values to polish the look of our UI (User Interface). We increase the padding between stack views, change the font size and amend the button title insets to bring the app a little closer to look like the finished product - an amazingly well designed calculator app!
-
48Theme ManagerVídeo Aula
We introduce a new class to take the responsibility of managing the color theme feature. This ThemeManager class will load in each theme and manage the currently selected theme.
As this feature evolves all of the color theme related code will be implemented only within this file - supporting the 'Separation Of Concerns' coding principle.
-
49Tap Gestures!Vídeo Aula
We add a double tap gesture recogniser to the LCD display screen allowing the user to interact with our newly added color theme system. Our goal is to display a different color theme each time the user double-taps the display.
-
50Storing Data To Disk: UserDefaultsVídeo Aula
We add some code to set the index of the current color theme to disk within Apples UserDefaults system. The UserDefaults exist and have been made available for this very purpose i.e. to store and revive the preferences set by the user.
-
51Data Storage Manager (A Wrapper For UserDefaults)Vídeo Aula
We create a datastore manager to add an extra layer of abstraction and prevent the Theme Manager from knowing exactly how the data is stored.
-
52Storing Custom DataVídeo Aula
Now that we have implemented the infrastructure for storing data to disk and saving the users preferences for their desired color theme we enhance the system by saving the whole color theme to disk itself.
We convert the color theme data into a JSON format and then save it to disk within the DataStoreManager.
-
53Color Theme ID (Identifier)Vídeo Aula
Now that we have successfully implemented the data storage to store and revive each color theme to disk we complete the system by removing the theme index and replacing it with the actual identifier for each theme.
-
54UIButton StatesVídeo Aula
We add a nice little feature by highlighting each operation button that was selected by the user.
E.g when the user presses the multiply button it will remain highlighted providing feedback to the user of the operation that is about to occur in their equation.
-
55Becoming First ResponderVídeo Aula
We add a new file to our project which will replace the class type for a UIView within the main storyboard. We subclass UIView to gain access to the exposed methods required to present a copy & paste menu (known as the UIMenuController) such as becoming a first responder.
But for this video we solely focus on creating a new subclass and implementing the basic infrastructure.
-
56Long Press Gesture RecogniserVídeo Aula
In order to trigger the display of the UIMenuController we first add a long press gesture recogniser as our type of interaction with the user. After touching down upon the main display and pausing for a moment the menu will preset itself. In this video we will create and setup the UILongPressGestureRecogniser.
-
57Show The Menu (UIMenuController)Vídeo Aula
In this video we try to understand the qwerks of subclassing a UIView, how to register different types of actions (such as copy & paste) and how to become whats known as the first responder. Toward the end of the video we will have successfully presented the menu (UIViewController) with both options to copy & paste.
-
58Copy & PasteVídeo Aula
We write the code to perform the copy & paste operations within the LCDDisplay view and successfully copy the value displayed by the calculator as well as pasting in a new value into a new equation.
-
59Posting NotificationsVídeo Aula
We post a notification from the LCDDisplay view which will be recieved by the CalcViewController and from that point we filter our communication down through each level of layered architecture until we reach our MathInputController which will handle the insertion of the new pasted value.
-
60Hiding The Menu (UIMenuController)Vídeo Aula
To enhance the UX (User Experience) we make a call to hide the menu (UIMenuController) in a certain scenario. When the user is presented with the UIMenuController and selects to view the next color theme we write some code to hide the menu so that the app feels more polished.
-
61Constructing Button Animation InfrastructureVídeo Aula
To start animating each button we make a call to a method held within a new UIButton extension. This method will allow us to easily experiment with new animations ideas.
-
62UIView Animation Blocks ExplainedVídeo Aula
We write a UIView animation block explaining the easiest form of animation for UIViews and all related subviews. This is the fastest form of animation and allows us to create basic but amazing animations in a very short amount of time.
-
63Using Weak ReferencesVídeo Aula
When referencing objects within a closure (which is what happens inside an animation block) we must think about the memory management system. We have 3 options to reference objects, however, we only focus on weak references within this video which won't prevent objects from being released from memory just because we wanted to apply various animations.
-
64A 'Polished' Button AnimationVídeo Aula
In this video, we write the code to implement the animated behaviour that will be submitted to the AppStore for this calculator app.
-
65Highlighting The LCD DisplayVídeo Aula
To enhance the UX (user experience) of the copy & paste feature we will highlight the LCD display by animating a color change from the clear color to the operation button color. This will add further feedback that the user has entered a different 'state' or 'mode' when they perform a long-press gesture.
-
66Unhighlighting The LCD DisplayVídeo Aula
We tackle the complexities that arise from adding some extra animations. As with any project, several code paths will exist when adding extra features and they must all be addressed when working in a professional setting. Even though it may be difficult and (dare we say) annoying to add complexity, the user experience must be preserved in every scenario.
-
67Custom UIMenuController ItemsVídeo Aula
The UIMenuController that is presented when the user performs a long press gesture on the LCD display can also include custom menu options. We utilise this feature to add our own menu item ready to present the history log screen.
-
68Presenting The LogViewControllerVídeo Aula
We create the infrastructure and new classes required to present a new screen - the LogViewController. This new screen will then become our blank canvas to display a list of each equation that was executed by the calculator.
-
69Connecting A DatasourceVídeo Aula
We connect the data source within our newly created LogViewController to the calculator engine.
-
70Populating CellsVídeo Aula
We add 3 UILabels to our new UITableViewCell subclass so that we can display the three main properties of each equation - the left-hand side, the operator combined with the right-hand side and the result.
-
71UINavigationControllersVídeo Aula
Instead of presenting the LogViewController directly, we present a UINavigationController which encapsulates a LogViewController. This is widely accepted as a best practice due to a new set of navigation being created and also we want to take advantage of having a navigation bar with a system done button displayed.
-
72Cell SelectionVídeo Aula
It is always better to use an existing system than to reinvent the wheel simply because we have added a new feature. We hijack and use the existing paste system in order to restore the result displayed within the selected UITableViewCell pressed by the user. A clever example of code reuse and reducing unnecessary complexity. i.e. the KISS coding principle.
-
73Color ThemesVídeo Aula
We decorate the history log screen with the selected color theme which brings our new feature to life and certainly makes it more fun to use.
-
74Tick AnimationVídeo Aula
The UX (user experience) feels confusing when restoring the result of a previous equation. This is mainly due to the rapid speed at which the selection is made. We add a beautiful tick animation combined with a delay to slow things down.
-
75Our FREE Bundle PackVídeo Aula
Please download our FREE Bundle Pack which is attached to this course. We have FREE Career Guides, CV Templates and even downloadable iOSBFree desktop backgrounds! We love our little characters and they love you too - why not take a look now?
Also, we are adding new content to our FREE Bundle Pack every month so don't forget to take another look as the weeks go by.
Much love
From the iOSBFree team
xxxX -
76Continuous Equations (One After The Other)Vídeo Aula
Previously, we only created enough code to allow for one equation. Then the user would have to press the reset button to enter a second equation. In this video we add the code to continuously enter equations one after the other.
It is at this point in the course that we can truly understand and experience the large benefits of focussing on building fantastic architecture before adding lots of different features. By waiting, we keep our code tidy, easy to maintain and can add huge amounts of features at an extraordinary speed!
-
77Pressing 'Add' After Executing An EquationVídeo Aula
New Feature: We add a new feature by applying calculations to the result of an equation. When a user presses the add operation button we will create a new equation populating the left-hand side with the previous result, populating the add operation and allowing the user to enter the right-hand side value.
-
78Coding Principle: Layered ArchitectureVídeo Aula
A very important video where we enforce the Coding Principle: Layered Architecture. As our calculator engine is separated into 3 layers (CalculatorEngine, MathInputController and MathEquation) we must ensure that 1. We communicate passing information between layers and 2. Each layer has a clear responsibility for the tasks it is allowed to execute.
It can be very easy to untidy and dirty a very good and well-built structure, which is why this video is so important. We must always try to maintain our architecture when ever we make changes and introduce new features. This is a very important point if we want to nurture a successful and profitable career in the iOS industry.
-
79Coding Principle: Single ResponsibilityVídeo Aula
Having moved forwards with a new feature we can see that all of the manipulation of the math equation (MathEquation type) is no longer confined to the input controller (MathInputController type). This means that we have broken our Single Responsibility Coding Principle and our responsibilities are now mixed (incorrectly). We refactor the code and ensure such behaviour only occurs in one file and one type.
-
80Pressing Any Operation Button After Executing An EquationVídeo Aula
We apply our newly added feature to all the operation buttons. After adding the content explained in this video the user will be able to add, subtract, multiply and divide from the displayed result of a previous equation.
-
81Executing An Equation By Pressing An Operation ButtonVídeo Aula
New Feature: We introduce a new feature allowing the user to execute an equation without pressing the equals button. Instead, each user can simply press any operation button i.e. 3 * 3 * which would execute 3 multiplied by 3.
-
82Repeatedly Pressing EqualsVídeo Aula
New Feature: We introduce a new feature allowing the user to continuously press the equals button. Each time it is pressed the previous manipulation will be repeated, which is essentially the operation together with the right hand side. E.g. If the successfully executed equation displayed was 3 * 3 (= 6) and the user continued to press the equals button the following equation would multiply 3 to the result, leaving 6 * 3 for the next equation.
-
83Extra Function Buttons From ResultVídeo Aula
New Feature: We implement the functionality for both the negate and percentage buttons to be pressed after displaying a result of an equation.
-
84Pressing Decimal Button From ResultVídeo Aula
New Feature: We implement the code to press the decimal button and start a new equation after displaying a result of an equation.
-
85Coding Principle: DRYVídeo Aula
As professionals we work beyond the scope of just adding features. We must ensure that the code is readable to others and is suitable for easy maintenance. In this video we look over the code in search for areas with what's known as WET code (Write Everything Twice) that we can encapsulate into a shared area (a function) so that it is not repeated so often - if at all.
This is an important part of the iterative process that takes place within software engineering. First we must figure out 'how' to solve our problems and finally we must create an elegant solution that is ready to be inspected by our peers. This is an important concept to adopt for any developer wanting to BOOST their carer forwards simply by adding good habits to their daily routine.
-
86Coding Principle: DRY Continued...Vídeo Aula
We continue our journey to refactor our latest additions to the codebase with a focus on writing DRY code (Don't Repeat Yourself).
-
87Refactoring Our MathInputControllerVídeo Aula
We look over the MathInputController type searching for any areas missed during development and add some small architectural enhancements to enforce good maintenance and the desired use of our calculator engine.
-
88Pin Pad ValidationVídeo Aula
We add some validation and rename the number input methods so that our calculator engine API (Application Programming Interface) offers as much information to the developers using it as possible. Upon a little reflection we realise that we don't want a number input method but rather a pinpad entry function allowing numbers only available within the 0-9 pinpad.
