add iOS copy and links (#6059)

src/data/roadmaps/ios/content/architectural-patterns@ajPGMwoaFb1UFWTtpi5kd.md

@@ -1 +1,3 @@
 # Architectural Patterns
+
+iOS development architectural patterns are structured approaches to organizing code for better maintainability, testability, and scalability. Each pattern has its strengths, and the choice often depends on project size, complexity, and team preferences. Understanding these patterns helps developers create more organized, maintainable iOS applications.

src/data/roadmaps/ios/content/async--await-in-swift@3GtrUXvLgvXK3G8cXRb-P.md

@@ -1 +1,7 @@
 # async / await in Swift
+
+Async/await in Swift is a modern concurrency model introduced in Swift 5.5 that simplifies asynchronous programming. It allows developers to write asynchronous code that looks and behaves like synchronous code, improving readability and reducing callback hell. The `async` keyword marks functions that can be suspended and resumed, while `await` is used to call these functions and wait for their completion. This model works with Swift's structured concurrency system, including tasks and actors, to manage complex asynchronous operations more easily.
+
+Learn more from the following resources:
+
+- [@video@Discover async / await in less than 90 seconds](https://www.youtube.com/watch?v=3CPsVAFfXlA)

src/data/roadmaps/ios/content/basic-interfaces@0o3V_zveN1xCIt7rayrCF.md

@@ -1 +1,11 @@
 # Basic Interfaces
+
+UIKit Basic Interfaces refer to the fundamental user interface elements provided by the UIKit framework for creating standard iOS app layouts. These include navigation bars (UINavigationBar) for hierarchical navigation, tab bars (UITabBar) for switching between app sections, toolbars (UIToolbar) for displaying action buttons, and status bars for system information. Basic interfaces also encompass common screen layouts like list views (UITableView), grid layouts (UICollectionView), and scroll views (UIScrollView) for handling content that exceeds screen size. Mastering these basic interfaces ensures developers can create consistent, platform-native app experiences that users find familiar and intuitive, while providing a solid foundation for more complex UI designs.
+
+Learn more from the following resources:
+
+- [@official@UINavigationBar](https://developer.apple.com/documentation/uikit/uinavigationbar)
+- [@official@UITabBar](https://developer.apple.com/documentation/uikit/uitabbar)
+- [@official@UIToolBar](https://developer.apple.com/documentation/uikit/uitoolbar)
+- [@official@UITableView](https://developer.apple.com/documentation/uikit/uitableview)
+- [@official@UICollectionView](https://developer.apple.com/documentation/uikit/uicollectionview)

src/data/roadmaps/ios/content/basics--creating-animations@w0i5Dxp40XS2HnF5nXeZI.md

@@ -1 +1,11 @@
 # Basics / Creating Animations
+
+Creating animations with Core Animation involves manipulating `CALayer` properties over time. Developers can use `CABasicAnimation` for simple property changes, or `CAKeyframeAnimation` for more complex, multi-step animations. Animations are added to layers using the `addAnimation(_:forKey:)` method. Common properties animated include position, bounds, transform, and opacity. Core Animation provides timing functions to control the pace of animations, and allows for grouping multiple animations using `CAAnimationGroup`. For view-level animations, UIView's animate methods serve as a convenient wrapper around Core Animation.
+
+Learn more from the following resources:
+
+- [@official@CALayer Documentation](https://developer.apple.com/documentation/quartzcore/calayer)
+- [@official@CABasicAnimation Documentation]
+- [@official@]CAKeyframeAnimation Documentation](https://developer.apple.com/documentation/quartzcore/cakeyframeanimation)
+(https://developer.apple.com/documentation/quartzcore/cabasicanimation)
+- [@article@What is CALayer?](https://www.hackingwithswift.com/example-code/calayer/what-is-calayer)

src/data/roadmaps/ios/content/components@A1TFKVjGU5RbeTF_zxJlu.md

@@ -1 +1,8 @@
 # Components
+
+UIKit components are the building blocks of iOS user interfaces, offering a wide range of pre-designed elements for creating functional and visually appealing apps. These include basic controls like `UIButton`, `UILabel`, and `UITextField` for user input and display; container views such as `UITableView` and `UICollectionView` for organizing content; `UINavigationController` and `UITabBarController` for app navigation; and `UIAlertController` for displaying alerts and action sheets. UIKit also provides components for more specialized functions, like `UIImageView` for displaying images, `UIScrollView` for scrollable content, and `UIPickerView` for selection interfaces. 
+
+Learn more from the following resources:
+
+- [@article@UIKit Component Styling](https://medium.com/@greenSyntax/uikit-component-styling-in-ios-ae218ae4823e)
+- [@article@Customizable UI Components on iOS Using UIKit](https://pspdfkit.com/blog/2023/customizable-ui-components/)

src/data/roadmaps/ios/content/concurrency-gcd-asyncawait@aALIiAxKz4f7B_EYyhBCi.md

@@ -1 +1,5 @@
 # Concurrency (GCD, async/await)
+
+Concurrency in iOS development refers to executing multiple tasks simultaneously, improving app performance and responsiveness. Grand Central Dispatch (GCD) is a low-level API that manages concurrent operations through queues, while async/await is a modern Swift feature that simplifies asynchronous code. These tools allow developers to perform time-consuming tasks (like network requests or complex calculations) in the background without freezing the UI. By leveraging concurrency, iOS apps can efficiently utilize device resources, handle multiple operations simultaneously, and maintain a smooth user experience even during intensive processing tasks.
+
+iOS specific concurrency is covered later in the roadmap.

src/data/roadmaps/ios/content/core-programming-concepts@mk02yV7_XHkgp2xdNIxaU.md

@@ -1 +1,9 @@
 # Core Programming Concepts
+
+Core programming concepts for iOS development encompass fundamental principles essential for creating efficient and robust applications. These include understanding variables, data types, control structures (like loops and conditionals), functions, and object-oriented programming principles. iOS developers should also be familiar with memory management, error handling, and basic algorithms. 
+
+Learn more from the following resources:
+
+- [@article@Programming Fundamentals](https://www.theknowledgeacademy.com/blog/programming-fundamentals/)
+- [@article@What are the basic fundementals of programming?](https://www.educative.io/answers/what-are-the-basic-fundamental-concepts-of-programming)
+

src/data/roadmaps/ios/content/error-handling@N5ojp6bqgH074MPKYjCHV.md

@@ -1 +1,9 @@
 # Error Handling
+
+Error handling is a crucial programming concept for managing unexpected situations or failures during code execution. It involves anticipating potential issues, detecting when they occur, and responding appropriately. Common techniques include try-catch blocks, throwing and catching exceptions, and using error codes or result objects. Effective error handling improves program robustness, prevents crashes, aids in debugging, and enhances user experience by providing meaningful feedback. It allows developers to gracefully manage issues like invalid inputs, resource unavailability, or network failures, ensuring the program can recover or fail safely when problems arise.
+
+Learn more from the following resources:
+
+- [@article@General Error Handling Rules - Google](https://developers.google.com/tech-writing/error-messages/error-handling)
+- [@article@Error Handling Patterns](https://andreabergia.com/blog/2023/05/error-handling-patterns/)
+- [@video@Error Handling by Timoth Cain](https://www.youtube.com/watch?v=yhJEJKG-aK8)

src/data/roadmaps/ios/content/media@nGCG74_Xp_Ngt0u7PZnZl.md

@@ -1 +1,3 @@
 # Media
+
+The iOS Media Layer is a collection of frameworks and technologies that enable developers to incorporate rich multimedia experiences into their apps. It includes tools for handling audio, video, and graphics. Key components are AVFoundation for working with time-based audiovisual media, Core Audio for low-level audio processing, Core Animation for fluid animations and visual effects, and Metal for high-performance graphics rendering. This layer also provides support for camera operations, audio recording, and media playback.

src/data/roadmaps/ios/content/mvp@lVNrnUK6p4eifKRVSnOje.md

@@ -1 +1,19 @@
 # MVP
+
+The Model-View-Presenter (MVP) architectural pattern is a derivative of the Model-View-Controller (MVC) pattern, designed to improve separation of concerns and testability in iOS applications. 
+
+In MVP:
+
+**Model**: Represents the data and business logic.
+
+**View**: Responsible for displaying data and capturing user inputs. It's typically passive and doesn't contain business logic.
+
+**Presenter**: Acts as an intermediary between Model and View. It retrieves data from the Model, formats it for the View, and reacts to user inputs from the View.
+
+MVP reduces the responsibilities of the View compared to MVC, making the UI layer thinner and more easily testable. The Presenter contains the presentation logic and is usually paired with a specific View, facilitating unit testing of the user interface logic without needing to interact with the UI components directly.
+
+Learn more from the following resources:
+
+- [@article@MVP Wikipedia](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter)
+- [@article@]Swift MVP: A Step-by-Step Guide for Clean Code](Swift MVP: A Step-by-Step Guide for Clean Code)
+- [@video@Discover the MVP architecture in less than 90 seconds](https://www.youtube.com/watch?v=DUX0nr5rvnU)

src/data/roadmaps/ios/content/mvvm-c@iLT2jAkQg-Ex0zSLquNfl.md

@@ -1 +1,14 @@
 # MVVM-C
+
+MVVM-C (Model-View-ViewModel-Coordinator) is an extension of the MVVM architectural pattern that adds a Coordinator component to manage navigation flow and app structure. In this pattern:
+
+Model, View, and ViewModel retain their roles from MVVM.
+
+**Coordinator**: Handles navigation logic and flow between different screens or modules of the app.
+
+The Coordinator pattern decouples view controllers from each other, centralizing navigation logic. This approach simplifies view controllers, improves modularity, and makes it easier to change or reuse flows within the app. Coordinators can be nested for complex navigation hierarchies.
+
+Learn more from the following resources:
+
+- [@video@Everything you need to know about client arthitecture patterns](https://www.youtube.com/watch?v=I5c7fBgvkNY)
+- [@article@iOS Architecture: MVVM-C, Introduction](https://medium.com/sudo-by-icalia-labs/ios-architecture-mvvm-c-introduction-1-6-815204248518)

src/data/roadmaps/ios/content/mvvm@taTxZw2c3xS18JOwgkNHM.md

@@ -1 +1,18 @@
 # MVVM
+
+The Model-View-ViewModel (MVVM) architectural pattern is a design approach that separates an application's user interface logic from its business logic. In iOS development:
+
+**Model**: Represents data and business logic, independent of the UI.
+
+**View**: Displays information and captures user input. In iOS, this is typically a UIView or UIViewController.
+
+**ViewModel**: Acts as an intermediary between Model and View, containing the presentation logic and state. It exposes data and commands for the View to bind to.
+
+MVVM promotes a clear separation of concerns, enhances testability, and facilitates data binding. The ViewModel transforms Model information for View consumption and handles View-related logic, making the View as passive as possible.
+
+Learn more from the following resources:
+
+- [@video@]MVVM In 100 Seconds](https://www.youtube.com/watch?v=-xTqfilaYow)
+- [@article@Understanding MVVM: Model-View-ViewModel Architecture Explained](https://www.ramotion.com/blog/what-is-mvvm/)
+- [@article@MVVM - Wikipedia](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93viewmodel)
+- [@article@MVVM - Microsoft](https://learn.microsoft.com/en-us/dotnet/architecture/maui/mvvm)

src/data/roadmaps/ios/content/navigation-view@IBr2P7dknWTnZ2a-fFCqN.md

@@ -4,7 +4,6 @@ Use a NavigationView to create a navigation-based app in which the user can trav
 > [!WARNING]
 > Deprecated. Use NavigationStack and NavigationSplitView instead. For more information, see Migrating to new navigation types.
 
-
 Visit the following resources to learn more:
 
 - [@official@Navigation View](https://developer.apple.com/documentation/swiftui/navigationview)

src/data/roadmaps/ios/content/navigationlink@my77jLU2qxU7bQ7_Fx2iH.md

@@ -1 +1,9 @@
 # NavigationLink
+
+NavigationLink is a SwiftUI component used to create navigation hierarchies within an app. It enables developers to define navigation paths between views, typically within a NavigationView. When tapped, a NavigationLink pushes a new view onto the navigation stack. It can be configured with a destination view and optional label, allowing for customizable navigation buttons or entire rows in lists to become navigable. NavigationLink supports programmatic navigation through bindings, enabling dynamic navigation based on app state.
+
+Learn more from the following resources:
+
+- [@official@NavigationLink Documentation](https://developer.apple.com/documentation/swiftui/navigationlink)
+- [@article@Displaying a detail screen with NavigationLink](https://www.hackingwithswift.com/quick-start/swiftui/displaying-a-detail-screen-with-navigationlink)
+- [@video@Displaying a detail screen with NavigationLink](https://www.youtube.com/watch?v=yGqmf8hnC8U)

src/data/roadmaps/ios/content/presenting--dismissing-views@4pmjLa7WvwV7D3RZlM6Hp.md

@@ -1 +1,14 @@
 # Presenting / Dismissing views
+
+SwiftUI offers several methods for presenting and dismissing views, providing flexible options for modal presentations and navigation. Sheets can be presented using the .sheet() modifier, allowing full or partial screen overlays. For alerts and action sheets, .alert() and .actionSheet() modifiers are used. Popovers are created with the .popover() modifier, typically for iPad interfaces. Full-screen covers use the .fullScreenCover() modifier. 
+
+To dismiss these presented views, SwiftUI uses the @Environment(\.presentationMode) property wrapper, allowing views to dismiss themselves. For navigation-based presentations, NavigationLink handles showing new views, while the .navigationBarItems() modifier can add dismiss functionality. These tools enable developers to create diverse and interactive user interfaces with smooth transitions between different view states.
+
+Learn more from the following resources:
+
+- [@official@sheet(ispresented) Documentation]
+- [@official@dismiss Documentation](https://developer.apple.com/documentation/swiftui/environmentvalues/dismiss)
+(https://developer.apple.com/documentation/swiftui/view/sheet(ispresented:ondismiss:content:))
+- [@article@How to present a new view using sheets](https://www.hackingwithswift.com/quick-start/swiftui/how-to-present-a-new-view-using-sheets)
+- [@article@How to make a view dismiss itself](https://www.hackingwithswift.com/quick-start/swiftui/how-to-make-a-view-dismiss-itself)
+

src/data/roadmaps/ios/content/swiftui@kAIKsDcDzwI1E0wSnC_uo.md

@@ -1 +1,10 @@
 # SwiftUI
+
+SwiftUI is Apple's modern declarative framework for building user interfaces across all Apple platforms. Introduced in 2019, it allows developers to create UIs using Swift code, describing the desired layout and behavior rather than implementing them imperatively. SwiftUI offers a more concise and intuitive approach to UI development, with features like automatic support for Dark Mode, dynamic type, and localization. It uses a state-driven approach, automatically updating the UI when underlying data changes. While newer than UIKit, SwiftUI is rapidly evolving and gaining adoption, offering seamless integration with UIKit when needed.
+
+Learn more from the following resources:
+
+- [@official@SwiftUI Documentation](https://developer.apple.com/xcode/swiftui/)
+- [@official@Apple - SwiftUI Documentation](https://developer.apple.com/documentation/SwiftUI?changes=latest_minor)
+- [@article@Build an iOS app with SwiftUI](https://www.swift.org/getting-started/swiftui/)
+- [@video@ WWDC24: SwiftUI essentials | Apple ](https://www.youtube.com/watch?v=HyQgpxX__-A)

src/data/roadmaps/ios/content/tca@NhC0SBZgUFGjMLNICvbTI.md

@@ -1 +1,19 @@
 # TCA
+
+The Composable Architecture (TCA) is a library and architectural pattern for building iOS applications, developed by Point-Free. It emphasizes:
+
+**State management**: All app state is centralized and clearly defined.
+
+**Composability**: Complex features are built from smaller, reusable components.
+
+**Side effect management**: Effects like network calls are handled predictably and testably.
+
+**Testing**: The architecture facilitates comprehensive unit and integration testing.
+
+TCA uses a unidirectional data flow, where state changes trigger actions, which may produce effects and lead to new states. It relies on Swift's value types and function composition to create a predictable and maintainable app structure.
+
+Learn more from the following resources:
+
+- [@opensource@The Composable architecture](https://github.com/pointfreeco/swift-composable-architecture)
+- [@article@The Composable Architecture: Swift guide to TCA](https://medium.com/@dmitrylupich/the-composable-architecture-swift-guide-to-tca-c3bf9b2e86ef)
+- [@video@Shai Mishali - A Newbie's Guide to The Composable Architecture](https://www.youtube.com/watch?v=XWZmgbylTpc)

src/data/roadmaps/ios/content/uikit@-7OW2IgiMk1eot1PaYd7m.md

@@ -1,9 +1,9 @@
 # UIKit
 
-UIKit provides a variety of features for building apps, including components you can use to construct the core infrastructure of your iOS, iPadOS, or tvOS apps. The framework provides the window and view architecture for implementing your UI, the event-handling infrastructure for delivering Multi-Touch and other types of input to your app, and the main run loop for managing interactions between the user, the system, and your app.
+UIKit is a fundamental framework for building user interfaces in iOS applications. It provides a comprehensive set of tools and pre-built components for creating and managing graphical interfaces, handling user interactions, and implementing app navigation. UIKit includes essential UI elements like buttons, labels, text fields, and table views, as well as controllers for managing view hierarchies and app structure. It also offers support for touch and gesture recognition, animation, and accessibility features. While SwiftUI is gaining popularity, UIKit remains crucial for iOS development due to its maturity, extensive documentation, and wide range of capabilities for creating polished, responsive user interfaces across Apple's mobile platforms.
 
-Visit the following resources to learn more:
+Learn more from the following resources: 
 
-- [@official@UIKit](https://developer.apple.com/documentation/uikit)
+- [@official@UIKit Documentation](https://developer.apple.com/documentation/uikit)
 - [@article@Build Your First iOS App with UIKit](https://daily.dev/blog/build-your-first-ios-app-with-uikit-beginners-guide)
 - [@video@Introduction to Programmatic UI - UIKit](https://www.youtube.com/watch?v=_U6_l58Cv4E)

src/data/roadmaps/ios/content/user-interactions@GKuxilB0AwjcTgCSk3FeU.md

@@ -1 +1,8 @@
 # User Interactions
+
+UIKit User Interactions encompass the various ways users can engage with an iOS app's interface. This includes touch events (taps, swipes, pinches), gesture recognizers for complex interactions, and control events for UI elements like buttons and sliders. UIKit provides a robust event handling system, allowing developers to respond to user actions through target-action patterns, delegate methods, or closure-based callbacks. It also supports accessibility features, enabling interactions via VoiceOver and switch control.
+
+Learn more from the following resources:
+
+- [@official@Interactions](https://developer.apple.com/documentation/uikit/uiview/2891054-interactions)
+- [@article@How do I handle user interactions in iOS apps?](https://clouddevs.com/ios/user-interactions/)

src/data/roadmaps/ios/content/version-control@sGnDm2xuJxqfU3pwmlY7H.md

@@ -1 +1,9 @@
 # Version Control
+
+Version control is a system that tracks changes to files over time, allowing multiple developers to collaborate on projects efficiently. It enables users to review project history, revert to previous states, manage different versions, and merge changes from multiple sources. Git is the most popular version control system, offering features like branching, merging, and distributed development. Version control is essential for software development, providing backup, facilitating collaboration, and allowing experimentation without risking project stability. It helps teams maintain code quality, resolve conflicts, and streamline the development process across various platforms and projects.
+
+Learn more from the following resources:
+
+- [@article@What is version control?](https://www.atlassian.com/git/tutorials/what-is-version-control)
+- [@article@Git - About version control](https://git-scm.com/book/en/v2/Getting-Started-About-Version-Control)
+- [@video@What is version control and why you should always use it](https://www.youtube.com/watch?v=IeXhYROClZk)

src/data/roadmaps/ios/content/view-controllers@mfWdkUm1RhjygtMyInXiD.md

@@ -1 +1,8 @@
 # View Controllers
+
+UIKit View Controllers are central to iOS app architecture, managing a view hierarchy and coordinating the flow of data between the app's data model and its views. They handle the presentation and dismissal of content, respond to user interactions, and manage the lifecycle of their associated views. Key types include `UIViewController` for basic screen management, `UINavigationController` for hierarchical navigation, `UITabBarController` for tab-based interfaces, and `UITableViewController` for table-based content. View controllers are responsible for loading and unloading views, handling device rotation, and managing memory efficiently. 
+
+Learn more from the following resources:
+
+- [@official@View Controllers](https://developer.apple.com/documentation/uikit/view_controllers)
+- [@video@UIKit View Controllers](https://www.youtube.com/watch?v=WuSesaZcaMQ)

src/data/roadmaps/ios/content/view-transitions@cwVcNDTBBulBY2m4Wzn4G.md

@@ -1 +1,8 @@
 # View Transitions
+
+UIKit View Transitions provide mechanisms for animating changes between different views or view states within an iOS app. These transitions can be used for presenting or dismissing view controllers, switching between views in a container, or updating the content of a single view. UIKit offers built-in transition styles like push, fade, and flip, as well as the ability to create custom transitions using animation controllers. Developers can use `UIView.transition(with:duration:options:animations:completion:)` for simple view changes or implement `UIViewControllerAnimatedTransitioning` for more complex, custom transitions between view controllers.
+
+Learn more from the following resources:
+
+- [@article@View Controller Transitions](https://developer.apple.com/documentation/uikit/animation_and_haptics/view_controller_transitions)
+- [@course@Kodeco - UIKit Transitions](https://www.kodeco.com/books/ios-animations-by-tutorials/v6.0/chapters/5-transitions)

src/data/roadmaps/ios/content/viewcontroller-lifecycle@DZaY060-5D6PbfryOZH9H.md

@@ -1 +1,8 @@
 # ViewController Lifecycle
+
+The ViewController lifecycle in iOS refers to the sequence of methods called as a view controller transitions between states. It begins with initialization, followed by loading the view, appearing on screen, disappearing, and potentially being deallocated. Key methods include `viewDidLoad()`, `viewWillAppear()`, `viewDidAppear()`, `viewWillDisappear()`, and `viewDidDisappear()`. Understanding this lifecycle is crucial for managing resources, updating UI, and handling state changes efficiently in iOS apps. 
+
+Learn more from the following resources:
+
+- [@article@ViewController Life Cycle in iOS](https://medium.com/@knoo/viewcontroller-life-cycle-in-ios-29f7da4acfc7)
+- [@opensource@ViewController Life Cycle](https://guides.codepath.com/ios/View-Controller-Lifecycle)

src/data/roadmaps/ios/content/views@se9w7mT1XJLGlmWUhH4Uv.md

@@ -1 +1,9 @@
 # Views
+
+UIKit views are the core visual elements in iOS interfaces, serving as the canvas for all user interface components. At its most basic, a view is an instance of UIView, representing a rectangular area on the screen. Views handle rendering content, laying out subviews, and responding to touch events. They can be nested to create complex layouts, with each view responsible for drawing and managing its own area. While some views display content directly, others act as containers for other views.
+
+Learn more from the following resources:
+
+- [@official@Views and Controls](https://developer.apple.com/documentation/uikit/views_and_controls)
+- [@video@Intro to UIKit and UIViews](https://www.youtube.com/watch?v=w58ncTHKiK4)
+- [@article@Performing iOS Animations On Views With UIKit And UIView](https://www.smashingmagazine.com/2019/11/performing-ios-animations-views-uikit-uiview)

src/data/roadmaps/ios/content/viper@mTdnDPGYSDupM9VBNdXRg.md

@@ -1 +1,21 @@
 # VIPER
+
+VIPER (View, Interactor, Presenter, Entity, Router) is an architectural pattern for iOS applications that adheres to clean architecture principles. It breaks down app components into five distinct roles:
+
+**View**: Displays information and sends user actions to the Presenter.
+
+**Interactor**: Contains business logic and data manipulation.
+
+**Presenter**: Mediates between View and Interactor, formats data for display.
+
+**Entity**: Represents basic model objects used by the Interactor.
+
+**Router**: Handles navigation logic between modules.
+
+VIPER aims to create a clear separation of concerns, improving testability and maintainability. It's particularly useful for large, complex applications where scalability is crucial.
+
+Learn more from the following resources:
+
+- [@video@Swift: VIPER Design Pattern](https://www.youtube.com/watch?v=hFLdbWEE3_Y)
+- [@article@Understanding VIPER Architecture](https://medium.com/@pinarkocak/understanding-viper-pattern-619fa9a0b1f1)
+- [@article@Getting Started with the VIPER Architecture Pattern for iOS Application Development](https://dev.to/marwan8/getting-started-with-the-viper-architecture-pattern-for-ios-application-development-2oee)

src/data/roadmaps/ios/content/xibs@RwvC4Pi18_1phcrJL-9iu.md

@@ -1 +1,9 @@
 # Xibs
+
+UIKit Xibs (XML Interface Builder files) are resource files used to design individual view hierarchies or custom views in iOS development. Unlike Storyboards, which can represent an entire app's interface, Xibs typically focus on smaller, reusable UI components or single view controllers. They offer a visual way to create and layout UI elements, set up constraints, and configure properties without writing code. Xibs are particularly useful for creating custom table view cells, reusable views, or view controllers that need to be instantiated programmatically. 
+
+Learn more from the following resources:
+
+- [@article@Building a Custom Component with XIB (iOS)](https://medium.com/@fsamuelsmartins/building-a-custom-component-with-xib-ios-f712840b651c)
+- [@article@Working with XIBs and Storyboards](https://entangleddev.com/posts/uikit/workingwithxibstoryboards/)
+- [@video@UITableView Tutorial with Custom Cells, XIB](https://www.youtube.com/watch?v=OOc-RhNQnLc)