Can you believe that you completed all the theory modules for this course, bearing in mind all the learning you've done to make it here? Let's take some time to recap. You began with an introduction to the course. You were introduced to the basic concepts of mobile user interfaces or UIs, including the differences between non touch and touch interfaces, and some of the guidelines for building them. You then downloaded and installed the Integrated Development Environment, or IDE, used for developing iOS apps, Xcode. You learned that with Xcode, you can create apps for the diverse Apple devices under different operating systems with different languages, UI paradigms such as SwiftUI, databases, and even control specific hardware sensors. This is because it comes equipped with all the tools you'll need to create your apps. When exploring setting up SwiftUI, you discovered that SwiftUI is a modern way to create UIs for apps designed for Apple devices. You learned of the roles SwiftUI has played in unifying the development of iOS apps. Making it possible for developers to create apps for all of Apple's devices in one place. A key takeaway was that SwiftUI makes developing cross-platform apps faster and easier. You also learned about other benefits of SwiftUI, such as the ability to easily create light and dark themes for us. What followed was an exploration of declarative and imperative syntaxes. You discover that the method of writing code for UI elements by specifying what you need as opposed to how you need it, is called declarative syntax and that this method is employed by SwiftUI. You may remember that the SwiftUI declarative syntax has many benefits, ranging from it being easy to learn to being the future for Apple platforms. While it is not without limitations, declarative syntax is fundamental to how SwiftUI makes it possible for developers to define UI elements simply and effectively in a way that translates across all Apple platforms. You then learned about scenes and views, two features that are fundamental to creating the visual parts of UIs and SwiftUI and the differences between them. Views such as text and images are one of the most important elements of an app and many adjustable properties and can be combined and aligned in many ways. Don't forget that they're reusable. Meaning you can use them many times in the same app or even across applications. Towards the end of the first lesson, you learned all about how UI elements benefit from observing variable changes, as well as how to create variables that can be created in views observed and communicate changes. This is important because most apps have views with elements that need to be displayed onscreen and updated at some point. For example, typing in an amount and having a discounted value display. In doing so, you were introduced to text fields, which is an element that allows user input, and text elements, which is an element that displays text. You discovered how they can be used with state variables to receive input, store the results of a calculation performed by function, and update the display with these results. In addition to state, you learned of another property wrapper called binding. Learning how to create another mechanism that reacts to changes within views and updates interface elements automatically. You also learned that you can use an observable object and its companion, the observed object property wrapper. When you want your interface to update or react to changes to values in classes. You then built in the earlier introduction to text elements and text fields by learning how to use both controls practically and the options available to you to customize them. This all prepares you to learn about how to store inputs from text fields into control variables, and how to detect changes to text fields using modifiers such as onchange, on submit, and on editing change. The second module on the foundations of SwiftUI began with an overview of the SwiftUI layout system, including an introduction to frames and the built-in frame modifier, which is used to manipulate views, the layout process, and Stacks. Which are used to combine an embed multiple views and are the primary layout instrument in SwiftUI. In relation to placing objects in views, spacers, padding, and alignment. You then explored Stacks in greater detail. Learning about the different kinds of Stacks and how you can use them to build screens for iOS applications. You should now be familiar with VStacks, HStacks, and ZStacks and the way they present views. Don't forget that you have the option to adjust the alignment for all three kinds of Stacks and spacings for VStacks and HStacks. You also learned the power of combining these Stacks to create complex views efficiently. You then learned how to create views using Stacks combined with text and text field elements, and more about the ways you can apply modifiers to them. Your next lesson was on UI elements. You explored a range of controls, which are visual elements that form the basis of all iOS apps that you'll find useful when creating apps, including buttons, toggles, stapers, sliders, progress view, date picker, and labels, as well as their code. You even practice creating an app using many of these controls. Recall that the great thing about controls is that because they'll be used repeatedly in the apps you develop, they're included in the SwiftUI framework by default and are intuitive, helping you create apps users will love in less time and with less effort. You also examined how to add and adjust different images to your projects. More specifically, regular images such as logos or photos and system images called SF symbols, which refer to the thousands of symbols that come with Xcode by default and can be used freely. The last lesson of the second module introduced you to the view hierarchy. You learned about container views and putting views on other views. How to use stack views to combine views in your user interface about the hierarchical relationship between parent and child views in your code and how these combine views behave when modified as a result of the view hierarchy. You then discovered more about creating views within views so that you can reuse them throughout your application through a practical demonstration that placed a little lemon restaurant logo inside a separate file and then referenced its name in another view to render the logo elsewhere. At the same time, you learned how to pass variables within views. The third lesson covered more advanced SwiftUI concepts. You learned that navigation, which involves presenting screens that must be shown in a certain order or follow a particular logic is integral to creating a successful app. You then explored the different types of navigation in SwiftUI, flat and hierarchical and how they work. Recall that flat navigation is where all the views a user can possibly navigate to derived from the one they are on. Whereas hierarchical navigation only displays one view, which contains multiple navigation options, where the user can navigate through pages, forward, and backwards as desired. You even explored hierarchical navigation in actions. Because flat navigation is done with TabViews and SwiftUI, you were then introduced to the concept of TabViews and tab navigation. You may remember that a TabView is a view that switches between multiple child views using interactive user interface elements. You also learned how to create a TabView with two tabs and create an app that navigates between multiple views. Your next lesson, which is about displaying list data, started with an introduction to ScrollViews and lists, which are containers that present rows or data arranged in a single column or line. Whereas scroll views display elements as they are without much formatting, lists use a specific format. You then learned how to implement a scroll view and list in your code, including how to create a scroll viewer list from elements contained in an array. In the final lesson of Module 3, you discovered more about interactions and gestures in Swift apps. You learned that gestures are elements that can be attached to views to detect user interactions like taps and swipes. You were also introduced to distinct kinds of gestures such as tap, drag, magnification, rotation, and long press. Finally, you learned how to apply three commonly used gestures: the drag gesture, the magnification gesture, and rotation gesture to your views, as well as how to implement a simple app that updates a variable when a gesture is activated. Well done. You've covered many concepts and skills and gained significant knowledge about creating the user interface with SwiftUI. Best of luck as you try out what you've learned and create your own SwiftUI app.
