From 33df3b1757252837daf97e7a2c1f3d827269b342 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Fri, 24 Jul 2026 12:42:47 +0200 Subject: [PATCH] chore: sync content to repo (#10177) Co-authored-by: nilbuild <4921183+nilbuild@users.noreply.github.com> --- ...ibility-inspector@h34LaYQ3JYN2AZPMDqpmO.md | 6 ++--- .../accessibility@1DZYPqvgY6GtwMCS7N2y-.md | 3 ++- .../alamofire@nJeBisdKtN43ntkXnPCVF.md | 6 ++--- ...tore-distribution@iZAXQKLe2LaIIifVFtFOL.md | 18 +++++---------- ...-optimization-aso@jZpH-T2hW-XBdprVqemGi.md | 10 ++++----- .../content/arkit@k3uHcF0CsyHr6PK95UwR1.md | 8 +++---- .../async--await@ysaBCl_TtWqelirptQp7P.md | 6 ++--- .../auto-layout@j2BL0sf3WjnJZZWa7cCjy.md | 8 ++----- .../avfoundation@UKgiSQvR9cryQT50t7riZ.md | 2 +- .../azure-devops@r3fNx1Hk_TGlQSDtRnXqF.md | 4 +++- .../basic-interfaces@0o3V_zveN1xCIt7rayrCF.md | 8 +++---- ...eating-animations@w0i5Dxp40XS2HnF5nXeZI.md | 11 +++++----- ...-over-objective-c@ZkNulHQAqhiFTO3CRC_mW.md | 18 ++++----------- .../breakpoints@X0QavvwPVJU6sulafPVUK.md | 17 +++----------- ...ilding-interfaces@YvuYJceeNNfLBpq2-3iiL.md | 8 +++---- .../callback-hell@WhOpzFvv21QQV3aS6XbXr.md | 6 ++--- .../callbacks@qJEd7KU52xL_GRG3IQqhM.md | 8 +++---- ...lues--memory-mgmt@S-D-PnHA7COd2Dp6U2XO4.md | 6 ++--- .../content/carthage@tIHjjNTXJWcNgkO6TB9ea.md | 10 ++++----- .../content/ci--cd@U4xE1enkZxUME0j0gutae.md | 10 ++------- .../content/circleci@tWxuFh0xDugdplnHt_G0e.md | 6 ++--- .../content/closures@M9UlalPL47GoqhcyGsAPV.md | 4 ++-- .../cocoa-touch@leozxW-5fAOfkKbQM4FD1.md | 8 ++----- .../cocoapods@epr1sOEZIAOwlgb8bre7r.md | 2 +- ...ode-quality-tools@DVe8S6TjKcQ8LT5G-aMVa.md | 4 ++-- .../combine-and-mvvm@pY_zaMcFpeFDLgVk2W0Vy.md | 6 ++--- .../content/combine@UzpdLLPs226N00c6weWRv.md | 7 +++--- .../components@A1TFKVjGU5RbeTF_zxJlu.md | 6 ++--- .../components@xkH7Llut6uP2-8iTMw76F.md | 4 ++-- ...nd-multithreading@fbloF-u4XwdHLmBS9flZm.md | 4 ++-- ...cy-gcd-asyncawait@aALIiAxKz4f7B_EYyhBCi.md | 6 ++--- .../concurrency@-aLGB3cDXZHIhVU3t-Ve4.md | 8 +++---- .../core-animation@KpcmuLWX0xAjz6ty4ebtB.md | 2 +- .../core-animation@_mRs6ctH0IsSSi-cwV2b8.md | 4 ++-- .../core-audio@4bAABCfTvxchS5C5NlAro.md | 2 +- .../core-data@H4-Dp2WTA6HAZiFRQdLjx.md | 7 +++--- .../core-graphics@kRE9xT3mT9Si4NwJr9yGi.md | 2 +- .../core-image@6zE_M0_oVpwW0B9qFSRgP.md | 6 ++--- .../content/core-ml@7s9Elv80TbZX_-NZpyutj.md | 3 ++- .../content/core-os@IdGdLNgJI3WmONEFsMq-d.md | 10 +++------ ...gramming-concepts@mk02yV7_XHkgp2xdNIxaU.md | 7 +++--- .../core-services@LHM7gNgTtfn_QDW-oQskD.md | 15 +++---------- .../data-binding@yR94uHs0SiSScU4gPBzfr.md | 2 +- .../data-persistence@6gfqFy3H6SLt06oJ1kt5A.md | 6 ++--- .../debug-navigator@VuWUsg05WmOoP_RJ5AXJO.md | 18 +++------------ ...ugging-techniques@OZZ3UnWN2gFflbM_WaJ8H.md | 4 ++-- ...eclarative-syntax@QVg4_8EXeQBJbleryy8c1.md | 2 +- .../delegate-pattern@BtPYKd7RedHOLRATDKkpg.md | 6 ++--- ...ependency-manager@Tv8-WUcKiZMLHuunQwise.md | 4 ++-- .../dynamic-library@Lrb4HZYrZU7SJlbedZp7U.md | 8 +++---- .../dynamic-type@0nei6iwP4Pgi_j4vVi_Qt.md | 3 ++- .../content/editors@-4q7MFXaTmpR_39PTeWD8.md | 15 +++---------- .../error-handling@N5ojp6bqgH074MPKYjCHV.md | 6 ++--- .../content/fastlane@_W3vb0b14FrWB2fH7DHC7.md | 14 +++--------- .../file-system@_bkRbqVXKNCnRvEFCM6mN.md | 6 ++--- ...ameworks--library@pZVPsgvCpP3zUgBM4i0CF.md | 4 ++-- .../frameworks@PdzCQXZIivw3zCYPtokJV.md | 2 +- ...ional-programming@Pj-hqRZUmwx1WhmTbLoFD.md | 4 ++-- .../content/gamekit@H5F9P5xeQiHhWhS6jEzp5.md | 6 ++--- .../ios/content/gcd@aROcI1RucAyu-gHn-tVnj.md | 8 +++---- .../ios/content/git@QifWR7WSJJTcTK2IfczxG.md | 6 ++--- .../github-actions@LltERZaHsI-R_3O_3twpk.md | 10 ++++----- .../content/github@U_xXGSFF5iibQ4VkzPAWf.md | 5 ++--- .../content/gitlab@VylaBSDAVFzveVfytI1Fz.md | 6 ++--- .../content/graphql@9o7d3aN0YFfNNUeVoJrhs.md | 10 ++++----- .../content/groups@42sfiLKrVCcnMMjR7TFn1.md | 18 ++++----------- .../healthkit@Jsu5f6QASpuvpky_W5q-O.md | 6 ++--- .../ios/content/hig@1I5eFKqFVBxWLAXfpgNXO.md | 4 ++-- ...ory-and-why-swift@z4-1Gc95JKYAn2RPFc7hw.md | 19 +++++----------- .../http--https@GjY5qCU1rjB0D58qHQtAR.md | 6 ++--- .../ibactions@FspN4yiBF9aEN7_SlXUe1.md | 21 +++++------------- .../iboutlets@tuUuLInq0p-nhehe2AqPg.md | 4 ++-- ...menting-delegates@z3AUN9u7EEqeKOqvLxf7D.md | 6 ++--- .../installing@R8LdFpfyS0MFYJuMLk8RG.md | 10 ++++----- ...interface-builder@iMzYd8KUFnk6zqr4KecgX.md | 18 +++------------ ...nterface-overview@FwwqAchMC6qdnXbqg45he.md | 14 ++---------- ...bility-with-swift@IAPzuN51xvrZJ5TFB23Q9.md | 17 +++----------- .../ios-architecture@IduGSdUa2Fi7VFMLKgmsS.md | 7 +++--- .../content/jenkins@TrblGyy81Oep2CBxoZkaf.md | 6 ++--- .../json--xml@WYV4YG_sLvC4S5ptFFdrF.md | 4 ++-- ...updated-with-wwdc@fOOQurIL1w3PwH5Mep9x1.md | 13 +++-------- .../content/keychain@8v_eP0j85TnB33XyYAzrT.md | 6 ++--- .../latest-ios-sdk@SBlLNfyWzzhdFNtNtkLet.md | 4 +++- ...est-swift-version@e7qVpQeu2iQL0c9MOMCVe.md | 6 +++-- .../content/lottie@i-T6GTqS0FZ_Llt5v4SvR.md | 5 ++--- .../content/mapkit@XOXsjaQ-YyuAMpVCqH8KG.md | 10 ++++----- .../content/media@nGCG74_Xp_Ngt0u7PZnZl.md | 2 +- ...memory-management@tqbg8mBJfjuXacdMlIB_L.md | 11 +++------- .../content/metal@5VguZoP4h40rTWkxWxaxU.md | 6 ++--- ...ls-and-navigation@jb89kQxDhZND3vQo0EH7r.md | 14 ++++-------- .../ios/content/mvc@a-QDI7Ei-B5BRHbicFcfG.md | 12 +++++----- .../ios/content/mvp@lVNrnUK6p4eifKRVSnOje.md | 17 +++----------- .../content/mvvm-c@iLT2jAkQg-Ex0zSLquNfl.md | 16 +++++--------- .../ios/content/mvvm@taTxZw2c3xS18JOwgkNHM.md | 18 +++++---------- ...ontrollers-segues@tUbMr1pGlw4JwMuW311JJ.md | 14 +++++------- ...navigation-stacks@TLm70PlTI0K3Odn1iYxWX.md | 9 +++----- ...navigation-stacks@mUMDZsgzCB6cs_K6pfUY1.md | 4 ++-- .../navigation-view@IBr2P7dknWTnZ2a-fFCqN.md | 8 +++---- .../navigation@02VAK4GMkN6nDHf1zqwPA.md | 11 +++++----- .../navigation@FXUrfyvuIIOH7VDnT_E0z.md | 2 +- .../navigationlink@my77jLU2qxU7bQ7_Fx2iH.md | 2 +- .../navigators@odKZx4SUULF1y4gmiJZdu.md | 14 ++---------- .../networking@JoNoM-utp8MaL1H0oXDta.md | 6 ++++- ...ure-announcements@0dbdUmWvTIJ0fkUuLp9gR.md | 4 +++- .../new-project@BJgoAgH85U6S3RtXq7hHV.md | 4 ++-- ...bjective-c-basics@0BSX80W1TJ_Ia_Zh2zKyK.md | 4 +++- .../objective-c@oOaMz9A5DZvrjxovMztXz.md | 11 +++------- ...vables--observers@k232wKg7XCb_ngjZ5Mwsy.md | 10 ++++----- .../ios/content/oop@FoqlB7xBIrV4yUp4ReBkw.md | 2 +- .../operation-queues@mdAV4JlF08q-ZQpb5C3q6.md | 6 ++--- ...rators--pipelines@GAn12SsVR_mPxOaOVckdz.md | 8 +++---- .../operators@t7IYTY8tVjC_xzM1n8wts.md | 6 ++--- .../content/parsing@UTVh1RHRWb5eA-S7ayLp8.md | 10 ++++----- .../pick-a-language@MrdIb9F-wSEbUz7KRnH3t.md | 8 +++---- .../preferences@SeGfULWFR7ufdv4U9Db3F.md | 2 +- ...-dismissing-views@4pmjLa7WvwV7D3RZlM6Hp.md | 14 +++++------- ...iling-instruments@Y24WWPej0C7-FiBeXpvl3.md | 10 ++++----- .../project-files@YytdlQl41yrHSwlV-G3Pd.md | 22 +++++-------------- ...hers--subscribers@noBaDV_PvCTzqPyw9eO4H.md | 4 ++-- ...ushing-presenting@gqd6zjxP_qFj4Ru-6LARo.md | 10 ++++----- ...ctive-programming@28HMXXBJWd3n-ZPgeQRDa.md | 2 +- .../ios/content/rest@3Qw-qmy5iAE61mPbIY4Q2.md | 6 ++--- ...rxswift-with-mvvm@g_1f5a6tIB5V_36NjgtL5.md | 6 ++--- .../content/rxswift@0xwoWj9jek36p1AwU3WkK.md | 8 +++---- .../schedulers@UqA01PT86_w_JzN6KZBku.md | 6 ++--- .../serializing@8rYjSCgRiJMHTNxOU6vgG.md | 6 ++--- ...imple-ui-building@INYUFVZ-_4htveLZ6EvRu.md | 3 +++ .../content/sqlite@3qjQbrCUchJn1bJTBWrQF.md | 8 +++---- .../state-management@RvyOkQelc-GChQGJyEx72.md | 11 ++++------ .../static-library@RuXuHQhMt2nywk43LgGeJ.md | 8 +++---- .../content/stepping@hUHxlNa6iJJbDGdFNhynB.md | 19 +++++----------- .../storyboards@a2CqrCJSxGfHq6_Y9f_re.md | 10 ++++----- .../content/subjects@1xYZdnlI6JSJzNvmz4-0v.md | 10 ++++----- .../swift-basics@fboebSmquyJyozsMRJDtK.md | 10 ++++----- ...t-package-manager@KFkX8_Hv9SCFeCtZMZIQM.md | 6 ++--- ...swift-recommended@KJ7fM-V0_azY_lzmhjJAN.md | 11 ++++------ .../swiftformat@TMFvfwG45Z00PzrzZIVhT.md | 8 +++---- .../swiftlint@NnTC3R8goZQTXHmfHKHbM.md | 14 ++++++------ .../content/swiftui@PvFp6aY7EUrYHn87RZAGj.md | 8 ++++++- .../content/swiftui@kAIKsDcDzwI1E0wSnC_uo.md | 11 +++++----- .../content/tailor@F5796wzm5Ar6sQt-1y8vH.md | 8 +++---- .../ios/content/tca@NhC0SBZgUFGjMLNICvbTI.md | 18 ++++----------- ...st-plan--coverage@uczkyc30K_qqcarZCGTdF.md | 9 ++------ .../testflight@KCJgCjMJGxIcf13XSEclO.md | 10 ++++----- .../content/toolbar@AxQ5gCjk136kXsbBFTUNp.md | 14 ++---------- .../ui-design@4fPgpGwNXmVoZoruBRb_B.md | 11 +++++----- .../content/uikit@-7OW2IgiMk1eot1PaYd7m.md | 8 +++---- .../content/uikit@pNEE5C1E1wAjH_nTlzH6N.md | 4 +++- ...nd-using-closures@5V7nxQKmmHWSMSBCRxkaF.md | 6 ++--- .../unit--ui-testing@5589B1DKaCd-9l9DfKH3o.md | 4 ++-- .../urlsession@WPJACNeI6jX9GGB1roeTp.md | 10 ++++----- .../user-defaults@ImS1FqVicQImMw-y1ze7y.md | 6 ++--- ...user-interactions@GKuxilB0AwjcTgCSk3FeU.md | 2 +- .../version-control@sGnDm2xuJxqfU3pwmlY7H.md | 11 +++++----- .../view-controllers@mfWdkUm1RhjygtMyInXiD.md | 6 ++--- .../view-transitions@2tmR1yE5daz2HB4IV5qwI.md | 10 ++++----- .../view-transitions@cwVcNDTBBulBY2m4Wzn4G.md | 8 +++---- ...troller-lifecycle@DZaY060-5D6PbfryOZH9H.md | 6 ++--- ...ews-and-modifiers@mgUCYztUpKINqIZikT4Bh.md | 7 +++--- ...-view-controllers@XX5rCd_yTHvOfYif4Kpbl.md | 12 ++++------ .../content/views@se9w7mT1XJLGlmWUhH4Uv.md | 6 ++--- .../content/viper@mTdnDPGYSDupM9VBNdXRg.md | 22 +++++-------------- .../voice-over@trAMZVA4tDB7b_qAgiWNW.md | 9 +++----- .../xcframework@MaHtZSIPxDzrnB33_9OdV.md | 6 ++--- .../xcode-debugger@WxshXCloVDkVkQV0JvI1w.md | 10 ++++----- .../content/xcode@la5M4VoH79bhnN8qj5Izp.md | 5 ++--- .../content/xctest@xZmBJVq5FHNdm1BDuZbbS.md | 6 ++--- .../content/xcuitest@ZQSUKPbXZl5yKra2ap8JR.md | 6 ++--- .../ios/content/xibs@RwvC4Pi18_1phcrJL-9iu.md | 4 ++-- 169 files changed, 540 insertions(+), 831 deletions(-) create mode 100644 src/data/roadmaps/ios/content/simple-ui-building@INYUFVZ-_4htveLZ6EvRu.md diff --git a/src/data/roadmaps/ios/content/accessibility-inspector@h34LaYQ3JYN2AZPMDqpmO.md b/src/data/roadmaps/ios/content/accessibility-inspector@h34LaYQ3JYN2AZPMDqpmO.md index ff040a631..5e1db7207 100644 --- a/src/data/roadmaps/ios/content/accessibility-inspector@h34LaYQ3JYN2AZPMDqpmO.md +++ b/src/data/roadmaps/ios/content/accessibility-inspector@h34LaYQ3JYN2AZPMDqpmO.md @@ -1,8 +1,8 @@ # Accessibility Inspector + +Accessibility Inspector is a tool in Xcode that audits UI elements for accessibility issues. It displays the accessibility properties of each element, runs automated audits to catch missing labels and low-contrast issues, and simulates VoiceOver navigation. It is the primary tool for testing and improving accessibility during development. -The Accessibility Inspector is a powerful tool in Xcode that helps developers ensure their iOS applications are accessible to users with disabilities. It provides a comprehensive view of an app's accessibility features, allowing developers to inspect and test various accessibility attributes of UI elements. The inspector displays information such as accessibility labels, hints, and traits for each element on the screen. It enables real-time simulation of different accessibility settings, such as VoiceOver, to test how the app behaves under various accessibility conditions. Developers can use the Accessibility Inspector to identify and fix issues related to screen reader compatibility, color contrast, and touch target sizes. This tool is crucial for creating inclusive apps that comply with accessibility guidelines and standards, ensuring that apps are usable by people with visual, auditory, motor, or cognitive impairments. Regular use of the Accessibility Inspector throughout the development process helps in building more universally accessible and user-friendly iOS applications. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Accessibility Inspector](https://developer.apple.com/documentation/accessibility/accessibility-inspector) - [@official@Inspecting the accessibility of the screens in your app](https://developer.apple.com/documentation/accessibility/inspecting-the-accessibility-of-screens) diff --git a/src/data/roadmaps/ios/content/accessibility@1DZYPqvgY6GtwMCS7N2y-.md b/src/data/roadmaps/ios/content/accessibility@1DZYPqvgY6GtwMCS7N2y-.md index 75c7899ab..df4a591c2 100644 --- a/src/data/roadmaps/ios/content/accessibility@1DZYPqvgY6GtwMCS7N2y-.md +++ b/src/data/roadmaps/ios/content/accessibility@1DZYPqvgY6GtwMCS7N2y-.md @@ -1,6 +1,7 @@ # Accessibility + With built-in accessibility features, accessibility APIs, and developer tools, Apple operating systems provide extraordinary opportunities to deliver high-quality experiences to everyone, including people with disabilities. Take advantage of VoiceOver — the revolutionary screen reader for blind and low-vision users — Music Haptics, Switch Control, Guided Access, Text to Speech, closed‑captioned or audio‑described video, and more. Visit the following resources to learn more: -- [@official@Accessibility](https://developer.apple.com/accessibility/) +- [@official@Accessibility](https://developer.apple.com/accessibility/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/alamofire@nJeBisdKtN43ntkXnPCVF.md b/src/data/roadmaps/ios/content/alamofire@nJeBisdKtN43ntkXnPCVF.md index cb9fd4bac..16deefd27 100644 --- a/src/data/roadmaps/ios/content/alamofire@nJeBisdKtN43ntkXnPCVF.md +++ b/src/data/roadmaps/ios/content/alamofire@nJeBisdKtN43ntkXnPCVF.md @@ -1,8 +1,8 @@ # Alamofire + +Alamofire is a Swift networking library built on top of URLSession that simplifies common networking tasks. It provides a clean, chainable API for making requests, handling authentication, and serializing responses. Alamofire is widely used in iOS projects that want a higher-level abstraction over raw URLSession without third-party dependencies for individual components. -Alamofire is a popular third-party networking library for iOS, built on top of Apple's URLSession. It offers a more elegant and simplified interface for common networking tasks, making it easier to write concise and readable networking code. Alamofire provides a chainable request/response API, automated JSON parsing, authentication handling, and convenient methods for common HTTP operations. It supports features like request/response interceptors, network reachability monitoring, and robust error handling. The library is particularly useful for working with RESTful APIs, offering easy integration with JSON and Swift's Codable protocol. Alamofire's modular architecture allows for easy extension and customization, making it adaptable to various project needs. While it adds an external dependency to projects, many developers find that Alamofire's convenience and feature set outweigh this consideration, especially in complex networking scenarios where it can significantly reduce boilerplate code and simplify network request management. - -Learn more from the following resources: +Visit the following resources to learn more: - [@opensource@Alamofire/Alamofire](https://github.com/Alamofire/Alamofire) - [@article@Alamofire Tutorial with Swift (Quickstart)](https://codewithchris.com/alamofire/) diff --git a/src/data/roadmaps/ios/content/app-store-distribution@iZAXQKLe2LaIIifVFtFOL.md b/src/data/roadmaps/ios/content/app-store-distribution@iZAXQKLe2LaIIifVFtFOL.md index 7d3944cea..b7e4c281d 100644 --- a/src/data/roadmaps/ios/content/app-store-distribution@iZAXQKLe2LaIIifVFtFOL.md +++ b/src/data/roadmaps/ios/content/app-store-distribution@iZAXQKLe2LaIIifVFtFOL.md @@ -1,18 +1,10 @@ # App Store Distribution + +Distributing an iOS app through the App Store requires a paid Apple Developer Program membership, building a release archive signed with a distribution certificate, and submitting it through App Store Connect. The app goes through Apple's review process before becoming available to users. App Store Connect also manages metadata, screenshots, pricing, and release scheduling. -App Store distribution is the process of preparing and submitting an iOS application for release on Apple's App Store. This involves several key steps: - -1. App Store Connect Setup: Registering your app in App Store Connect, including adding app metadata, screenshots, and descriptions. -2. Certificates and Provisioning Profiles: Creating the necessary certificates and provisioning profiles in the Apple Developer portal to sign your app for distribution. -3. Build and Archive: Using Xcode to build and archive your app, ensuring it meets Apple’s guidelines and standards. -4. Submission: Submitting the app for review through App Store Connect, where Apple’s review team evaluates it for compliance with their guidelines. -5. Release and Updates: Once approved, the app is published to the App Store. Developers can manage updates, monitor app performance, and respond to user feedback through App Store Connect. - -This process ensures that apps are of high quality, secure, and provide a good user experience before reaching the end users. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Distribute on App Store](https://developer.apple.com/distribute/) - [@official@Distributing Custom Apps](https://developer.apple.com/custom-apps/) -- [@video@Submit App to App Store (Upload iOS App)](https://www.youtube.com/watch?v=bz_KJdXylh0) -- [@article@Creating the iOS Provisioning Profiles](https://support.staffbase.com/hc/en-us/articles/115003598691-Creating-the-iOS-Provisioning-Profiles) \ No newline at end of file +- [@article@Creating the iOS Provisioning Profiles](https://support.staffbase.com/hc/en-us/articles/115003598691-Creating-the-iOS-Provisioning-Profiles) +- [@video@Submit App to App Store (Upload iOS App)](https://www.youtube.com/watch?v=bz_KJdXylh0) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/app-store-optimization-aso@jZpH-T2hW-XBdprVqemGi.md b/src/data/roadmaps/ios/content/app-store-optimization-aso@jZpH-T2hW-XBdprVqemGi.md index 2fb6e30b9..5026ac645 100644 --- a/src/data/roadmaps/ios/content/app-store-optimization-aso@jZpH-T2hW-XBdprVqemGi.md +++ b/src/data/roadmaps/ios/content/app-store-optimization-aso@jZpH-T2hW-XBdprVqemGi.md @@ -1,9 +1,9 @@ # App Store Optimization (ASO) + +App Store Optimization (ASO) is the process of improving an iOS app's visibility and conversion rate in the App Store. It involves optimizing the app name, subtitle, keywords, screenshots, and description to rank higher in relevant searches. Effective ASO increases organic downloads without paid advertising spend. -App Store Optimization (ASO) is the process of improving the visibility and ranking of a mobile app within app stores like Apple's App Store and Google Play. The goal of ASO is to increase app downloads and user engagement. Key strategies include optimizing the app title and description with relevant keywords, creating compelling and clear app icons, and using high-quality screenshots and videos to showcase the app's features. Additionally, gathering positive user reviews and ratings, regularly updating the app to fix bugs and add new features, and encouraging user engagement can significantly enhance an app’s ranking. ASO also involves monitoring and analyzing performance metrics to continually refine and improve the app’s visibility and attractiveness to potential users. Effective ASO leads to higher organic downloads and better overall app performance. - -Learn more from the following resources: +Visit the following resources to learn more: +- [@article@What is App Store Optimization (ASO)?](https://appradar.com/academy/what-is-app-store-optimization-aso) - [@video@5 Essential ASO Strategies to Boost Your App Store Ranking in 2024](https://www.youtube.com/watch?v=bqM9x-oRZOA) -- [@video@Advanced App Store Optimization Strategies for 2024](https://www.youtube.com/watch?v=d8TOuMnMv74) -- [@article@What is App Store Optimization (ASO)?](https://appradar.com/academy/what-is-app-store-optimization-aso) \ No newline at end of file +- [@video@Advanced App Store Optimization Strategies for 2024](https://www.youtube.com/watch?v=d8TOuMnMv74) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/arkit@k3uHcF0CsyHr6PK95UwR1.md b/src/data/roadmaps/ios/content/arkit@k3uHcF0CsyHr6PK95UwR1.md index 7d0907ffb..0bcee3c44 100644 --- a/src/data/roadmaps/ios/content/arkit@k3uHcF0CsyHr6PK95UwR1.md +++ b/src/data/roadmaps/ios/content/arkit@k3uHcF0CsyHr6PK95UwR1.md @@ -1,11 +1,9 @@ # ARKit - -ARKit is Apple’s framework for creating `augmented reality (AR) experiences` on iOS devices. - -`Augmented reality (AR)` describes user experiences that add 2D or 3D elements to the live view from a device’s sensors in a way that makes those elements appear to inhabit the real world. + +ARKit is Apple's augmented reality framework for iOS. It uses the device's camera and motion sensors to track the physical world and overlay digital content on top of it. ARKit provides features like horizontal and vertical plane detection, image tracking, face tracking, and LiDAR scene reconstruction on supported devices. Visit the following resources to learn more: - [@official@ARKit](https://developer.apple.com/documentation/arkit) - [@official@Setting up access to ARKit data](https://developer.apple.com/documentation/visionos/setting-up-access-to-arkit-data) -- [@article@Everything you need to know about Apple's augmented reality platform](https://www.pocket-lint.com/ar-vr/news/apple/141615-apple-ar-kit-explained/) +- [@article@Everything you need to know about Apple's augmented reality platform](https://www.pocket-lint.com/ar-vr/news/apple/141615-apple-ar-kit-explained/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/async--await@ysaBCl_TtWqelirptQp7P.md b/src/data/roadmaps/ios/content/async--await@ysaBCl_TtWqelirptQp7P.md index 482bdf083..6b4153d70 100644 --- a/src/data/roadmaps/ios/content/async--await@ysaBCl_TtWqelirptQp7P.md +++ b/src/data/roadmaps/ios/content/async--await@ysaBCl_TtWqelirptQp7P.md @@ -1,8 +1,8 @@ # Async / Await + +Async/await is Swift's built-in structured concurrency model, introduced in Swift 5.5. Async functions can be suspended at await points without blocking a thread, allowing other work to proceed in the meantime. This makes asynchronous code significantly more readable and composable compared to callback and Combine-based approaches. -Async/await in Swift is a modern approach to handling asynchronous operations, introduced to simplify complex asynchronous code and mitigate the challenges of callback-based programming. This feature allows developers to write asynchronous code that looks and behaves like synchronous code, improving readability and maintainability. The 'async' keyword marks functions that can be suspended and resumed, while 'await' is used to call these functions and wait for their completion without blocking the entire thread. This pattern integrates seamlessly with Swift's error handling mechanism, allowing for more natural try-catch blocks in asynchronous contexts. Async/await works with Swift's structured concurrency system, including tasks and actors, to manage complex asynchronous operations more easily. - -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Async await in Swift explained with code examples](https://www.avanderlee.com/swift/async-await/) - [@article@Swift async await](https://www.hackingwithswift.com/swift/5.5/async-await) diff --git a/src/data/roadmaps/ios/content/auto-layout@j2BL0sf3WjnJZZWa7cCjy.md b/src/data/roadmaps/ios/content/auto-layout@j2BL0sf3WjnJZZWa7cCjy.md index 14dcf5af6..c2a487cbc 100644 --- a/src/data/roadmaps/ios/content/auto-layout@j2BL0sf3WjnJZZWa7cCjy.md +++ b/src/data/roadmaps/ios/content/auto-layout@j2BL0sf3WjnJZZWa7cCjy.md @@ -1,7 +1,3 @@ # Auto layout - -Auto Layout dynamically calculates the size and position of all the views in your view hierarchy, based on constraints placed on those views. For example, you can constrain a button so that it is horizontally centered with an Image view and so that the button’s top edge always remains 8 points below the image’s bottom. If the image view’s size or position changes, the button’s position automatically adjusts to match. - -Learn more from the following resources: - -[@official@Understanding Auto Layout](https://developer.apple.com/library/archive/documentation/UserExperience/Conceptual/AutolayoutPG/index.html) + +Auto Layout is a constraint-based layout system that defines the size and position of views relative to each other and to the container. It automatically adapts layouts for different screen sizes, orientations, and locales. Constraints are created visually in Interface Builder or programmatically using NSLayoutConstraint or anchor APIs. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/avfoundation@UKgiSQvR9cryQT50t7riZ.md b/src/data/roadmaps/ios/content/avfoundation@UKgiSQvR9cryQT50t7riZ.md index c88f5952a..9b4e5052e 100644 --- a/src/data/roadmaps/ios/content/avfoundation@UKgiSQvR9cryQT50t7riZ.md +++ b/src/data/roadmaps/ios/content/avfoundation@UKgiSQvR9cryQT50t7riZ.md @@ -2,7 +2,7 @@ AVFoundation is a comprehensive framework for working with time-based audiovisual media on iOS-based platforms. It enables developers to play, create, and edit QuickTime movies and MPEG-4 files, as well as handle HLS streams. AVFoundation offers robust tools for audio and video capture, editing, and playback, allowing for advanced media functionalities like precise control over audio sessions, media composition, and real-time processing. It ensures high performance and flexibility for building rich multimedia experiences in apps. -Learn more from the following resources: +Visit the following resources to learn more: - [@official@AVFoundation Documentation](https://developer.apple.com/av-foundation/) - [@article@Learning AVFoundation](https://medium.com/@divya.nayak/learning-avfoundation-part-1-c761aad183ad) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/azure-devops@r3fNx1Hk_TGlQSDtRnXqF.md b/src/data/roadmaps/ios/content/azure-devops@r3fNx1Hk_TGlQSDtRnXqF.md index 228b3025c..7380fefda 100644 --- a/src/data/roadmaps/ios/content/azure-devops@r3fNx1Hk_TGlQSDtRnXqF.md +++ b/src/data/roadmaps/ios/content/azure-devops@r3fNx1Hk_TGlQSDtRnXqF.md @@ -1,6 +1,8 @@ # Azure DevOps + +Azure DevOps is Microsoft's suite of developer tools that includes a CI/CD pipeline service supporting iOS development. It uses macOS-hosted agents to run Xcode builds and Fastlane workflows, and integrates with Azure Repos, GitHub, and other source control systems. Azure DevOps is commonly used in enterprise organizations already invested in Microsoft tooling. -Azure DevOps is a suite of development tools and services offered by Microsoft to support the entire software development lifecycle. It includes Azure Repos for source code management with Git repositories, Azure Pipelines for continuous integration and continuous deployment (CI/CD), Azure Boards for agile project management and tracking, Azure Artifacts for managing and sharing packages, and Azure Test Plans for manual and exploratory testing. Azure DevOps integrates seamlessly with a variety of third-party tools and services, offering flexibility and extensibility. It provides robust security features, comprehensive reporting, and scalable infrastructure, making it suitable for teams of all sizes. By using Azure DevOps, development teams can collaborate more effectively, automate their workflows, and deliver high-quality software more quickly and efficiently. +Visit the following resources to learn more: - [@official@Azure DevOps Website](https://azure.microsoft.com/en-gb/products/devops) - [@article@Build, test, and deploy Xcode apps](https://learn.microsoft.com/en-us/azure/devops/pipelines/ecosystems/xcode?view=azure-devops) diff --git a/src/data/roadmaps/ios/content/basic-interfaces@0o3V_zveN1xCIt7rayrCF.md b/src/data/roadmaps/ios/content/basic-interfaces@0o3V_zveN1xCIt7rayrCF.md index 9fc91fbf8..6c36d17d8 100644 --- a/src/data/roadmaps/ios/content/basic-interfaces@0o3V_zveN1xCIt7rayrCF.md +++ b/src/data/roadmaps/ios/content/basic-interfaces@0o3V_zveN1xCIt7rayrCF.md @@ -1,11 +1,11 @@ # Basic Interfaces + +Building a basic interface in UIKit involves adding views to a view controller's root view, setting up Auto Layout constraints, and wiring controls to code through IBOutlets and IBActions. Simple interfaces typically combine labels, buttons, text fields, and image views arranged into a readable, functional layout. -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: +Visit the following resources to learn more: - [@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) +- [@official@UICollectionView](https://developer.apple.com/documentation/uikit/uicollectionview) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/basics--creating-animations@w0i5Dxp40XS2HnF5nXeZI.md b/src/data/roadmaps/ios/content/basics--creating-animations@w0i5Dxp40XS2HnF5nXeZI.md index cb9864fea..394844793 100644 --- a/src/data/roadmaps/ios/content/basics--creating-animations@w0i5Dxp40XS2HnF5nXeZI.md +++ b/src/data/roadmaps/ios/content/basics--creating-animations@w0i5Dxp40XS2HnF5nXeZI.md @@ -1,11 +1,10 @@ # Basics / Creating Animations + +Creating animations with Core Animation involves working with CALayer and CAAnimation subclasses. CABasicAnimation animates a single property from one value to another, while CAKeyframeAnimation defines multiple values along an animation path. Animations are applied to layer properties like position, opacity, transform, and background color. -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: +Visit the following resources to learn more: - [@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) +- [@article@https://developer.apple.com/documentation/quartzcore/cabasicanimation](https://developer.apple.com/documentation/quartzcore/cabasicanimation) +- [@article@What is CALayer?](https://www.hackingwithswift.com/example-code/calayer/what-is-calayer) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/benefits-over-objective-c@ZkNulHQAqhiFTO3CRC_mW.md b/src/data/roadmaps/ios/content/benefits-over-objective-c@ZkNulHQAqhiFTO3CRC_mW.md index 0cde7a461..095950aa9 100644 --- a/src/data/roadmaps/ios/content/benefits-over-objective-c@ZkNulHQAqhiFTO3CRC_mW.md +++ b/src/data/roadmaps/ios/content/benefits-over-objective-c@ZkNulHQAqhiFTO3CRC_mW.md @@ -1,18 +1,8 @@ # Benefits over Objective-C - -**Safety and Reliability:** Swift includes features like optionals and type inference that reduce common programming errors and crashes. - -**Modern Syntax:** Swift’s concise and clean syntax improves readability and maintainability. - -**Performance:** Swift is designed for speed and efficiency, often outperforming Objective-C in benchmarks. - -**Interoperability:** Swift can easily coexist with Objective-C, allowing for a gradual transition of codebases. - -**Memory Management:** Automatic Reference Counting (ARC) in Swift handles memory management across both procedural and object-oriented code, reducing memory leaks. - -**Playgrounds:** Swift's interactive playgrounds provide a dynamic environment for testing and learning Swift code. + +Swift offers several advantages over Objective-C including type safety with optionals, modern syntax that reduces boilerplate, cleaner closure support, and better performance in many scenarios. Swift code is generally easier to read, write, and maintain. The language also benefits from active development through the Swift Evolution open-source process. Visit the following resources to learn more: -- [@article@Swift vs Objective-C](https://www.waldo.com/blog/swift-vs-objective-c) -- [@feed@Explore top posts about C Programming](https://app.daily.dev/tags/c?ref=roadmapsh) +- [@roadmap@Visit the Dedicated Swift & Swift UI Roadmap](https://roadmap.sh/swift-ui) +- [@article@Swift vs Objective-C](https://www.waldo.com/blog/swift-vs-objective-c) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/breakpoints@X0QavvwPVJU6sulafPVUK.md b/src/data/roadmaps/ios/content/breakpoints@X0QavvwPVJU6sulafPVUK.md index 13c17b7b8..ab681b6a5 100644 --- a/src/data/roadmaps/ios/content/breakpoints@X0QavvwPVJU6sulafPVUK.md +++ b/src/data/roadmaps/ios/content/breakpoints@X0QavvwPVJU6sulafPVUK.md @@ -1,19 +1,8 @@ # Breakpoints + +Breakpoints pause app execution at a specific line of code so the developer can inspect the current state of variables and the call stack. Xcode supports line breakpoints, symbolic breakpoints that trigger on a function name, and exception breakpoints that catch crashes automatically. Conditional breakpoints pause only when a specified expression evaluates to true. -Xcode debugger breakpoints are powerful tools for pausing program execution at specific points, allowing developers to inspect the application state and diagnose issues. Key features include: - -1. Line breakpoints: Set on specific code lines to pause execution. -2. Symbolic breakpoints: Trigger on function or method names. -3. Exception breakpoints: Pause when exceptions occur. -4. Conditional breakpoints: Only activate when certain conditions are met. -5. Action breakpoints: Perform custom actions when hit, like logging or running scripts. -6. Breakpoint navigator: Centralized management of all breakpoints. -7. Enable/disable options: Easily toggle breakpoints without removing them. -8. Breakpoint groups: Organize and manage sets of related breakpoints. - -Breakpoints can be set by clicking in the gutter of the source editor or through the Breakpoint Navigator. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Setting breakpoints to pause your running app](https://developer.apple.com/documentation/xcode/setting-breakpoints-to-pause-your-running-app) - [@article@How to add and use a breakpoint in XCode](https://www.delasign.com/blog/xcode-add-use-breakpoint/) diff --git a/src/data/roadmaps/ios/content/building-interfaces@YvuYJceeNNfLBpq2-3iiL.md b/src/data/roadmaps/ios/content/building-interfaces@YvuYJceeNNfLBpq2-3iiL.md index 012f780fa..7a2563e79 100644 --- a/src/data/roadmaps/ios/content/building-interfaces@YvuYJceeNNfLBpq2-3iiL.md +++ b/src/data/roadmaps/ios/content/building-interfaces@YvuYJceeNNfLBpq2-3iiL.md @@ -1,9 +1,9 @@ # Building Interfaces + +Building interfaces in SwiftUI involves composing views using container types. VStack arranges views vertically, HStack arranges them horizontally, and ZStack layers them. The declarative approach means the layout is described statically and SwiftUI handles rendering and updates as state changes. -SwiftUI is Apple's modern framework for building user interfaces across all Apple platforms using Swift. It employs a declarative syntax where UI is described using Swift code, defining what should appear rather than how to create it. Xcode provides real-time previews of the UI as you code, enhancing the development experience. SwiftUI uses property wrappers like `@State` for managing UI state, and offers a flexible layout system with VStack, HStack, and ZStack. Complex UIs are built by composing smaller, reusable views, and data flow between views is managed using `@Binding` and `@ObservedObject`. The framework provides chainable modifiers for customizing view appearance and behavior, easy-to-implement declarative animations, and built-in support for common gestures. SwiftUI simplifies UI development by reducing boilerplate code and offering a more intuitive way to create responsive, adaptive interfaces that can target iOS, macOS, watchOS, and tvOS from a single codebase. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@ZStack](https://developer.apple.com/documentation/swiftui/zstack) - [@official@VStack](https://developer.apple.com/documentation/swiftui/vstack) -- [@official@HStack](https://developer.apple.com/documentation/swiftui/hstack) +- [@official@HStack](https://developer.apple.com/documentation/swiftui/hstack) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/callback-hell@WhOpzFvv21QQV3aS6XbXr.md b/src/data/roadmaps/ios/content/callback-hell@WhOpzFvv21QQV3aS6XbXr.md index 42cafafee..3e47d7304 100644 --- a/src/data/roadmaps/ios/content/callback-hell@WhOpzFvv21QQV3aS6XbXr.md +++ b/src/data/roadmaps/ios/content/callback-hell@WhOpzFvv21QQV3aS6XbXr.md @@ -1,8 +1,8 @@ # Callback Hell + +Callback hell refers to deeply nested, hard-to-read code that results from chaining multiple asynchronous operations through callbacks. This pattern, sometimes called the pyramid of doom, was common in iOS development when completion handlers were the primary way to handle async work. Swift's async/await syntax resolves this by allowing sequential, readable async code. -Callback hell, also known as the pyramid of doom, is a common issue in asynchronous programming where multiple nested callbacks create code that is difficult to read, understand, and maintain. This problem typically arises when dealing with multiple asynchronous operations that depend on each other's results. As callbacks are nested within callbacks, the code structure becomes deeply indented, resembling a pyramid shape. This nesting not only hampers code readability but also makes error handling and flow control more complex. To mitigate callback hell, developers often employ techniques such as modularizing code, using named functions instead of anonymous closures, or adopting more advanced asynchronous patterns. Modern Swift development addresses this issue through the use of promises, futures, completion handlers, and most recently, the async/await pattern, which provides a more linear and readable approach to handling asynchronous operations. - -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Avoiding callback hell in Swift](https://swiftrocks.com/avoiding-callback-hell-in-swift) - [@article@Say Goodbye to Callback Hell: A Beginner’s Guide to Async/Await in Swift](https://medium.com/@asumahbanda3/say-goodbye-to-callback-hell-a-beginners-guide-to-async-await-in-swift-4c3230183218) diff --git a/src/data/roadmaps/ios/content/callbacks@qJEd7KU52xL_GRG3IQqhM.md b/src/data/roadmaps/ios/content/callbacks@qJEd7KU52xL_GRG3IQqhM.md index 2c93e0a36..a4eb375de 100644 --- a/src/data/roadmaps/ios/content/callbacks@qJEd7KU52xL_GRG3IQqhM.md +++ b/src/data/roadmaps/ios/content/callbacks@qJEd7KU52xL_GRG3IQqhM.md @@ -1,9 +1,7 @@ # Callbacks + +Callbacks are functions passed as arguments to be executed when an asynchronous operation completes. In Swift, callbacks are implemented as closures. They are used for network completion handlers, animation callbacks, and event notifications, particularly in code that predates Swift's async/await concurrency model. -Callbacks in Swift provide a mechanism for asynchronous communication between different parts of an application. They allow a function to pass control back to the caller once a task is completed, making them particularly useful for handling time-consuming operations or events that occur at unpredictable times. In Swift, callbacks are often implemented using closures, which are self-contained blocks of functionality that can be passed around and executed later. This approach is commonly used in network operations, user interface events, and any scenario where the result of an operation isn't immediately available. - -While simple to implement for basic use cases, callbacks can lead to complex nested structures (often referred to as "callback hell") in more intricate scenarios. To mitigate this, Swift offers more advanced patterns like completion handlers, promises, and async/await syntax, which provide cleaner ways to handle asynchronous operations while maintaining the core concept of passing control back to the caller upon completion. - -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Use callback in swift (UIKit)](https://medium.com/@ravenst/use-callback-in-swift-uikit-7d5a85d37c9e) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/capturing-values--memory-mgmt@S-D-PnHA7COd2Dp6U2XO4.md b/src/data/roadmaps/ios/content/capturing-values--memory-mgmt@S-D-PnHA7COd2Dp6U2XO4.md index 0a8c4faa4..ebe039627 100644 --- a/src/data/roadmaps/ios/content/capturing-values--memory-mgmt@S-D-PnHA7COd2Dp6U2XO4.md +++ b/src/data/roadmaps/ios/content/capturing-values--memory-mgmt@S-D-PnHA7COd2Dp6U2XO4.md @@ -1,8 +1,8 @@ # Capturing Values & Memory Mgmt. + +Closures capture references to the variables and constants from their surrounding context. When a closure captures a class instance, it holds a strong reference by default, which can create retain cycles if the instance also holds the closure. Capture lists using [weak self] or [unowned self] break these cycles and are a required pattern in iOS Swift development. -Capturing values in closures is a powerful feature in Swift that allows closures to access and retain variables from their surrounding context. When a closure captures a value, it creates a strong reference to that value, potentially extending its lifetime beyond its original scope. This behavior is crucial for maintaining state in asynchronous operations but can lead to memory management challenges if not handled carefully. Swift provides capture lists to explicitly define how values should be captured, allowing developers to specify weak or unowned references to avoid retain cycles. Proper management of captured values is essential for preventing memory leaks, especially in scenarios involving self-referential closures or delegate patterns. Understanding the implications of value capture and employing appropriate memory management techniques ensures efficient and leak-free use of closures in Swift applications, particularly in complex asynchronous and event-driven programming scenarios. - -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Capture lists in Swift](https://www.hackingwithswift.com/articles/179/capture-lists-in-swift-whats-the-difference-between-weak-strong-and-unowned-references) - [@article@Swift’s closure capturing mechanics](https://www.swiftbysundell.com/articles/swifts-closure-capturing-mechanics/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/carthage@tIHjjNTXJWcNgkO6TB9ea.md b/src/data/roadmaps/ios/content/carthage@tIHjjNTXJWcNgkO6TB9ea.md index cb3e7093b..92f21bd39 100644 --- a/src/data/roadmaps/ios/content/carthage@tIHjjNTXJWcNgkO6TB9ea.md +++ b/src/data/roadmaps/ios/content/carthage@tIHjjNTXJWcNgkO6TB9ea.md @@ -1,8 +1,8 @@ # Carthage + +Carthage is a decentralized dependency manager for iOS and macOS that builds frameworks from source and links them manually into the project. Unlike CocoaPods, Carthage does not modify the Xcode project file, giving developers full control over integration. Carthage has become less common as Swift Package Manager has matured. -Carthage is a decentralized dependency manager for iOS and macOS development, offering a lightweight alternative to CocoaPods. It focuses on building frameworks rather than integrating directly into projects, giving developers more control over their project structure. Carthage fetches and builds dependencies as specified in a Cartfile, creating standalone frameworks that can be easily integrated into Xcode projects. This approach keeps the project's structure intact and allows for easier version control. Carthage supports both Swift and Objective-C libraries and works well with dynamic frameworks. It's particularly favored for its simplicity and non-invasive nature, as it doesn't modify project files or create workspaces. While Carthage requires manual framework linking, which can be more time-consuming initially, it offers faster build times and more flexibility in managing dependencies. This tool is often preferred by developers who desire more control over their dependency integration process and project structure. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@opensource@carthage/carthage](https://github.com/Carthage/Carthage) -- [@course@Carthage - Getting Started](https://www.kodeco.com/7649117-carthage-tutorial-getting-started) \ No newline at end of file +- [@course@Carthage - Getting Started](https://www.kodeco.com/7649117-carthage-tutorial-getting-started) +- [@opensource@carthage/carthage](https://github.com/Carthage/Carthage) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/ci--cd@U4xE1enkZxUME0j0gutae.md b/src/data/roadmaps/ios/content/ci--cd@U4xE1enkZxUME0j0gutae.md index 3121c9471..2586126c8 100644 --- a/src/data/roadmaps/ios/content/ci--cd@U4xE1enkZxUME0j0gutae.md +++ b/src/data/roadmaps/ios/content/ci--cd@U4xE1enkZxUME0j0gutae.md @@ -1,9 +1,3 @@ # CI / CD - -Continuous Integration (CI) and Continuous Deployment (CD) are practices aimed at improving software development efficiency and quality by automating the integration and delivery processes. - -Continuous Integration (CI) involves automatically integrating code changes from multiple contributors into a shared repository several times a day. Each integration is verified by an automated build, allowing teams to detect and address issues early. CI tools like Jenkins, GitHub Actions, and Travis CI run automated tests and ensure that new code commits do not break the existing functionality. - -Continuous Deployment (CD) extends CI by automating the release of validated changes to production. Every change that passes the automated tests is automatically deployed to the production environment, ensuring that the software is always in a release-ready state. This practice reduces the time between development and release, allowing for faster delivery of features and updates. - -Together, CI/CD practices help teams achieve rapid, reliable, and repeatable software delivery, fostering a culture of continuous improvement and agility. \ No newline at end of file + +Continuous Integration and Continuous Delivery (CI/CD) for iOS automates building, testing, and distributing apps on every code change. CI/CD pipelines run on platforms like CircleCI, Jenkins, GitHub Actions, GitLab, and Azure DevOps. Automated pipelines catch regressions early, enforce code quality checks, and speed up the release process. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/circleci@tWxuFh0xDugdplnHt_G0e.md b/src/data/roadmaps/ios/content/circleci@tWxuFh0xDugdplnHt_G0e.md index c87e303cd..0730b6f8d 100644 --- a/src/data/roadmaps/ios/content/circleci@tWxuFh0xDugdplnHt_G0e.md +++ b/src/data/roadmaps/ios/content/circleci@tWxuFh0xDugdplnHt_G0e.md @@ -1,8 +1,8 @@ # CircleCI + +CircleCI is a cloud-based CI/CD platform that supports iOS development through macOS build environments with Xcode installed. It runs builds, executes test suites, and triggers Fastlane lanes for automated distribution. Pipelines are configured with YAML files and integrate with GitHub and Bitbucket repositories. -CircleCI is a cloud-based continuous integration and continuous deployment (CI/CD) platform that automates the software development process, allowing teams to build, test, and deploy code efficiently. It offers both cloud and on-premises solutions, providing flexibility for different project requirements and security needs. CircleCI supports the definition and management of complex workflows with multiple jobs and dependencies, enabling parallel execution to optimize build times. It integrates seamlessly with Docker, allowing developers to use containers to ensure consistent environments across builds. Configuration is managed through YAML files, which define build processes and make them easily maintainable and version-controlled. The platform also offers extensive integrations with various version control systems, deployment services, and notification tools. CircleCI automatically scales to handle multiple concurrent builds, making it suitable for growing teams and larger projects. Its robust feature set and ease of use make it an excellent choice for streamlining CI/CD processes and improving software delivery performance. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@CircleCI Website](https://circleci.com) - [@article@Deploy iOS applications](https://circleci.com/docs/deploy-ios-applications/) diff --git a/src/data/roadmaps/ios/content/closures@M9UlalPL47GoqhcyGsAPV.md b/src/data/roadmaps/ios/content/closures@M9UlalPL47GoqhcyGsAPV.md index 47fe5cbff..6240a2920 100644 --- a/src/data/roadmaps/ios/content/closures@M9UlalPL47GoqhcyGsAPV.md +++ b/src/data/roadmaps/ios/content/closures@M9UlalPL47GoqhcyGsAPV.md @@ -1,3 +1,3 @@ # Closures - -Callback closures in Swift are a powerful and flexible way to handle asynchronous operations and event-driven programming. These closures are functions passed as arguments to other functions, which can be executed once a specific task or operation is completed. They allow for non-blocking execution of code, enabling the program to continue running while waiting for long-running tasks to finish. Callback closures are particularly useful in scenarios like network requests, file I/O operations, or user interface events. Swift's syntax for closures makes them concise and easy to use, with features like trailing closure syntax and capture lists for managing memory. While callback closures offer great flexibility, they can lead to nested code structures in complex scenarios, which has led to the development of more advanced patterns like promises and async/await to manage asynchronous code more elegantly. \ No newline at end of file + +Closures are self-contained blocks of code that can capture and store references to values from the surrounding context. In Swift, closures are first-class types that can be passed as arguments, stored in variables, and returned from functions. They are the basis for callbacks, higher-order functions like map and filter, and completion handlers throughout the iOS SDK. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/cocoa-touch@leozxW-5fAOfkKbQM4FD1.md b/src/data/roadmaps/ios/content/cocoa-touch@leozxW-5fAOfkKbQM4FD1.md index b1e1ca6d7..73ed101c9 100644 --- a/src/data/roadmaps/ios/content/cocoa-touch@leozxW-5fAOfkKbQM4FD1.md +++ b/src/data/roadmaps/ios/content/cocoa-touch@leozxW-5fAOfkKbQM4FD1.md @@ -1,7 +1,3 @@ # Cocoa Touch - -The Cocoa Touch layer in iOS provides the key frameworks needed to create apps for iOS devices. It offers extensive support for various user interface elements, gestures, animations, and event handling, making it central to developing interactive and visually appealing applications. Key components include UIKit for managing the graphical user interface, Foundation for essential data and network access, and Core Motion for handling device motion data. Additionally, frameworks like GameKit, MapKit, MessageUI, EventKit, and AVFoundation extend functionality for gaming, mapping, communication, event management, and multimedia. - -Cocoa Touch is responsible for the seamless integration of user interfaces and multimedia, supporting touch-based input, complex animations, and gesture recognizers through UIKit. AVFoundation provides robust tools for handling audio and video, essential for media-rich applications. GameKit offers features for game development, while MapKit integrates mapping services. MessageUI enables in-app communication via email and messages, and EventKit manages calendar events and reminders. These frameworks collectively empower developers to create rich, interactive, and high-performing iOS applications. - -You can learn more in depth information on the elements of the Cocoa Touch layer further down the roadmap in the UI Design & Framework sections. \ No newline at end of file + +Cocoa Touch is the topmost layer of the iOS architecture and provides the frameworks developers interact with most directly, including UIKit, SwiftUI, MapKit, and GameKit. It handles touch input, notifications, multitasking, and high-level app structure. Most iOS app code is written against Cocoa Touch APIs. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/cocoapods@epr1sOEZIAOwlgb8bre7r.md b/src/data/roadmaps/ios/content/cocoapods@epr1sOEZIAOwlgb8bre7r.md index acf82adfd..001032a6a 100644 --- a/src/data/roadmaps/ios/content/cocoapods@epr1sOEZIAOwlgb8bre7r.md +++ b/src/data/roadmaps/ios/content/cocoapods@epr1sOEZIAOwlgb8bre7r.md @@ -6,4 +6,4 @@ Visit the following resources to learn more: - [@official@CocoaPods](https://cocoapods.org/) - [@video@How to install Cocoapods on Mac M1](https://www.youtube.com/watch?v=0EbUBgO681w) -- [@video@How to Fix Cocoapods Install Errors on an Apple Silicon Macs](https://www.youtube.com/watch?v=uZD2EQbBqPg) +- [@video@How to Fix Cocoapods Install Errors on an Apple Silicon Macs](https://www.youtube.com/watch?v=uZD2EQbBqPg) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/code-quality-tools@DVe8S6TjKcQ8LT5G-aMVa.md b/src/data/roadmaps/ios/content/code-quality-tools@DVe8S6TjKcQ8LT5G-aMVa.md index 78f7e890a..57dea4042 100644 --- a/src/data/roadmaps/ios/content/code-quality-tools@DVe8S6TjKcQ8LT5G-aMVa.md +++ b/src/data/roadmaps/ios/content/code-quality-tools@DVe8S6TjKcQ8LT5G-aMVa.md @@ -1,3 +1,3 @@ # Code Quality Tools - -Code quality tools in iOS development are essential for maintaining high standards of code cleanliness, efficiency, and maintainability. These tools automate the process of identifying potential issues, enforcing coding standards, and improving overall code quality. Popular options include SwiftLint, which checks Swift code for style and conventions; SonarQube, which provides comprehensive code analysis for bugs, vulnerabilities, and code smells; and Codebeat, offering automated code reviews. Static analysis tools like Clang Static Analyzer help detect bugs and security issues. Continuous integration platforms often integrate these tools, running checks automatically with each commit. Code coverage tools measure the extent of test coverage, while performance profilers like Instruments help optimize app efficiency. By incorporating these tools into the development workflow, teams can catch issues early, maintain consistent coding standards, and produce more robust, maintainable iOS applications. Regular use of code quality tools contributes significantly to reducing technical debt and improving long-term project health. \ No newline at end of file + +Code quality tools for iOS enforce consistent style and detect potential issues in Swift code through static analysis. SwiftLint, Tailor, and SwiftFormat are the main tools available. Integrating them into the Xcode build process or CI pipeline ensures consistent code quality across the team. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/combine-and-mvvm@pY_zaMcFpeFDLgVk2W0Vy.md b/src/data/roadmaps/ios/content/combine-and-mvvm@pY_zaMcFpeFDLgVk2W0Vy.md index 0bd7c97cb..8b34115f6 100644 --- a/src/data/roadmaps/ios/content/combine-and-mvvm@pY_zaMcFpeFDLgVk2W0Vy.md +++ b/src/data/roadmaps/ios/content/combine-and-mvvm@pY_zaMcFpeFDLgVk2W0Vy.md @@ -1,8 +1,8 @@ # Combine and MVVM + +Combine integrates naturally with the MVVM pattern. ViewModels expose @Published properties that emit state changes, and Views subscribe to those values to update the UI automatically. Combine operators handle data transformation, network logic, and combining multiple sources within the ViewModel, keeping the UI layer simple. -Combine and MVVM (Model-View-ViewModel) form a powerful combination in iOS development. Combine's reactive approach complements MVVM's separation of concerns. In this pairing, ViewModels use Combine publishers to expose data streams to Views, which subscribe to these streams for reactive UI updates. Models can publish changes through Combine, which ViewModels then process and transform. This setup allows for clean, declarative bindings between Views and ViewModels, reducing boilerplate code and improving testability. Combine's operators facilitate complex data transformations within ViewModels, while its handling of asynchronous operations simplifies tasks like network requests. - -Learn more from the following resoureces: +Visit the following resources to learn more: - [@article@MVVM Design Pattern with Combine Framework](https://medium.com/@mshcheglov/mvvm-design-pattern-with-combine-framework-on-ios-5ff911011b0b) - [@article@MVVM and Combine](https://betterprogramming.pub/uikit-mvvm-combine-912c80c02262) diff --git a/src/data/roadmaps/ios/content/combine@UzpdLLPs226N00c6weWRv.md b/src/data/roadmaps/ios/content/combine@UzpdLLPs226N00c6weWRv.md index 3f98c063d..d6780687c 100644 --- a/src/data/roadmaps/ios/content/combine@UzpdLLPs226N00c6weWRv.md +++ b/src/data/roadmaps/ios/content/combine@UzpdLLPs226N00c6weWRv.md @@ -1,9 +1,8 @@ # Combine -Combine is Apple's built-in framework for reactive programming, using the same publisher-subscriber pattern as most modern approaches to this issue. -Combine introduces the concept of a `Cancellable` (i.e. a subscription) and many different operators to use on these Cancellables. -When writing Combine code, developers will notice complex generic types. For this reason, type-erasure can be done through `AnyCancellable`. + +Combine is Apple's built-in framework for reactive programming, using the same publisher-subscriber pattern as most modern approaches to this issue. Combine introduces the concept of a `Cancellable` (i.e. a subscription) and many different operators to use on these Cancellables. When writing Combine code, developers will notice complex generic types. For this reason, type-erasure can be done through `AnyCancellable`. Visit the following resources to learn more: - [@official@Combine](https://developer.apple.com/documentation/combine) -- [@video@Understanding Combine](https://youtu.be/rz0yx0Qz2jE) +- [@video@Understanding Combine](https://youtu.be/rz0yx0Qz2jE) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/components@A1TFKVjGU5RbeTF_zxJlu.md b/src/data/roadmaps/ios/content/components@A1TFKVjGU5RbeTF_zxJlu.md index dacf78f8d..efadbb09e 100644 --- a/src/data/roadmaps/ios/content/components@A1TFKVjGU5RbeTF_zxJlu.md +++ b/src/data/roadmaps/ios/content/components@A1TFKVjGU5RbeTF_zxJlu.md @@ -1,8 +1,8 @@ # Components + +UIKit components are the built-in UI controls the framework provides, including UIButton, UILabel, UITextField, UISwitch, UISlider, UIImageView, and UITableView. Each component is a UIView subclass and can be customized through properties, subclassing, or delegation. -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: +Visit the following resources to learn more: - [@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/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/components@xkH7Llut6uP2-8iTMw76F.md b/src/data/roadmaps/ios/content/components@xkH7Llut6uP2-8iTMw76F.md index 1518ca2b9..e90059558 100644 --- a/src/data/roadmaps/ios/content/components@xkH7Llut6uP2-8iTMw76F.md +++ b/src/data/roadmaps/ios/content/components@xkH7Llut6uP2-8iTMw76F.md @@ -2,8 +2,8 @@ Components are built by composing primitive views like Text, Image, and Button, along with container views such as VStack and HStack. They can accept parameters for customization and use `@State` and `@Binding` for internal state management and data flow. SwiftUI's modifiers allow for styling and behavior adjustments. Components can be extracted into separate files for reusability across the app. This approach encourages a modular design, improving code organization and maintainability. -Learn more from the following resources: +Visit the following resources to learn more: -- [@article@SwiftUI Components](https://designcode.io/swiftui-handbook-components) - [@course@Building Reusable SwiftUI Components](https://peterfriese.github.io/Building-SwiftUI-Components-Tutorial/tutorials/tutorial-table-of-contents/) +- [@article@SwiftUI Components](https://designcode.io/swiftui-handbook-components) - [@video@Building SwiftUI Components](https://www.youtube.com/playlist?list=PLsnLd2esiGRTfzn8pq4ZMYyDsL8GEMZO8) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/concurrency-and-multithreading@fbloF-u4XwdHLmBS9flZm.md b/src/data/roadmaps/ios/content/concurrency-and-multithreading@fbloF-u4XwdHLmBS9flZm.md index a4021f3de..59d7e9b9d 100644 --- a/src/data/roadmaps/ios/content/concurrency-and-multithreading@fbloF-u4XwdHLmBS9flZm.md +++ b/src/data/roadmaps/ios/content/concurrency-and-multithreading@fbloF-u4XwdHLmBS9flZm.md @@ -1,3 +1,3 @@ # Concurrency and Multithreading - -Concurrency and multithreading in iOS development enable applications to perform multiple operations simultaneously, improving responsiveness and performance. iOS provides several mechanisms for managing concurrent tasks, including Grand Central Dispatch (GCD) and Operation queues. GCD offers a low-level API for dispatching tasks to concurrent queues, while Operation queues provide a higher-level, object-oriented approach. Swift's modern concurrency features, including async/await and actors, offer a more intuitive way to write asynchronous code, reducing complexity and potential threading issues. These tools allow developers to offload time-consuming tasks from the main thread, ensuring a smooth user interface. Proper use of concurrency involves careful management of shared resources to avoid race conditions and deadlocks. Understanding thread safety, queue priorities, and synchronization techniques is crucial for developing efficient and responsive iOS applications that can effectively utilize modern multi-core devices. \ No newline at end of file + +Concurrency and multithreading allow iOS apps to perform multiple operations simultaneously without blocking the main UI thread. iOS provides Grand Central Dispatch (GCD) and Operation Queues as the two main systems for managing concurrent work. Swift's async/await, introduced in Swift 5.5, is now the preferred approach for writing concurrent code. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/concurrency-gcd-asyncawait@aALIiAxKz4f7B_EYyhBCi.md b/src/data/roadmaps/ios/content/concurrency-gcd-asyncawait@aALIiAxKz4f7B_EYyhBCi.md index 53230df97..332d9ca18 100644 --- a/src/data/roadmaps/ios/content/concurrency-gcd-asyncawait@aALIiAxKz4f7B_EYyhBCi.md +++ b/src/data/roadmaps/ios/content/concurrency-gcd-asyncawait@aALIiAxKz4f7B_EYyhBCi.md @@ -1,5 +1,3 @@ # 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. \ No newline at end of file + +Concurrency in iOS allows multiple tasks to run in parallel to keep the UI responsive. Grand Central Dispatch (GCD) is the traditional approach, using dispatch queues to schedule work on background threads. Swift's async/await syntax, introduced in Swift 5.5, provides a more readable and structured way to write asynchronous code. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/concurrency@-aLGB3cDXZHIhVU3t-Ve4.md b/src/data/roadmaps/ios/content/concurrency@-aLGB3cDXZHIhVU3t-Ve4.md index 2f62947ed..df0137930 100644 --- a/src/data/roadmaps/ios/content/concurrency@-aLGB3cDXZHIhVU3t-Ve4.md +++ b/src/data/roadmaps/ios/content/concurrency@-aLGB3cDXZHIhVU3t-Ve4.md @@ -1,9 +1,9 @@ # Concurrency + +Swift's structured concurrency builds on async/await with additional primitives for parallel execution. async let runs multiple async operations concurrently, TaskGroup manages a dynamic set of concurrent child tasks, and actors protect shared mutable state from data races. The Swift concurrency model enforces safety through the Sendable protocol and actor isolation. -Swift's concurrency model centers on async/await syntax, allowing asynchronous code to be written in a clear, sequential manner. It employs actors to manage shared mutable state safely, and the Task API for handling concurrent work. Structured concurrency ensures proper task lifecycle management. The language also offers async sequences and streams for working with asynchronous data, and the Sendable protocol to guarantee thread-safe data sharing. This comprehensive approach enables developers to write efficient, safe concurrent code while minimizing common issues like race conditions and deadlocks. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Swift Documentation (How to interact)](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/concurrency/) - [@official@Apple Documentation (Signatures for interaction)](https://developer.apple.com/documentation/swift/concurrency) -- [@article@Concurrency bu Example](https://www.hackingwithswift.com/quick-start/concurrency) +- [@article@Concurrency bu Example](https://www.hackingwithswift.com/quick-start/concurrency) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/core-animation@KpcmuLWX0xAjz6ty4ebtB.md b/src/data/roadmaps/ios/content/core-animation@KpcmuLWX0xAjz6ty4ebtB.md index eed495bc8..fd2898756 100644 --- a/src/data/roadmaps/ios/content/core-animation@KpcmuLWX0xAjz6ty4ebtB.md +++ b/src/data/roadmaps/ios/content/core-animation@KpcmuLWX0xAjz6ty4ebtB.md @@ -2,7 +2,7 @@ Core Animation is a robust animation framework in iOS that enables developers to create smooth and visually engaging animations. It provides a simple yet powerful API for animating views and other visual elements, allowing for complex motion effects with minimal code. Core Animation handles the rendering and compositing of animated content efficiently, ensuring high performance and fluid user experiences in applications. -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Core Animation Documentation](https://developer.apple.com/documentation/quartzcore) - [@video@Introduction to Core Animation](https://www.youtube.com/watch?v=93bfh3GK79s) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/core-animation@_mRs6ctH0IsSSi-cwV2b8.md b/src/data/roadmaps/ios/content/core-animation@_mRs6ctH0IsSSi-cwV2b8.md index 62225e0ad..b44344a1a 100644 --- a/src/data/roadmaps/ios/content/core-animation@_mRs6ctH0IsSSi-cwV2b8.md +++ b/src/data/roadmaps/ios/content/core-animation@_mRs6ctH0IsSSi-cwV2b8.md @@ -2,6 +2,6 @@ Core Animation is a powerful framework in iOS that allows developers to create rich and interactive animations. It works by compositing layers, each representing a view, and uses hardware acceleration to ensure smooth animations. Core Animation simplifies the process of animating properties such as position, scale, and opacity, providing implicit and explicit animation techniques. It enhances the user interface experience by enabling complex visual effects, transitions, and animations with minimal impact on performance, making it essential for crafting visually appealing iOS applications. -Learn more from the following resources: +Visit the following resources to learn more: -- [@official@Core Animation Documentation](https://developer.apple.com/documentation/quartzcore) +- [@official@Core Animation Documentation](https://developer.apple.com/documentation/quartzcore) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/core-audio@4bAABCfTvxchS5C5NlAro.md b/src/data/roadmaps/ios/content/core-audio@4bAABCfTvxchS5C5NlAro.md index c553cee70..c6e4449a3 100644 --- a/src/data/roadmaps/ios/content/core-audio@4bAABCfTvxchS5C5NlAro.md +++ b/src/data/roadmaps/ios/content/core-audio@4bAABCfTvxchS5C5NlAro.md @@ -2,7 +2,7 @@ Core Audio is a low-level framework in iOS designed for handling audio. It provides developers with advanced capabilities for recording, processing, playing back, and streaming audio. Core Audio supports various audio formats and offers precise control over audio data, enabling tasks such as real-time audio manipulation, audio mixing, and effects processing. With its high-performance and low-latency features, Core Audio is ideal for professional audio applications and complex audio signal processing tasks. -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Core Audio Documentation](https://developer.apple.com/documentation/coreaudio) - [@article@Working with Core Audio](https://medium.com/@ios_guru/core-audio-for-working-with-audio-7c293382ffca) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/core-data@H4-Dp2WTA6HAZiFRQdLjx.md b/src/data/roadmaps/ios/content/core-data@H4-Dp2WTA6HAZiFRQdLjx.md index 1abdc6d72..726010cd7 100644 --- a/src/data/roadmaps/ios/content/core-data@H4-Dp2WTA6HAZiFRQdLjx.md +++ b/src/data/roadmaps/ios/content/core-data@H4-Dp2WTA6HAZiFRQdLjx.md @@ -1,9 +1,8 @@ # Core Data -Use Core Data to save your application’s permanent data for offline use, to cache temporary data, and to add undo functionality to your app on a single device. To sync data across multiple devices in a single iCloud account, Core Data automatically mirrors your schema to a CloudKit container. - -Through Core Data’s Data Model editor, you define your data’s types and relationships, and generate respective class definitions. Core Data can then manage object instances at runtime to provide the following features. + +Core Data is Apple's framework for persisting complex object graphs and relational data on iOS. It provides an abstraction layer over SQLite with tools for defining data models, fetching, filtering, and observing changes. Core Data supports undo/redo, background data operations, and CloudKit integration for syncing data across a user's devices. Visit the following resources to learn more: - [@official@CoreData](https://developer.apple.com/documentation/coredata/) -- [@video@iOS Core Data Quick Start](https://www.youtube.com/watch?v=O7u9nYWjvKk) +- [@video@iOS Core Data Quick Start](https://www.youtube.com/watch?v=O7u9nYWjvKk) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/core-graphics@kRE9xT3mT9Si4NwJr9yGi.md b/src/data/roadmaps/ios/content/core-graphics@kRE9xT3mT9Si4NwJr9yGi.md index c46989a64..76f0d1494 100644 --- a/src/data/roadmaps/ios/content/core-graphics@kRE9xT3mT9Si4NwJr9yGi.md +++ b/src/data/roadmaps/ios/content/core-graphics@kRE9xT3mT9Si4NwJr9yGi.md @@ -2,7 +2,7 @@ Core Graphics, also known as Quartz, is a powerful 2D graphics rendering framework in iOS. It provides essential functions for drawing shapes, images, and text, handling low-level graphic operations with precision and efficiency. Core Graphics supports advanced features like color management, path-based drawing, and anti-aliasing, enabling developers to create detailed and visually appealing graphics within their applications. -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Core Graphics Documentation](https://developer.apple.com/documentation/coregraphics) - [@video@Introduction to Core Graphics](https://www.youtube.com/watch?v=won0gA05ce0) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/core-image@6zE_M0_oVpwW0B9qFSRgP.md b/src/data/roadmaps/ios/content/core-image@6zE_M0_oVpwW0B9qFSRgP.md index d1162fdd0..29d7a3040 100644 --- a/src/data/roadmaps/ios/content/core-image@6zE_M0_oVpwW0B9qFSRgP.md +++ b/src/data/roadmaps/ios/content/core-image@6zE_M0_oVpwW0B9qFSRgP.md @@ -2,7 +2,7 @@ Core Image is a powerful framework in iOS for image processing and analysis. It provides a wide array of built-in filters for tasks such as enhancing photos, applying artistic effects, and performing face detection. Core Image leverages GPU acceleration to ensure high performance and real-time processing capabilities. With support for custom filters and flexible integration with other graphics technologies, Core Image enables developers to create complex visual effects and perform sophisticated image manipulations within their applications. -Learn more from the following resources: +Visit the following resources to learn more: -- [@official@Core Image Documentation](https://developer.apple.com/documentation/coreimage) -- [@course@Core Image Tutorial](https://www.kodeco.com/30195423-core-image-tutorial-getting-started) \ No newline at end of file +- [@course@Core Image Tutorial](https://www.kodeco.com/30195423-core-image-tutorial-getting-started) +- [@official@Core Image Documentation](https://developer.apple.com/documentation/coreimage) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/core-ml@7s9Elv80TbZX_-NZpyutj.md b/src/data/roadmaps/ios/content/core-ml@7s9Elv80TbZX_-NZpyutj.md index fbfa573d7..199a49ff2 100644 --- a/src/data/roadmaps/ios/content/core-ml@7s9Elv80TbZX_-NZpyutj.md +++ b/src/data/roadmaps/ios/content/core-ml@7s9Elv80TbZX_-NZpyutj.md @@ -1,7 +1,8 @@ # Core ML + Use `Core ML` to integrate machine learning models into your app. Core ML provides a unified representation for all models. Your app uses Core ML APIs and user data to make predictions, and to train or fine-tune models, all on a person’s device. Visit the following resources to learn more: - [@official@Core ML](https://developer.apple.com/documentation/coreml/) -- [@official@Create machine learning models for use in your app.](https://developer.apple.com/machine-learning/create-ml/) +- [@official@Create machine learning models for use in your app.](https://developer.apple.com/machine-learning/create-ml/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/core-os@IdGdLNgJI3WmONEFsMq-d.md b/src/data/roadmaps/ios/content/core-os@IdGdLNgJI3WmONEFsMq-d.md index a7985c52c..d77a9b95e 100644 --- a/src/data/roadmaps/ios/content/core-os@IdGdLNgJI3WmONEFsMq-d.md +++ b/src/data/roadmaps/ios/content/core-os@IdGdLNgJI3WmONEFsMq-d.md @@ -1,14 +1,10 @@ # Core OS - -The Core OS layer in iOS is the foundation upon which the entire operating system is built, providing essential low-level services that ensure the system’s security, performance, and efficiency. This layer includes the kernel, which manages system resources and hardware abstraction, and device drivers that facilitate communication between the OS and hardware. Core OS also encompasses security frameworks, such as the Secure Enclave for handling encryption keys and biometric data, and Keychain Services for secure storage of sensitive information. - -Core OS supports essential functionalities like the Apple File System (APFS), which offers features like encryption and snapshotting, efficient memory management, and robust networking capabilities. It also includes power management features to extend battery life, inter-process communication (IPC) mechanisms for multitasking, and core system libraries like libdispatch for concurrency. By providing these foundational services, Core OS ensures that higher-level software can operate efficiently and securely on iOS devices. + +Core OS is the bottom layer of the iOS architecture, sitting directly above the hardware. It provides the Darwin kernel, security frameworks, and low-level system interfaces. Frameworks at this level include Security, Accelerate for math and signal processing, and ExternalAccessory for communicating with hardware accessories. Visit the following resources to learn more: - [@article@Kernel API](https://developer.apple.com/documentation/kernel) - [@article@System Configuration](https://developer.apple.com/documentation/systemconfiguration) - [@article@Apple File System Guide](https://developer.apple.com/documentation/foundation/file_system/about_apple_file_system) -- [@article@Keychain Services](https://developer.apple.com/documentation/security/keychain_services) -- [@article@LibDispatch](https://developer.apple.com/documentation/dispatch) -- [@article@LibXPC](https://developer.apple.com/documentation/xpc) \ No newline at end of file +- [@article@Keychain Services](https://developer.apple.com/documentation/security/keychain_services) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/core-programming-concepts@mk02yV7_XHkgp2xdNIxaU.md b/src/data/roadmaps/ios/content/core-programming-concepts@mk02yV7_XHkgp2xdNIxaU.md index 9d24fc4e3..3116d3a05 100644 --- a/src/data/roadmaps/ios/content/core-programming-concepts@mk02yV7_XHkgp2xdNIxaU.md +++ b/src/data/roadmaps/ios/content/core-programming-concepts@mk02yV7_XHkgp2xdNIxaU.md @@ -1,9 +1,8 @@ # 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. +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: +Visit the following resources to learn more: - [@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) - +- [@article@What are the basic fundementals of programming?](https://www.educative.io/answers/what-are-the-basic-fundamental-concepts-of-programming) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/core-services@LHM7gNgTtfn_QDW-oQskD.md b/src/data/roadmaps/ios/content/core-services@LHM7gNgTtfn_QDW-oQskD.md index 70a09627c..c493dbdf2 100644 --- a/src/data/roadmaps/ios/content/core-services@LHM7gNgTtfn_QDW-oQskD.md +++ b/src/data/roadmaps/ios/content/core-services@LHM7gNgTtfn_QDW-oQskD.md @@ -1,16 +1,7 @@ # Core Services - -The Core Services layer in iOS provides essential system services that support app development by offering a wide range of fundamental frameworks and capabilities. These services are crucial for enabling basic app functionality such as data management, networking, location services, motion sensing, and web content integration. By leveraging these core frameworks, you can efficiently handle tasks like data storage and persistence, network communication, and user location tracking, ensuring their apps are robust, responsive, and capable of interacting with various hardware and software components. - -Core Services are responsible for managing fundamental utilities and services that underpin iOS applications. This includes providing efficient data management solutions, robust networking capabilities, precise location data, and motion sensing features. Additionally, they facilitate seamless integration and manipulation of web content within apps. + +Core Services is the second layer of the iOS architecture and provides fundamental system capabilities that apps depend on. It includes frameworks for networking, file access, data management, location, and iCloud. Higher-level frameworks in Cocoa Touch build on Core Services internally. Visit the following resources to learn more: -- [@article@Core Services Layer Overview](https://developer.apple.com/documentation/coreservices) -- [@article@Core Foundation](https://developer.apple.com/documentation/corefoundation) -- [@article@Core Data](https://developer.apple.com/documentation/coredata) -- [@article@Core Location](https://developer.apple.com/documentation/corelocation) -- [@article@CFNetwork](https://developer.apple.com/documentation/cfnetwork) -- [@article@Core Motion](https://developer.apple.com/documentation/coremotion) -- [@article@Foundation](https://developer.apple.com/documentation/foundation) -- [@article@WebKit](https://developer.apple.com/documentation/webkit) \ No newline at end of file +- [@article@Core Services Layer Overview](https://developer.apple.com/documentation/coreservices) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/data-binding@yR94uHs0SiSScU4gPBzfr.md b/src/data/roadmaps/ios/content/data-binding@yR94uHs0SiSScU4gPBzfr.md index 21dfe7605..b20f4410b 100644 --- a/src/data/roadmaps/ios/content/data-binding@yR94uHs0SiSScU4gPBzfr.md +++ b/src/data/roadmaps/ios/content/data-binding@yR94uHs0SiSScU4gPBzfr.md @@ -2,7 +2,7 @@ SwiftUI data binding is a mechanism that creates a two-way connection between a piece of data and a UI element. It uses the `@Binding` property wrapper to allow child views to share and modify data owned by parent views. Bindings ensure that changes in data are immediately reflected in the UI and vice versa. They are typically created using the `$` prefix on a `@State` property. This approach facilitates the flow of data through an app's view hierarchy, enabling reactive UI updates and maintaining a single source of truth. -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Binding](https://developer.apple.com/documentation/swiftui/binding) - [@official@Apple Tutorials: Passing data with bindings](https://developer.apple.com/tutorials/app-dev-training/passing-data-with-bindings) diff --git a/src/data/roadmaps/ios/content/data-persistence@6gfqFy3H6SLt06oJ1kt5A.md b/src/data/roadmaps/ios/content/data-persistence@6gfqFy3H6SLt06oJ1kt5A.md index 7af7efda5..415f52407 100644 --- a/src/data/roadmaps/ios/content/data-persistence@6gfqFy3H6SLt06oJ1kt5A.md +++ b/src/data/roadmaps/ios/content/data-persistence@6gfqFy3H6SLt06oJ1kt5A.md @@ -1,7 +1,7 @@ # Data Persistence + +Data persistence covers the different mechanisms iOS apps use to store data on-device across app sessions. Options include Core Data for complex object graphs, User Defaults for simple preferences, Keychain for sensitive credentials, SQLite for relational data, and the file system for arbitrary files. -Data persistence in iOS applications involves storing and retrieving data beyond the app's current runtime, ensuring information remains available across app launches and device restarts. Swift and iOS offer several mechanisms for data persistence, each suited to different needs and data complexities. Core Data provides a robust framework for managing and persisting large, structured datasets, offering features like data modeling, querying, and synchronization. For simpler data storage, UserDefaults is ideal for storing small amounts of key-value data. File system storage allows direct saving and loading of data to and from files in the app's sandbox. Keychain Services offer secure storage for sensitive information like passwords and tokens. SQLite databases can be used for more complex relational data storage needs. Additionally, CloudKit enables data synchronization across devices via iCloud. Choosing the appropriate persistence method depends on factors such as data structure, size, security requirements, and the need for synchronization across devices or with remote servers. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Apple Dev Training - Persisting Data](https://developer.apple.com/tutorials/app-dev-training/persisting-data) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/debug-navigator@VuWUsg05WmOoP_RJ5AXJO.md b/src/data/roadmaps/ios/content/debug-navigator@VuWUsg05WmOoP_RJ5AXJO.md index 3252f5e6c..f9f112907 100644 --- a/src/data/roadmaps/ios/content/debug-navigator@VuWUsg05WmOoP_RJ5AXJO.md +++ b/src/data/roadmaps/ios/content/debug-navigator@VuWUsg05WmOoP_RJ5AXJO.md @@ -1,20 +1,8 @@ # Debug Navigator + +The Debug Navigator appears during a debugging session and shows real-time data about the running app, including CPU, memory, disk, and network usage, as well as active threads and their states. It helps identify performance issues and excessive resource consumption without switching to a separate profiling tool. -The Xcode Debug Navigator is a powerful tool in the Navigator pane that provides detailed information about the running application during debugging sessions. Key features include: - -1. Process hierarchy: Displays all running processes and threads. -2. CPU and memory usage: Shows real-time performance metrics. -3. Disk activity: Monitors file system operations. -4. Network activity: Tracks network requests and responses. -5. Energy impact: Measures the app's energy consumption. -6. GPU usage: Monitors graphics processing utilization. -7. iCloud activity: Tracks iCloud-related operations. -8. Thread states: Visualizes the state of each thread (running, blocked, etc.). -9. Stacktrace view: Allows navigation through the call stack of selected threads. - -The Debug Navigator helps developers identify performance bottlenecks, memory leaks, and other runtime issues. It's particularly useful for optimizing app performance and troubleshooting complex multi-threaded scenarios. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Debugging](https://developer.apple.com/documentation/xcode/debugging) - [@article@Exploring Xcode's Debugging Tools](https://cocoacasts.com/debugging-applications-with-xcode-exploring-xcode-debugging-tools) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/debugging-techniques@OZZ3UnWN2gFflbM_WaJ8H.md b/src/data/roadmaps/ios/content/debugging-techniques@OZZ3UnWN2gFflbM_WaJ8H.md index ef6830d88..b7cdc6859 100644 --- a/src/data/roadmaps/ios/content/debugging-techniques@OZZ3UnWN2gFflbM_WaJ8H.md +++ b/src/data/roadmaps/ios/content/debugging-techniques@OZZ3UnWN2gFflbM_WaJ8H.md @@ -1,3 +1,3 @@ # Debugging Techniques - -Debugging techniques in iOS development include using Xcode’s integrated debugger, which allows developers to set breakpoints, inspect variables, and step through code to identify issues. Utilizing the LLDB (Low-Level Debugger) commands in the console helps examine program state and perform complex operations. Instruments, another powerful tool within Xcode, is used for profiling and identifying performance bottlenecks, memory leaks, and energy usage. Logging with NSLog or print statements can also provide insight into runtime behavior. Additionally, employing unit tests and running the application on real devices can help uncover device-specific issues and ensure code reliability. \ No newline at end of file + +Debugging in iOS involves identifying and resolving issues in app behavior, performance, and memory. Xcode provides a built-in debugger with breakpoints and variable inspection, and Instruments provides deep profiling for CPU, memory, energy, and network usage. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/declarative-syntax@QVg4_8EXeQBJbleryy8c1.md b/src/data/roadmaps/ios/content/declarative-syntax@QVg4_8EXeQBJbleryy8c1.md index ddaa152e6..764e8eb18 100644 --- a/src/data/roadmaps/ios/content/declarative-syntax@QVg4_8EXeQBJbleryy8c1.md +++ b/src/data/roadmaps/ios/content/declarative-syntax@QVg4_8EXeQBJbleryy8c1.md @@ -2,7 +2,7 @@ SwiftUI's declarative syntax allows developers to describe the desired UI state rather than the step-by-step process to achieve it. This approach uses Swift code to define what views should appear and how they should behave, with SwiftUI handling the underlying implementation details. Developers create views by combining and modifying smaller view components, using modifiers to adjust appearance and behavior. State management is integrated into this syntax, with UI automatically updating when state changes. -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Declarative and Imperative Programming using SwiftUI and UIKit](https://medium.com/@rmeji1/declarative-and-imperative-programming-using-swiftui-and-uikit-c91f1f104252) - [@article@Apple's SwiftUI Declarative Framework](https://www.linkedin.com/pulse/apples-swiftui-declarative-framework-vivek-singh/) diff --git a/src/data/roadmaps/ios/content/delegate-pattern@BtPYKd7RedHOLRATDKkpg.md b/src/data/roadmaps/ios/content/delegate-pattern@BtPYKd7RedHOLRATDKkpg.md index 921150317..9ef759ecc 100644 --- a/src/data/roadmaps/ios/content/delegate-pattern@BtPYKd7RedHOLRATDKkpg.md +++ b/src/data/roadmaps/ios/content/delegate-pattern@BtPYKd7RedHOLRATDKkpg.md @@ -1,8 +1,8 @@ # Delegate Pattern + +The delegate pattern is a core design pattern in iOS where one object delegates responsibility for certain behaviors to another through a protocol. UIKit uses delegation extensively, with UITableViewDelegate, UITextFieldDelegate, and URLSessionDelegate being common examples. Delegates allow customization of behavior without requiring subclassing. -The delegate pattern is a widely used design pattern in iOS development that facilitates communication between objects in a flexible and decoupled manner. It allows one object to delegate certain responsibilities or decisions to another object, typically through a protocol. This pattern is particularly useful for handling events or customizing behavior without creating tight dependencies between classes. In implementation, a delegate protocol defines methods that the delegating object can call, while the delegate object conforms to this protocol and provides specific implementations. This approach promotes loose coupling, enhances reusability, and allows for easy customization of component behavior. The delegate pattern is extensively used in UIKit for handling user interactions, data source management, and event callbacks, making it a fundamental concept in iOS app architecture and design. - -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Mastering Swift Delegates](https://www.dhiwise.com/post/mastering-swift-delegates-a-comprehensive-guide) - [@article@A Step-by-Step Guide to the Delegate Pattern in Swift](https://medium.com/@afonso.script.sol/a-step-by-step-guide-to-the-delegate-pattern-in-swift-91a28de1baf8) diff --git a/src/data/roadmaps/ios/content/dependency-manager@Tv8-WUcKiZMLHuunQwise.md b/src/data/roadmaps/ios/content/dependency-manager@Tv8-WUcKiZMLHuunQwise.md index 6fed1294a..64862aeb5 100644 --- a/src/data/roadmaps/ios/content/dependency-manager@Tv8-WUcKiZMLHuunQwise.md +++ b/src/data/roadmaps/ios/content/dependency-manager@Tv8-WUcKiZMLHuunQwise.md @@ -1,3 +1,3 @@ # Dependency Manager - -Dependency managers in iOS development are tools that automate the process of adding, updating, and managing third-party libraries and frameworks in Swift and Objective-C projects. These tools simplify the integration of external code, ensuring version compatibility and reducing manual setup errors. The most popular dependency managers for iOS are CocoaPods, Carthage, and Swift Package Manager (SPM). CocoaPods, the oldest and most widely used, integrates directly with Xcode projects and offers a vast library of pods. Carthage provides a more decentralized approach, building frameworks separately from the main project. Swift Package Manager, integrated into Xcode, is Apple's official solution, offering seamless integration with Swift projects. Each manager has its strengths, with developers choosing based on project needs, team preferences, and specific library support. Effective use of dependency managers streamlines development workflows, promotes code reuse, and helps maintain up-to-date, efficient codebases in iOS applications. \ No newline at end of file + +Dependency managers automate adding, updating, and removing third-party libraries in an iOS project. The three main options are Swift Package Manager, CocoaPods, and Carthage. Each has different trade-offs around integration complexity, build speed, and the breadth of available packages. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/dynamic-library@Lrb4HZYrZU7SJlbedZp7U.md b/src/data/roadmaps/ios/content/dynamic-library@Lrb4HZYrZU7SJlbedZp7U.md index aca3c10b7..52af8cf05 100644 --- a/src/data/roadmaps/ios/content/dynamic-library@Lrb4HZYrZU7SJlbedZp7U.md +++ b/src/data/roadmaps/ios/content/dynamic-library@Lrb4HZYrZU7SJlbedZp7U.md @@ -1,8 +1,8 @@ # Dynamic Library + +A dynamic library is a compiled binary loaded into memory at runtime rather than being embedded in the app binary at link time. On iOS, third-party dynamic libraries must be bundled inside the app's framework folder. Dynamic frameworks allow code and resources to be shared between an app and its extensions. -Dynamic libraries in iOS development are code modules that are loaded into an app's memory at runtime rather than being compiled into the app's executable. They are typically distributed as .dylib files or packaged within frameworks. Unlike static libraries, dynamic libraries remain separate from the app's main binary, allowing for more efficient memory usage and smaller app sizes. Multiple apps can share a single copy of a dynamic library in memory, reducing overall system resource consumption. This approach facilitates easier updates to the library without requiring a full app recompilation. In iOS, dynamic libraries are primarily used within frameworks, as Apple restricts the use of standalone dynamic libraries in App Store submissions. Dynamic frameworks offer benefits like code modularity, easier sharing of code between apps, and potential performance improvements through reduced launch times. However, they introduce a slight runtime overhead for library loading. The use of dynamic libraries in iOS is subject to Apple's guidelines and is generally recommended for larger, frequently updated codebases or when sharing code across multiple apps. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Overview of Dynamic Libraries](https://developer.apple.com/library/archive/documentation/DeveloperTools/Conceptual/DynamicLibraries/100-Articles/OverviewOfDynamicLibraries.html) -- [@article@Static Library vs Dynamic Library in iOS](https://pratheeshbennet.medium.com/static-library-vs-dynamic-library-in-ios-55478ed53a03) +- [@article@Static Library vs Dynamic Library in iOS](https://pratheeshbennet.medium.com/static-library-vs-dynamic-library-in-ios-55478ed53a03) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/dynamic-type@0nei6iwP4Pgi_j4vVi_Qt.md b/src/data/roadmaps/ios/content/dynamic-type@0nei6iwP4Pgi_j4vVi_Qt.md index ad1dfc808..e868b5dc6 100644 --- a/src/data/roadmaps/ios/content/dynamic-type@0nei6iwP4Pgi_j4vVi_Qt.md +++ b/src/data/roadmaps/ios/content/dynamic-type@0nei6iwP4Pgi_j4vVi_Qt.md @@ -1,7 +1,8 @@ # Dynamic Type + The Dynamic Type feature allows users to choose the size of textual content displayed on the screen. It helps users who need larger text for better readability. It also accommodates those who can read smaller text, allowing more information to appear on the screen. Apps that support Dynamic Type also provide a more consistent reading experience. Visit the following resources to learn more: - [@official@Dynamic Type](https://developer.apple.com/documentation/uikit/uifont/scaling_fonts_automatically/) -- [@official@WWDC24: Get started with Dynamic Type](https://www.youtube.com/watch?v=ZqDZjW9TpFw) +- [@official@WWDC24: Get started with Dynamic Type](https://www.youtube.com/watch?v=ZqDZjW9TpFw) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/editors@-4q7MFXaTmpR_39PTeWD8.md b/src/data/roadmaps/ios/content/editors@-4q7MFXaTmpR_39PTeWD8.md index 943fa84b9..fb4fe2a6f 100644 --- a/src/data/roadmaps/ios/content/editors@-4q7MFXaTmpR_39PTeWD8.md +++ b/src/data/roadmaps/ios/content/editors@-4q7MFXaTmpR_39PTeWD8.md @@ -1,17 +1,8 @@ # Editors + +Xcode provides different editor modes depending on the file being viewed. The standard editor shows a single file, the assistant editor displays two files side by side, and the version editor shows Git history for the current file. The editor area also hosts Interface Builder when a Storyboard or XIB file is open. -Xcode editors are the central workspace for code creation and modification. The main types include: - -1. Source Editor: For writing and editing code, featuring syntax highlighting, code completion, and inline documentation. -2. Interface Builder: A visual editor for designing user interfaces, supporting both Storyboards and XIB files. -3. Assistant Editor: Allows viewing related files side-by-side, useful for simultaneously editing header and implementation files. -4. Version Editor: For comparing and merging different versions of a file. -5. Property List Editor: A specialized editor for working with .plist files. -6. Core Data Model Editor: For designing and managing Core Data models. - -The Editor area supports multiple tabs and split views, enabling developers to work on multiple files simultaneously. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Creating a source editor extension](https://developer.apple.com/documentation/xcodekit/creating-a-source-editor-extension) - [@official@Source Editor](https://developer.apple.com/documentation/xcode/source-editor) diff --git a/src/data/roadmaps/ios/content/error-handling@N5ojp6bqgH074MPKYjCHV.md b/src/data/roadmaps/ios/content/error-handling@N5ojp6bqgH074MPKYjCHV.md index c2637d73d..4afc67eeb 100644 --- a/src/data/roadmaps/ios/content/error-handling@N5ojp6bqgH074MPKYjCHV.md +++ b/src/data/roadmaps/ios/content/error-handling@N5ojp6bqgH074MPKYjCHV.md @@ -1,8 +1,8 @@ # Error Handling + +Swift provides a structured error handling model using the throw, try, and catch keywords. Functions that can fail declare throws in their signature, and callers handle errors using do-catch blocks. Swift also supports the Result type for propagating errors through asynchronous APIs. -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: +Visit the following resources to learn more: - [@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/) diff --git a/src/data/roadmaps/ios/content/fastlane@_W3vb0b14FrWB2fH7DHC7.md b/src/data/roadmaps/ios/content/fastlane@_W3vb0b14FrWB2fH7DHC7.md index d1f17978c..09b148245 100644 --- a/src/data/roadmaps/ios/content/fastlane@_W3vb0b14FrWB2fH7DHC7.md +++ b/src/data/roadmaps/ios/content/fastlane@_W3vb0b14FrWB2fH7DHC7.md @@ -1,16 +1,8 @@ # FastLane + +Fastlane is an open-source automation tool for iOS development that handles repetitive tasks like building, testing, code signing, and uploading to App Store Connect. Workflows are defined in Ruby-based scripts called Fastfiles using reusable actions called lanes. Fastlane is widely used in iOS CI/CD pipelines to automate provisioning, screenshots, and App Store submissions. -Fastlane is an open-source platform designed to simplify and automate the deployment process of iOS (and Android) applications. It provides a suite of tools to streamline various tasks such as building, testing, and releasing apps. Key features of Fastlane include: - -1. Automated Build and Distribution: Automate the creation and distribution of beta builds through services like TestFlight or Google Play. -2. Continuous Integration: Integrate with CI/CD systems to ensure continuous testing and deployment. -3. Code Signing Management: Simplify and automate the management of certificates and provisioning profiles. -4. App Metadata Management: Automatically update app metadata, screenshots, and other related information on App Store Connect. -5. Error Reporting: Receive detailed logs and error reports to debug issues quickly. - -Fastlane uses a configuration file (Fastfile) where developers can define lanes for different workflows, making the deployment process more efficient and less error-prone. This tool is highly valuable for teams looking to maintain consistency and save time in their release processes. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@FastLane Website](https://fastlane.tools) - [@opensource@fastlane/fastlane](https://github.com/fastlane/fastlane) diff --git a/src/data/roadmaps/ios/content/file-system@_bkRbqVXKNCnRvEFCM6mN.md b/src/data/roadmaps/ios/content/file-system@_bkRbqVXKNCnRvEFCM6mN.md index 3083e60b1..4f1dcf8d9 100644 --- a/src/data/roadmaps/ios/content/file-system@_bkRbqVXKNCnRvEFCM6mN.md +++ b/src/data/roadmaps/ios/content/file-system@_bkRbqVXKNCnRvEFCM6mN.md @@ -1,8 +1,8 @@ # File System + +The iOS file system sandboxes each app's data into private directories. The Documents directory is for user-facing files that should be backed up, the Caches directory is for regenerable data, and the tmp directory is for temporary files that do not need to persist. Apps use FileManager to create, read, write, move, and delete files within their sandbox. -The iOS file system provides a structured way for apps to store and access data directly on the device. Each app operates within its own sandbox, a dedicated directory structure that isolates the app's data for security and privacy. Within this sandbox, apps can create, read, write, and organize files and directories. The system offers several key directories, including Documents for user-generated content, Library for app-specific data, and tmp for temporary files. File management in iOS is primarily handled through the FileManager class, which provides a comprehensive API for file and directory operations. When working with files, developers must consider factors such as data persistence across app updates, iCloud backup settings, and efficient management of storage space. The file system is particularly useful for storing larger datasets, binary files, or data that doesn't fit well into structured storage systems like Core Data or User Defaults. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@File System Basics](https://developer.apple.com/library/archive/documentation/FileManagement/Conceptual/FileSystemProgrammingGuide/FileSystemOverview/FileSystemOverview.html) - [@official@About File System](https://developer.apple.com/documentation/foundation/file_system/about_apple_file_system/) diff --git a/src/data/roadmaps/ios/content/frameworks--library@pZVPsgvCpP3zUgBM4i0CF.md b/src/data/roadmaps/ios/content/frameworks--library@pZVPsgvCpP3zUgBM4i0CF.md index 1daf14de9..77b7ce2bb 100644 --- a/src/data/roadmaps/ios/content/frameworks--library@pZVPsgvCpP3zUgBM4i0CF.md +++ b/src/data/roadmaps/ios/content/frameworks--library@pZVPsgvCpP3zUgBM4i0CF.md @@ -1,3 +1,3 @@ # Frameworks & Library - -Frameworks and libraries in iOS development are collections of reusable code that provide specific functionality, enhancing development efficiency and maintaining code consistency. Frameworks are more structured than libraries, offering a hierarchical directory that bundles code, resources, and documentation. They can include dynamic or static libraries, header files, and additional resources like images or localization files. iOS provides numerous built-in frameworks like UIKit, Foundation, and CoreData, which form the backbone of app development. Third-party frameworks expand functionality further, often distributed via dependency managers. Libraries, typically in the form of static or dynamic libraries, contain compiled code that can be linked into an app. They're generally simpler than frameworks but less self-contained. The choice between using a framework or a library often depends on the complexity of the functionality needed and how it integrates with the existing project structure. Effective use of frameworks and libraries can significantly reduce development time and improve code quality in iOS applications. \ No newline at end of file + +Frameworks and libraries are reusable packages of compiled code and resources that can be linked into iOS apps. Understanding the differences between XCFrameworks, static libraries, and dynamic libraries is important for packaging shared code, distributing SDKs, and managing binary dependencies. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/frameworks@PdzCQXZIivw3zCYPtokJV.md b/src/data/roadmaps/ios/content/frameworks@PdzCQXZIivw3zCYPtokJV.md index 3044b9379..3f3de663f 100644 --- a/src/data/roadmaps/ios/content/frameworks@PdzCQXZIivw3zCYPtokJV.md +++ b/src/data/roadmaps/ios/content/frameworks@PdzCQXZIivw3zCYPtokJV.md @@ -1,3 +1,3 @@ # Frameworks -Frameworks in iOS development are modular, reusable packages of code and resources that provide specific functionality to applications. They offer a hierarchical structure containing compiled code, header files, resources like images and localization files, and often documentation. iOS provides numerous built-in frameworks such as UIKit for user interface elements, Foundation for fundamental data types and collections, and Core Data for data management. These frameworks form the backbone of iOS app development, offering standardized and optimized implementations of common functionalities. Third-party frameworks extend this ecosystem, providing additional features and tools. Frameworks can be static or dynamic, with dynamic frameworks offering more flexibility in terms of memory usage and updates. The use of frameworks promotes code reuse, maintains consistency across projects, and often improves development efficiency. Effective utilization of both system and third-party frameworks is crucial for building robust, feature-rich iOS applications while minimizing development time and effort. \ No newline at end of file +Frameworks in iOS development are modular, reusable packages of code and resources that provide specific functionality to applications. They offer a hierarchical structure containing compiled code, header files, resources like images and localization files, and often documentation. iOS provides numerous built-in frameworks such as UIKit for user interface elements, Foundation for fundamental data types and collections, and Core Data for data management. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/functional-programming@Pj-hqRZUmwx1WhmTbLoFD.md b/src/data/roadmaps/ios/content/functional-programming@Pj-hqRZUmwx1WhmTbLoFD.md index 39bd8d966..5fba9d64a 100644 --- a/src/data/roadmaps/ios/content/functional-programming@Pj-hqRZUmwx1WhmTbLoFD.md +++ b/src/data/roadmaps/ios/content/functional-programming@Pj-hqRZUmwx1WhmTbLoFD.md @@ -2,8 +2,8 @@ Functional programming is a style of programming where code is written using pure functions, avoiding changing state and mutable data. It emphasizes the use of mathematical functions to process data, which leads to more predictable and bug-resistant code. This approach helps in writing concise, readable, and testable code. -Learn more from the following resources: +Visit the following resources to learn more: - [@video@Functional programming - A general introduction](https://www.youtube.com/watch?v=8z_bUIl_uPo) - [@video@Intro to Swift for Functional Programmers](https://www.youtube.com/watch?v=rYC-TnKoi40) -- [@feed@Explore top posts about Functional Programming](https://app.daily.dev/tags/functional-programming?ref=roadmapsh) +- [@feed@Explore top posts about Functional Programming](https://app.daily.dev/tags/functional-programming?ref=roadmapsh) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/gamekit@H5F9P5xeQiHhWhS6jEzp5.md b/src/data/roadmaps/ios/content/gamekit@H5F9P5xeQiHhWhS6jEzp5.md index 1f6aaba9d..baba4bf72 100644 --- a/src/data/roadmaps/ios/content/gamekit@H5F9P5xeQiHhWhS6jEzp5.md +++ b/src/data/roadmaps/ios/content/gamekit@H5F9P5xeQiHhWhS6jEzp5.md @@ -1,8 +1,8 @@ # GameKit + +GameKit is Apple's framework for adding social gaming features to iOS apps. It provides APIs for leaderboards, achievements, multiplayer matchmaking, and real-time game sessions through Game Center. GameKit handles authentication with the user's Apple ID and integrates with the native Game Center UI. -GameKit is a framework provided by Apple for iOS, macOS, and tvOS that facilitates the implementation of social gaming features. It offers a set of tools and APIs for integrating multiplayer functionality, leaderboards, achievements, and player authentication in games. GameKit simplifies the process of adding real-time multiplayer capabilities, allowing developers to create peer-to-peer connections or use Apple's Game Center servers for matchmaking. The framework provides APIs for managing leaderboards, enabling players to compare scores globally or among friends. It also supports a system for creating and tracking in-game achievements, enhancing player engagement. GameKit handles player authentication through Game Center, offering a unified gaming identity across Apple platforms. While primarily designed for games, some of GameKit's features, like peer-to-peer connectivity, can be useful in non-gaming apps as well. By leveraging GameKit, developers can create more interactive and socially engaging gaming experiences on Apple platforms without having to implement complex networking and social features from scratch. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@GameKit](https://developer.apple.com/documentation/gamekit) - [@article@How to integrate GameKit](https://medium.com/swlh/how-to-integrate-gamekit-ios-794061428197) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/gcd@aROcI1RucAyu-gHn-tVnj.md b/src/data/roadmaps/ios/content/gcd@aROcI1RucAyu-gHn-tVnj.md index d2a726731..8af10bc32 100644 --- a/src/data/roadmaps/ios/content/gcd@aROcI1RucAyu-gHn-tVnj.md +++ b/src/data/roadmaps/ios/content/gcd@aROcI1RucAyu-gHn-tVnj.md @@ -1,9 +1,9 @@ # GCD + +Grand Central Dispatch (GCD) is a C-based system for dispatching work to queues managed by the operating system. The main queue runs tasks on the main thread for UI updates, while serial and concurrent dispatch queues run background work. GCD is lightweight and efficient, and remains widely used alongside Swift's async/await model. -Grand Central Dispatch (GCD) is a powerful concurrency framework in iOS that simplifies the execution of parallel code. It abstracts the complexities of thread management, allowing developers to focus on the tasks to be performed rather than the underlying threading details. GCD uses a queue-based model where tasks are submitted to dispatch queues and executed by a managed pool of threads. It offers both serial and concurrent queues, enabling fine-grained control over task execution order and parallelism. The framework provides global queues with different quality of service levels, allowing prioritization of tasks based on their importance. GCD's dispatch groups facilitate the coordination of multiple asynchronous operations, while dispatch semaphores help manage access to shared resources. By leveraging GCD, iOS developers can efficiently distribute work across multiple cores, improve app responsiveness, and avoid common pitfalls associated with manual thread management, making it an essential tool for building high-performance, concurrent applications. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@official@Dispatch@](https://developer.apple.com/documentation/DISPATCH) +- [@official@Dispatch](https://developer.apple.com/documentation/DISPATCH) - [@article@Grand Central Dispatch (GCD) in iOS: The Developer's Guide](https://hackernoon.com/grand-central-dispatch-gcd-in-ios-the-developers-guide) - [@article@Grand Central Dispatch in iOS](https://medium.com/@knoo/gcd-grand-central-dispatch-in-ios-b2dd665cabd5) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/git@QifWR7WSJJTcTK2IfczxG.md b/src/data/roadmaps/ios/content/git@QifWR7WSJJTcTK2IfczxG.md index e2302e743..13d54e0a9 100644 --- a/src/data/roadmaps/ios/content/git@QifWR7WSJJTcTK2IfczxG.md +++ b/src/data/roadmaps/ios/content/git@QifWR7WSJJTcTK2IfczxG.md @@ -2,9 +2,9 @@ Git is a distributed version control system **(VCS)** used to track changes in source code during software development. It allows multiple developers to collaborate on a project by managing different versions of the code, enabling them to work on separate branches, merge changes, and keep a complete history of modifications. -Learn more from the following resources: +Visit the following resources to learn more: - [@roadmap@Visit Dedicated Git & GitHub Roadmap](https://roadmap.sh/git-github) -- [@article@Git by Example - Learn Version Control with Bite-sized Lessons](https://antonz.org/git-by-example/) -- [@video@Git & GitHub Crash Course For Beginners](https://www.youtube.com/watch?v=vA5TTz6BXhY) - [@course@Why use Git? (Interactive Lesson)](https://inter-git.com/lessons/introduction) +- [@article@Git by Example - Learn Version Control with Bite-sized Lessons](https://antonz.org/git-by-example/) +- [@video@Git & GitHub Crash Course For Beginners](https://www.youtube.com/watch?v=vA5TTz6BXhY) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/github-actions@LltERZaHsI-R_3O_3twpk.md b/src/data/roadmaps/ios/content/github-actions@LltERZaHsI-R_3O_3twpk.md index 0575ffacb..5eac1f525 100644 --- a/src/data/roadmaps/ios/content/github-actions@LltERZaHsI-R_3O_3twpk.md +++ b/src/data/roadmaps/ios/content/github-actions@LltERZaHsI-R_3O_3twpk.md @@ -1,9 +1,9 @@ # GitHub Actions + +GitHub Actions provides CI/CD automation directly within GitHub repositories. For iOS development, it uses macOS runners with Xcode installed to build apps, run tests, and trigger Fastlane workflows. Pipelines are defined in YAML workflow files and triggered by events like pull requests and pushes to main. -GitHub Actions is a CI/CD tool integrated directly into GitHub, allowing developers to automate workflows, such as building, testing, and deploying code directly from their repositories. It uses YAML files to define workflows, which can be triggered by various events like pushes, pull requests, or on a schedule. GitHub Actions supports a wide range of actions and integrations, making it highly customizable for different project needs. It provides a marketplace with reusable workflows and actions contributed by the community. With its seamless integration with GitHub, developers can take advantage of features like matrix builds, secrets management, and environment-specific configurations to streamline and enhance their development and deployment processes. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@GitHub Actions Documentation](https://docs.github.com/en/actions) -- [@video@How to build an iOS app with GitHub Actions](https://www.youtube.com/watch?v=Sd7YhlxZrJw) -- [@article@How to build an iOS app with GitHub Actions](https://www.andrewhoog.com/post/how-to-build-an-ios-app-with-github-actions-2023/) \ No newline at end of file +- [@article@How to build an iOS app with GitHub Actions](https://www.andrewhoog.com/post/how-to-build-an-ios-app-with-github-actions-2023/) +- [@video@How to build an iOS app with GitHub Actions](https://www.youtube.com/watch?v=Sd7YhlxZrJw) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/github@U_xXGSFF5iibQ4VkzPAWf.md b/src/data/roadmaps/ios/content/github@U_xXGSFF5iibQ4VkzPAWf.md index 331cd31f3..5ae6a4558 100644 --- a/src/data/roadmaps/ios/content/github@U_xXGSFF5iibQ4VkzPAWf.md +++ b/src/data/roadmaps/ios/content/github@U_xXGSFF5iibQ4VkzPAWf.md @@ -2,9 +2,8 @@ GitHub is a web-based platform that uses Git for version control and collaboration. It provides a centralized repository for hosting and managing Git repositories, allowing developers to share their code, collaborate on projects, and track issues. -Learn more from the following resources: +Visit the following resources to learn more: - [@official@GitHub Docs](https://docs.github.com/en) -- [@video@How to Use GitHub](https://www.youtube.com/watch?v=v_1iqtOnUMg) - [@article@What is GitHub](https://blog.hubspot.com/website/what-is-github-used-for) -- [@feed@Explore top posts about GitHub](https://app.daily.dev/tags/github?ref=roadmapsh) +- [@video@How to Use GitHub](https://www.youtube.com/watch?v=v_1iqtOnUMg) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/gitlab@VylaBSDAVFzveVfytI1Fz.md b/src/data/roadmaps/ios/content/gitlab@VylaBSDAVFzveVfytI1Fz.md index 5042dc52f..b2d124fdb 100644 --- a/src/data/roadmaps/ios/content/gitlab@VylaBSDAVFzveVfytI1Fz.md +++ b/src/data/roadmaps/ios/content/gitlab@VylaBSDAVFzveVfytI1Fz.md @@ -1,8 +1,8 @@ # GitLab + +GitLab CI/CD is GitLab's built-in automation platform that runs pipelines on code changes. For iOS development, it uses GitLab Runners configured on macOS to execute Xcode builds and test suites. GitLab CI is tightly integrated with the GitLab source code platform and merge request workflow. -GitLab is a comprehensive DevOps platform that provides source code management, CI/CD, and project management tools in a single application. It enables teams to manage their entire software development lifecycle, from planning and coding to testing, deployment, and monitoring. GitLab's built-in CI/CD capabilities allow developers to automate the build, test, and deployment processes using pipelines defined in YAML files. It integrates with various version control systems and supports Docker, Kubernetes, and other deployment environments. GitLab's features include issue tracking, code review, and merge request workflows, which enhance collaboration and code quality. The platform also offers robust security features, such as vulnerability management and dependency scanning, to ensure the safety and integrity of the codebase. GitLab can be hosted on-premises or used as a cloud-based service, providing flexibility and scalability for different project needs. Its all-in-one nature simplifies the development process, making it a popular choice for teams seeking to streamline their workflows and improve productivity. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@GitLab Website](https://about.gitlab.com/) - [@article@Tutorial: iOS CI/CD with GitLab](https://about.gitlab.com/blog/2023/06/07/ios-cicd-with-gitlab/) diff --git a/src/data/roadmaps/ios/content/graphql@9o7d3aN0YFfNNUeVoJrhs.md b/src/data/roadmaps/ios/content/graphql@9o7d3aN0YFfNNUeVoJrhs.md index 17feda2e4..b3fba8d4d 100644 --- a/src/data/roadmaps/ios/content/graphql@9o7d3aN0YFfNNUeVoJrhs.md +++ b/src/data/roadmaps/ios/content/graphql@9o7d3aN0YFfNNUeVoJrhs.md @@ -1,8 +1,8 @@ # GraphQL + +GraphQL is a query language for APIs that allows clients to request exactly the data they need in a single request. iOS apps interact with GraphQL APIs using libraries like Apollo iOS. GraphQL reduces over-fetching and under-fetching of data, making it efficient for mobile clients on limited bandwidth. -GraphQL is a query language and runtime for APIs, offering an alternative to traditional REST APIs in iOS development. It allows clients to request specific data structures, reducing over-fetching and under-fetching of data common in REST. In iOS apps, GraphQL enables more efficient network usage by allowing precise data requests tailored to UI needs. Developers typically use libraries like Apollo iOS to integrate GraphQL, which handles query execution, caching, and data normalization. GraphQL's strong typing system aligns well with Swift, facilitating type-safe API interactions. It supports real-time data with subscriptions, useful for live updates in iOS apps. While GraphQL offers flexibility and performance benefits, it requires a mindset shift from REST, including different approaches to error handling and caching. Implementing GraphQL in iOS involves crafting queries, managing the schema, and often requires coordination with backend teams to design effective GraphQL APIs that cater to mobile app needs. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@official@GraphQL Website](https://graphql.org/) -- [@official@GraphQL Roadmap](https://roadmap.sh/graphql] \ No newline at end of file +- [@roadmap@Visit the Dedicated GraphQL Roadmap](https://roadmap.sh/graphql) +- [@official@GraphQL Website](https://graphql.org/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/groups@42sfiLKrVCcnMMjR7TFn1.md b/src/data/roadmaps/ios/content/groups@42sfiLKrVCcnMMjR7TFn1.md index 3eba0d01e..8174dcf19 100644 --- a/src/data/roadmaps/ios/content/groups@42sfiLKrVCcnMMjR7TFn1.md +++ b/src/data/roadmaps/ios/content/groups@42sfiLKrVCcnMMjR7TFn1.md @@ -1,17 +1,7 @@ # Groups + +Groups in Xcode are virtual folders used to organize files within the Project Navigator without necessarily reflecting the file system directory structure. They keep large projects organized by feature or layer. Developers can create and rename groups and move files between them without affecting how Xcode locates or compiles those files. -Xcode groups are organizational tools used to structure and manage files within a project. They provide a logical hierarchy for arranging source code, resources, and other project files without affecting the actual file system structure. Key aspects of Xcode groups include: +Visit the following resources to learn more: -1. Visual organization: Groups appear as folders in the Project Navigator, helping developers categorize and locate files easily. -2. Flexible structure: Files can be organized into groups based on functionality, feature, or any other logical division. -3. No impact on build: Grouping doesn't affect how Xcode compiles or packages the application. -4. Color coding: Groups can be color-coded for quick visual identification. -5. Nested groups: Support for subgroups allows for more detailed organization. -6. References vs. folders: Groups can be created as simple references or as folder references that mirror the file system. -7. Drag-and-drop management: Easy reorganization of files and groups within the Project Navigator. - -Using groups effectively helps maintain clean, organized projects, especially as they grow in size and complexity. - -Learn more from the following resources: - -- [@official@Managing files and folders in your Xcode project](https://developer.apple.com/documentation/xcode/managing-files-and-folders-in-your-xcode-project) +- [@official@Managing files and folders in your Xcode project](https://developer.apple.com/documentation/xcode/managing-files-and-folders-in-your-xcode-project) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/healthkit@Jsu5f6QASpuvpky_W5q-O.md b/src/data/roadmaps/ios/content/healthkit@Jsu5f6QASpuvpky_W5q-O.md index d54d60be7..a974f6edb 100644 --- a/src/data/roadmaps/ios/content/healthkit@Jsu5f6QASpuvpky_W5q-O.md +++ b/src/data/roadmaps/ios/content/healthkit@Jsu5f6QASpuvpky_W5q-O.md @@ -1,11 +1,9 @@ # HealthKit -HealthKit is a powerful framework that allows developers to create health and fitness applications that can interact seamlessly with the iOS `Health app`. - -HealthKit provides a central repository for health and fitness data on iPhone and Apple Watch. With the user’s permission, apps communicate with the HealthKit store to access and share this data. +HealthKit is a powerful framework that allows developers to create health and fitness applications that can interact seamlessly with the iOS `Health app`. HealthKit provides a central repository for health and fitness data on iPhone and Apple Watch. With the user’s permission, apps communicate with the HealthKit store to access and share this data. Visit the following resources to learn more: - [@official@HealthKit](https://developer.apple.com/documentation/healthkit) - [@official@Creating a Mobility Health App](https://developer.apple.com/documentation/healthkit/creating_a_mobility_health_app) -- [@article@How I use Apple's Health app to track my fitness](https://www.pocket-lint.com/apps/news/apple/131130-apple-healthkit-and-health-app-how-they-work-and-the-medical-records-you-need/) +- [@article@How I use Apple's Health app to track my fitness](https://www.pocket-lint.com/apps/news/apple/131130-apple-healthkit-and-health-app-how-they-work-and-the-medical-records-you-need/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/hig@1I5eFKqFVBxWLAXfpgNXO.md b/src/data/roadmaps/ios/content/hig@1I5eFKqFVBxWLAXfpgNXO.md index aeb7a4ac1..92b5ee850 100644 --- a/src/data/roadmaps/ios/content/hig@1I5eFKqFVBxWLAXfpgNXO.md +++ b/src/data/roadmaps/ios/content/hig@1I5eFKqFVBxWLAXfpgNXO.md @@ -2,6 +2,6 @@ Human Interface Guidelines (HIG) by Apple are a set of recommendations and best practices for creating user interfaces on Apple devices. These guidelines help developers and designers create applications and interfaces that provide a high-quality experience and consistency with the Apple ecosystem. -Learn more from the following resources: +Visit the following resources to learn more: -- [@official@Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines) +- [@official@Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/history-and-why-swift@z4-1Gc95JKYAn2RPFc7hw.md b/src/data/roadmaps/ios/content/history-and-why-swift@z4-1Gc95JKYAn2RPFc7hw.md index c33ed4f9e..c7a323547 100644 --- a/src/data/roadmaps/ios/content/history-and-why-swift@z4-1Gc95JKYAn2RPFc7hw.md +++ b/src/data/roadmaps/ios/content/history-and-why-swift@z4-1Gc95JKYAn2RPFc7hw.md @@ -1,18 +1,9 @@ # History and Why Swift? - -**History** - -Swift was introduced by Apple in 2014 as a modern replacement for Objective-C. - -It was developed to address the limitations and complexities of Objective-C, providing a more powerful and user-friendly programming language. - -**Why Swift?** - -Swift offers improved performance, safety, and readability. It reduces common programming errors with features like optionals and type inference. - -Swift’s concise syntax and modern language constructs enhance developer productivity, making it easier to write and maintain code. Its open-source nature also allows a wider community to contribute and improve the language. + +Swift was introduced by Apple in 2014 to address the limitations of Objective-C in terms of safety, performance, and developer experience. It was designed to be faster, more expressive, and safer by eliminating entire classes of bugs through optionals and strong typing. Apple open-sourced Swift in 2015, and it has since become one of the most widely adopted programming languages. Visit the following resources to learn more: + +- [@roadmap@Visit the Dedicated Swift & Swift UI Roadmap](https://roadmap.sh/swift-ui) - [@official@About Swift](https://www.swift.org/about/) -- [@video@A Brief History](https://www.youtube.com/watch?v=4P_ZsOqELBo) -- [@feed@Explore top posts about Swift](https://app.daily.dev/tags/swift?ref=roadmapsh) +- [@video@A Brief History](https://www.youtube.com/watch?v=4P_ZsOqELBo) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/http--https@GjY5qCU1rjB0D58qHQtAR.md b/src/data/roadmaps/ios/content/http--https@GjY5qCU1rjB0D58qHQtAR.md index b9e340b4f..f22b9db9d 100644 --- a/src/data/roadmaps/ios/content/http--https@GjY5qCU1rjB0D58qHQtAR.md +++ b/src/data/roadmaps/ios/content/http--https@GjY5qCU1rjB0D58qHQtAR.md @@ -1,8 +1,8 @@ # HTTP / HTTPs + +HTTP and HTTPS are the application-layer protocols used for communication between iOS apps and web servers. iOS enforces App Transport Security (ATS) by default, requiring HTTPS for most network requests. Understanding request methods, status codes, headers, and the request-response cycle is fundamental to working with any iOS networking stack. -HTTP (Hypertext Transfer Protocol) and HTTPS (HTTP Secure) are fundamental protocols for data communication on the internet, extensively used in iOS app networking. HTTP facilitates request-response interactions between clients and servers, defining how messages are formatted and transmitted. HTTPS extends HTTP by encrypting the data exchange using SSL/TLS protocols, ensuring secure communication. In iOS development, URLSession handles both HTTP and HTTPS requests seamlessly, automatically managing the encryption for HTTPS connections. Developers typically use HTTPS for all network communications to protect user data and maintain privacy. iOS enforces App Transport Security (ATS) by default, requiring secure connections for network requests. When working with web APIs, iOS apps use these protocols to fetch data, submit forms, upload files, and perform various other network operations. Understanding HTTP methods (GET, POST, PUT, DELETE, etc.), status codes, and headers is crucial for effective API integration and troubleshooting in iOS app development. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@URLSession](https://developer.apple.com/documentation/foundation/urlsession) - [@article@Mastering URLSession in Swift](https://elamir.medium.com/mastering-urlsession-in-swift-a-comprehensive-guide-d3a3aa740f6e) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/ibactions@FspN4yiBF9aEN7_SlXUe1.md b/src/data/roadmaps/ios/content/ibactions@FspN4yiBF9aEN7_SlXUe1.md index 7e13183ad..9b1aa9eed 100644 --- a/src/data/roadmaps/ios/content/ibactions@FspN4yiBF9aEN7_SlXUe1.md +++ b/src/data/roadmaps/ios/content/ibactions@FspN4yiBF9aEN7_SlXUe1.md @@ -1,19 +1,8 @@ # IBActions + +IBActions connect UI controls in Interface Builder to methods in code that run when a user interacts with a control. Declaring a method with @IBAction allows it to be wired to a button, gesture recognizer, or other control in a Storyboard or XIB. When the user triggers the control, UIKit calls the connected method. -Xcode IBActions are methods that connect user interface elements to code, allowing the app to respond to user interactions. Key features include: +Visit the following resources to learn more: -1. Definition: Declared as methods in view controller classes. -2. Connection: Made by ctrl-dragging from UI elements to code in Interface Builder. -3. Purpose: Handle user interactions like button taps, slider changes, etc. -4. Method signature: Can include a sender parameter of the interacting UI element's type. -5. Multiple connections: One IBAction can be connected to multiple UI elements. -6. Event types: Can be set to respond to specific events (e.g., touch up inside, value changed). -7. Naming convention: Often prefixed with 'ib' for clarity. -8. Refactoring support: Xcode updates connections when renaming. - -IBActions provide a clean way to separate UI logic from business logic, enhancing code organization. They allow developers to centralize the handling of user interactions, making it easier to manage and modify app behavior in response to user input. - -Learn more from the following resources: - -- [@video@IBOutlet & IBAction](https://www.youtube.com/watch?v=ztPpThdBHT0) -- [@article@From outlets to actions: creating an IBAction](https://www.hackingwithswift.com/read/2/5/from-outlets-to-actions-creating-an-ibaction) \ No newline at end of file +- [@article@From outlets to actions: creating an IBAction](https://www.hackingwithswift.com/read/2/5/from-outlets-to-actions-creating-an-ibaction) +- [@video@IBOutlet & IBAction](https://www.youtube.com/watch?v=ztPpThdBHT0) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/iboutlets@tuUuLInq0p-nhehe2AqPg.md b/src/data/roadmaps/ios/content/iboutlets@tuUuLInq0p-nhehe2AqPg.md index 96eef7386..ee2109780 100644 --- a/src/data/roadmaps/ios/content/iboutlets@tuUuLInq0p-nhehe2AqPg.md +++ b/src/data/roadmaps/ios/content/iboutlets@tuUuLInq0p-nhehe2AqPg.md @@ -2,6 +2,6 @@ An outlet is a property of an object that references another object. The reference is archived through Interface Builder. The connections between the containing object and its outlets are reestablished every time the containing object is unarchived from its nib file. The containing object holds an outlet declared as a property with the type qualifier of IBOutlet and a weak option. -Learn more from the following resources: +Visit the following resources to learn more: -- [@official@Outlets](https://developer.apple.com/library/archive/documentation/General/Conceptual/CocoaEncyclopedia/Outlets/Outlets.html) +- [@official@Outlets](https://developer.apple.com/library/archive/documentation/General/Conceptual/CocoaEncyclopedia/Outlets/Outlets.html) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/implementing-delegates@z3AUN9u7EEqeKOqvLxf7D.md b/src/data/roadmaps/ios/content/implementing-delegates@z3AUN9u7EEqeKOqvLxf7D.md index 55a9bb76c..60dfd139b 100644 --- a/src/data/roadmaps/ios/content/implementing-delegates@z3AUN9u7EEqeKOqvLxf7D.md +++ b/src/data/roadmaps/ios/content/implementing-delegates@z3AUN9u7EEqeKOqvLxf7D.md @@ -1,8 +1,8 @@ # Implementing Delegates + +Implementing a delegate involves defining a protocol with required methods, adding a weak delegate property to the delegating class, and calling delegate methods at the appropriate times. The conforming class implements the protocol methods to respond to events. The weak reference is necessary to prevent retain cycles between the delegate and the delegating object. -Implementing delegates in Swift involves creating a protocol that defines the methods the delegate should implement, and then using this protocol to establish a communication channel between objects. The process typically begins with defining a protocol that outlines the required and optional methods. Next, a weak delegate property is declared in the delegating class to avoid retain cycles. The delegating class then calls the delegate methods at appropriate times, often in response to specific events or state changes. On the delegate side, the class conforms to the protocol and implements the required methods, providing custom behavior as needed. This implementation allows for flexible and reusable code, as the delegating object doesn't need to know the specific type of its delegate, only that it conforms to the protocol. - -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Delegates in Swift](https://medium.com/@muhammad.cse11/delegates-in-swift-ios-application-6dfb37897f9b) - [@article@What is a delegate in Swift](https://www.hackingwithswift.com/example-code/language/what-is-a-delegate-in-ios) diff --git a/src/data/roadmaps/ios/content/installing@R8LdFpfyS0MFYJuMLk8RG.md b/src/data/roadmaps/ios/content/installing@R8LdFpfyS0MFYJuMLk8RG.md index f2e1972a1..3a948652d 100644 --- a/src/data/roadmaps/ios/content/installing@R8LdFpfyS0MFYJuMLk8RG.md +++ b/src/data/roadmaps/ios/content/installing@R8LdFpfyS0MFYJuMLk8RG.md @@ -1,10 +1,8 @@ # Installing + +Installing Xcode is the first step in setting up an iOS development environment. Xcode is available for free from the Mac App Store and requires macOS and sufficient disk space. After installation, additional simulators and command-line tools can be added through Xcode settings. -The Xcode Integrated Development Environment (IDE) can only be installed on MacOS given it's nature as an iOS IDE. It can be installed simply like any application on the Mac, via the iStore using an Apple ID. +Visit the following resources to learn more: -If you wish to do any development using the Command Line Interface (CLI) you will need to install Xcode Command Line Tools via the `Xcode-select --install`. Popular CLI tools such as `clang`, `gcc` & `git` will require the installation of Xcode Command Line Tools. - -Learn more from the following resources: - -- [@video@How to Install Xcode on Mac](https://www.youtube.com/watch?v=F6QZ2atZrDw) - [@article@Xcode Command Line Tools Installation](https://mac.install.guide/commandlinetools/4) +- [@video@How to Install Xcode on Mac](https://www.youtube.com/watch?v=F6QZ2atZrDw) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/interface-builder@iMzYd8KUFnk6zqr4KecgX.md b/src/data/roadmaps/ios/content/interface-builder@iMzYd8KUFnk6zqr4KecgX.md index 87c84cb0b..45f15812b 100644 --- a/src/data/roadmaps/ios/content/interface-builder@iMzYd8KUFnk6zqr4KecgX.md +++ b/src/data/roadmaps/ios/content/interface-builder@iMzYd8KUFnk6zqr4KecgX.md @@ -1,20 +1,8 @@ # Interface Builder + +Interface Builder is the visual design tool embedded in Xcode for creating UI layouts without writing code. Developers drag UI elements onto a canvas, configure properties through the inspector, and set up constraints. Interface Builder generates XIB and Storyboard files that are compiled into the app bundle at build time. -Xcode Interface Builder is a visual design tool for creating user interfaces in iOS, macOS, watchOS, and tvOS applications. Key features include: - -1. Drag-and-drop UI design: Easily add and arrange UI elements on the canvas. -2. Storyboards: Create and manage multiple screens and their connections. -3. Auto Layout: Set up adaptive layouts using constraints. -4. Size classes: Design interfaces for different device sizes and orientations. -5. Custom controls: Integrate custom UI components alongside system-provided ones. -6. IBOutlets and IBActions: Connect UI elements to code. -7. Preview: Visualize designs on different devices and orientations. -8. Accessibility inspector: Ensure UI elements are accessible. -9. Localization: Manage multiple language versions of the interface. - -Interface Builder integrates seamlessly with Xcode's coding environment, allowing developers to switch between visual design and code implementation. It supports both .xib files for individual view controllers and .storyboard files for more complex, multi-screen interfaces. - -Learn more from the following resources: +Visit the following resources to learn more: - [@course@iOS Storyboards: Getting Started](https://www.kodeco.com/5055364-ios-storyboards-getting-started) - [@article@A bit about Interface Builder](https://medium.com/swlh/a-bit-about-interface-builder-ceffaf484580) diff --git a/src/data/roadmaps/ios/content/interface-overview@FwwqAchMC6qdnXbqg45he.md b/src/data/roadmaps/ios/content/interface-overview@FwwqAchMC6qdnXbqg45he.md index b597eadd8..5d999b5b2 100644 --- a/src/data/roadmaps/ios/content/interface-overview@FwwqAchMC6qdnXbqg45he.md +++ b/src/data/roadmaps/ios/content/interface-overview@FwwqAchMC6qdnXbqg45he.md @@ -1,13 +1,3 @@ # Interface overview - -Xcode's interface is designed for efficient iOS, macOS, watchOS, and tvOS development. The main window is divided into several key areas: - -1. Toolbar: Contains run buttons, scheme selector, and status display. -2. Navigator Area (left): Includes file navigator, search, issue navigator, and test navigator. -3. Editor Area (center): The main coding space, supporting multiple editors and Interface Builder. -4. Utility Area (right): Shows file inspectors, Quick Help, and Interface Builder libraries. -5. Debug Area (bottom): Displays console output and variables during debugging. -6. Assistant Editor: Allows viewing related files side-by-side. -7. Version Editor: For managing and comparing different versions of code. - -The interface is highly customizable, allowing developers to adjust layouts and show/hide areas as needed for their workflow. This integrated environment provides tools for coding, UI design, testing, and debugging all in one application. + +The Xcode interface is organized into a navigator panel on the left, an editor area in the center, an inspector panel on the right, and a debug area at the bottom. The toolbar at the top provides controls for running, stopping, and switching build schemes. Understanding the layout helps developers move efficiently across code, assets, and project settings. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/interoperability-with-swift@IAPzuN51xvrZJ5TFB23Q9.md b/src/data/roadmaps/ios/content/interoperability-with-swift@IAPzuN51xvrZJ5TFB23Q9.md index 383d2e0fe..44628dcdd 100644 --- a/src/data/roadmaps/ios/content/interoperability-with-swift@IAPzuN51xvrZJ5TFB23Q9.md +++ b/src/data/roadmaps/ios/content/interoperability-with-swift@IAPzuN51xvrZJ5TFB23Q9.md @@ -1,19 +1,8 @@ # Interoperability with Swift - -Swift is designed to work seamlessly with Objective-C, allowing developers to integrate and use both languages within the same project. This interoperability enables: - -**Gradual Migration:** Developers can incrementally migrate their codebase from Objective-C to Swift without needing a complete rewrite. - -**Mixed-Language Projects:** Swift and Objective-C files can coexist, and developers can call Objective-C code from Swift and vice versa. - -**Access to Existing Libraries:** Swift code can leverage existing Objective-C libraries and frameworks, ensuring continued use of valuable resources and tools. - -**Bridging Header:** A bridging header file allows Swift to interface with Objective-C code, facilitating communication between the two languages. - -**Compatibility:** Swift supports dynamic libraries, ensuring compatibility with existing Objective-C runtime and APIs. + +Swift and Objective-C can coexist in the same Xcode project through a bridging header mechanism. Swift code can call Objective-C APIs, and Objective-C code can use Swift classes marked with the @objc attribute. Interoperability is important when migrating legacy Objective-C projects to Swift incrementally. Visit the following resources to learn more: - [@official@Swift and Objective-C Interoperability](https://developer.apple.com/videos/play/wwdc2015/401/) -- [@video@Bridging Swift And Objective C](https://www.youtube.com/watch?v=Wp_-8tE85hE) -- [@feed@Explore top posts about Swift](https://app.daily.dev/tags/swift?ref=roadmapsh) +- [@video@Bridging Swift And Objective C](https://www.youtube.com/watch?v=Wp_-8tE85hE) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/ios-architecture@IduGSdUa2Fi7VFMLKgmsS.md b/src/data/roadmaps/ios/content/ios-architecture@IduGSdUa2Fi7VFMLKgmsS.md index 11a2b230b..372c00240 100644 --- a/src/data/roadmaps/ios/content/ios-architecture@IduGSdUa2Fi7VFMLKgmsS.md +++ b/src/data/roadmaps/ios/content/ios-architecture@IduGSdUa2Fi7VFMLKgmsS.md @@ -2,10 +2,9 @@ iOS architecture refers to the design principles and patterns used to build iOS applications. It focuses on how to structure code, manage data, and ensure a smooth user experience. These architectural patterns help developers create maintainable, scalable, and testable applications while following best practices specific to iOS development. Use cases of these architectures may vary according to the requirements of the application. For example, MVC is used for simple apps, while MVVM is considered when the app is large and complex. -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Model-View-Controller Pattern in swift (MVC) for Beginners](https://ahmedaminhassanismail.medium.com/model-view-controller-pattern-in-swift-mvc-for-beginners-35db8d479832) -- [@video@MVC Design Pattern Explained with Example](https://youtu.be/sbYaWJEAYIY?t=2) - [@article@MVVM in iOS Swift](https://medium.com/@zebayasmeen76/mvvm-in-ios-swift-6afb150458fd) -- [@video@MVVM Design Pattern Explained with Example](https://www.youtube.com/watch?v=sLHVxnRS75w) - +- [@video@MVC Design Pattern Explained with Example](https://youtu.be/sbYaWJEAYIY?t=2) +- [@video@MVVM Design Pattern Explained with Example](https://www.youtube.com/watch?v=sLHVxnRS75w) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/jenkins@TrblGyy81Oep2CBxoZkaf.md b/src/data/roadmaps/ios/content/jenkins@TrblGyy81Oep2CBxoZkaf.md index d4aaf6c82..a66cde57e 100644 --- a/src/data/roadmaps/ios/content/jenkins@TrblGyy81Oep2CBxoZkaf.md +++ b/src/data/roadmaps/ios/content/jenkins@TrblGyy81Oep2CBxoZkaf.md @@ -1,8 +1,8 @@ # Jenkins + +Jenkins is an open-source automation server used for iOS CI/CD, particularly in enterprise environments. It runs on macOS machines and can execute Xcode builds, run tests, and invoke Fastlane workflows. Jenkins requires more infrastructure setup than cloud-based alternatives but offers maximum flexibility in configuration. -Jenkins is an open-source automation server widely used for continuous integration (CI) and continuous deployment (CD). It automates the process of building, testing, and deploying software, enhancing productivity and consistency in development workflows. Jenkins supports an extensive range of plugins, enabling seamless integration with various version control systems, build tools, and deployment environments. One of its key features is the Pipeline as Code functionality, which allows developers to define complex build and deployment pipelines using a domain-specific language (DSL) in Groovy. This enables version control and easier maintenance of pipelines. Jenkins is highly extensible, with over 1,500 plugins available for integration with tools such as Git, Maven, Docker, and Kubernetes. It also supports distributed builds, allowing the load to be spread across multiple machines for improved performance. Automated testing is another crucial aspect, as Jenkins can run unit, integration, and UI tests as part of the CI process, helping to catch issues early. Jenkins' flexibility and extensive plugin ecosystem make it a popular choice for automating complex CI/CD workflows. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Jenkins Website](https://www.jenkins.io/) - [@article@What is Jenkins?](https://www.spiceworks.com/tech/devops/articles/what-is-jenkins/) diff --git a/src/data/roadmaps/ios/content/json--xml@WYV4YG_sLvC4S5ptFFdrF.md b/src/data/roadmaps/ios/content/json--xml@WYV4YG_sLvC4S5ptFFdrF.md index f9f3e6fef..1e1831fb2 100644 --- a/src/data/roadmaps/ios/content/json--xml@WYV4YG_sLvC4S5ptFFdrF.md +++ b/src/data/roadmaps/ios/content/json--xml@WYV4YG_sLvC4S5ptFFdrF.md @@ -1,3 +1,3 @@ # JSON / XML - -JSON (JavaScript Object Notation) and XML (eXtensible Markup Language) are widely used data interchange formats in iOS development, each with its own strengths and use cases. JSON has become increasingly popular due to its lightweight nature and ease of use, particularly in web services and APIs. Swift provides built-in support for JSON encoding and decoding through the Codable protocol, simplifying the process of converting between JSON data and Swift objects. XML, while less common in modern APIs, is still used in certain scenarios, especially for complex, hierarchical data structures. iOS provides the XMLParser class for parsing XML data, though it requires more manual handling compared to JSON. Both formats support data serialization and deserialization, allowing for easy storage and transmission of structured data. When working with external APIs or services, the choice between JSON and XML is often dictated by the service provider, but for internal data storage or custom APIs, JSON is generally preferred for its simplicity and performance in mobile environments. \ No newline at end of file + +JSON and XML are the two most common data interchange formats used when communicating with web services or storing structured data locally. iOS apps frequently parse JSON responses from REST APIs and serialize Swift models into JSON before sending them. XML is less common but still used in some legacy APIs and standards like RSS. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/keeping-updated-with-wwdc@fOOQurIL1w3PwH5Mep9x1.md b/src/data/roadmaps/ios/content/keeping-updated-with-wwdc@fOOQurIL1w3PwH5Mep9x1.md index dadb54ce4..5d2bdb78e 100644 --- a/src/data/roadmaps/ios/content/keeping-updated-with-wwdc@fOOQurIL1w3PwH5Mep9x1.md +++ b/src/data/roadmaps/ios/content/keeping-updated-with-wwdc@fOOQurIL1w3PwH5Mep9x1.md @@ -1,16 +1,9 @@ # Keeping Updated with WWDC - -WWDC (Worldwide Developers Conference) is an annual conference held by Apple for software developers. The main objectives of the conference are: - -1. **Presenting New Products**: Apple uses WWDC to announce new versions of its operating systems, such as iOS, macOS, watchOS, and tvOS, as well as new products and technologies. -2. **Developer Training**: The conference includes numerous technical sessions, labs, and workshops where developers can receive tips and guidance from Apple engineers on using the latest tools and technologies. -3. **Networking**: Developers from around the world gather at WWDC to share experiences and establish valuable connections. - -WWDC typically takes place in June and kicks off with a keynote presentation where Tim Cook and other Apple executives introduce major updates and new products. + +WWDC (Apple Worldwide Developers Conference) is Apple's annual developer event where new iOS, macOS, and framework announcements are made. Watching WWDC sessions, reading the associated documentation, and reviewing the release notes keeps iOS developers current with new APIs, deprecations, and best practices. Visit the following resources to learn more: - [@official@Worldwide Developers Conference](https://developer.apple.com/wwdc) - [@official@Apple Developer YouTube channel](https://www.youtube.com/@AppleDeveloper) -- [@official@WWDC videos collection by year](https://developer.apple.com/videos/) -- +- [@official@WWDC videos collection by year](https://developer.apple.com/videos/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/keychain@8v_eP0j85TnB33XyYAzrT.md b/src/data/roadmaps/ios/content/keychain@8v_eP0j85TnB33XyYAzrT.md index ea0cea7a6..c06d6a351 100644 --- a/src/data/roadmaps/ios/content/keychain@8v_eP0j85TnB33XyYAzrT.md +++ b/src/data/roadmaps/ios/content/keychain@8v_eP0j85TnB33XyYAzrT.md @@ -1,8 +1,8 @@ # Keychain + +The Keychain is iOS's secure, encrypted storage for sensitive data like passwords, tokens, and cryptographic keys. Data stored in the Keychain persists across app reinstalls and can be shared between apps from the same developer through Keychain Access Groups. Keychain access is managed through the Security framework's SecItem API. -The Keychain in iOS provides a secure, encrypted storage system for sensitive data such as passwords, authentication tokens, and other confidential information. It offers a higher level of security compared to other local storage options, as the data is encrypted and protected by the device's security features. The Keychain Services API allows apps to store, retrieve, and manage small chunks of data in a way that's significantly more secure than alternatives like User Defaults. Data stored in the Keychain persists across app reinstalls and can be shared between apps from the same developer. While powerful, working with the Keychain API can be complex, leading many developers to use wrapper libraries that simplify its usage. It's crucial to manage Keychain items carefully, considering aspects like accessibility settings and access groups, to ensure data remains secure while still being available when needed by the app. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Keychain Services](https://developer.apple.com/documentation/security/keychain_services) - [@article@Local storage in iOS: Keychain](https://medium.com/@omar.saibaa/local-storage-in-ios-keychain-668240e2670d) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/latest-ios-sdk@SBlLNfyWzzhdFNtNtkLet.md b/src/data/roadmaps/ios/content/latest-ios-sdk@SBlLNfyWzzhdFNtNtkLet.md index 2b214974f..2f832771c 100644 --- a/src/data/roadmaps/ios/content/latest-ios-sdk@SBlLNfyWzzhdFNtNtkLet.md +++ b/src/data/roadmaps/ios/content/latest-ios-sdk@SBlLNfyWzzhdFNtNtkLet.md @@ -1,5 +1,7 @@ # Latest iOS SDK + +The iOS SDK is updated each year with new APIs, deprecated frameworks, and changes to system behavior. New SDK features are announced at WWDC and documented in the release notes. Adopting the latest SDK allows apps to use new platform capabilities and ensures compliance with evolving App Store requirements. -The latest iOS SDK can be found in the following resources: +Visit the following resources to learn more: - [@official@Apple Developer Website](https://developer.apple.com/develop/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/latest-swift-version@e7qVpQeu2iQL0c9MOMCVe.md b/src/data/roadmaps/ios/content/latest-swift-version@e7qVpQeu2iQL0c9MOMCVe.md index 3d66e9dd2..dc192f738 100644 --- a/src/data/roadmaps/ios/content/latest-swift-version@e7qVpQeu2iQL0c9MOMCVe.md +++ b/src/data/roadmaps/ios/content/latest-swift-version@e7qVpQeu2iQL0c9MOMCVe.md @@ -1,6 +1,8 @@ # Latest Swift Version + +Apple releases new Swift versions annually alongside Xcode and iOS updates. New Swift versions introduce language features, performance improvements, and standard library additions. Tracking the Swift Evolution process and WWDC sessions on Swift helps developers adopt new capabilities and respond to deprecations promptly. -The latest Swift version can be found in the following resources: +Visit the following resources to learn more: - [@official@Official Swift Website](https://www.swift.org/download/) -- [@official@Swiftversion.net](https://swiftversion.net/) +- [@official@Swiftversion.net](https://swiftversion.net/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/lottie@i-T6GTqS0FZ_Llt5v4SvR.md b/src/data/roadmaps/ios/content/lottie@i-T6GTqS0FZ_Llt5v4SvR.md index 802d9083e..4ed66acb5 100644 --- a/src/data/roadmaps/ios/content/lottie@i-T6GTqS0FZ_Llt5v4SvR.md +++ b/src/data/roadmaps/ios/content/lottie@i-T6GTqS0FZ_Llt5v4SvR.md @@ -1,10 +1,9 @@ # Lottie -Lottie is a cross-platform library for iOS, macOS, tvOS, visionOS, Android, and Web that natively renders vector-based animations and art in realtime with minimal code. -Lottie loads and renders animations and vectors exported in the bodymovin JSON format. Bodymovin JSON can be created and exported from After Effects with bodymovin, Sketch with Lottie Sketch Export, and from Haiku. +Lottie is a cross-platform library for iOS, macOS, tvOS, visionOS, Android, and Web that natively renders vector-based animations and art in realtime with minimal code. Lottie loads and renders animations and vectors exported in the bodymovin JSON format. Bodymovin JSON can be created and exported from After Effects with bodymovin, Sketch with Lottie Sketch Export, and from Haiku. Visit the following resources to learn more: - [@official@Lottie for iOS](https://github.com/airbnb/lottie-ios) - [@article@How to Add Lottie Animations in iOS Apps](https://lottiefiles.com/blog/working-with-lottie-animations/how-to-add-lottie-animation-ios-app-swift) -- [@article@Lottie, with official support for SwiftUI](https://github.com/airbnb/lottie-ios/discussions/2189) +- [@article@Lottie, with official support for SwiftUI](https://github.com/airbnb/lottie-ios/discussions/2189) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/mapkit@XOXsjaQ-YyuAMpVCqH8KG.md b/src/data/roadmaps/ios/content/mapkit@XOXsjaQ-YyuAMpVCqH8KG.md index 747ee47ee..ff419ffe3 100644 --- a/src/data/roadmaps/ios/content/mapkit@XOXsjaQ-YyuAMpVCqH8KG.md +++ b/src/data/roadmaps/ios/content/mapkit@XOXsjaQ-YyuAMpVCqH8KG.md @@ -1,9 +1,9 @@ # MapKit + +MapKit is Apple's framework for embedding maps and location-based features into iOS apps. It provides interactive map views, annotation pins, overlays, turn-by-turn directions, and local place search. MapKit uses Apple Maps as its data source and integrates with Core Location for GPS access. -MapKit is a powerful framework provided by Apple for integrating interactive maps and location-based services into iOS, macOS, and tvOS applications. It offers a rich set of tools for displaying maps, adding annotations and overlays, handling user interactions, and performing geocoding and reverse geocoding. The framework provides customizable map views that support various map types, including standard, satellite, and hybrid views. Developers can easily add pins, custom annotations, and polylines to highlight specific locations or routes. MapKit integrates seamlessly with Core Location for handling real-time user positioning and region monitoring. It also supports features like 3D map views, flyover mode, and turn-by-turn navigation. The framework handles map rendering and data management efficiently, optimizing performance even when dealing with large numbers of map elements. By leveraging MapKit, developers can create sophisticated location-aware applications, from simple map displays to complex navigation and geospatial analysis tools, enhancing user experience with visual and interactive geographical data. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@MapKit](https://developer.apple.com/documentation/mapkit/) -- [@video@Meet MapKit for SwiftUI](https://developer.apple.com/videos/play/wwdc2023/10043/) -- [@article@Implement MapKit APIs](https://medium.com/simform-engineering/mapkit-swiftui-in-ios-17-1fec82c3bf00) \ No newline at end of file +- [@article@Implement MapKit APIs](https://medium.com/simform-engineering/mapkit-swiftui-in-ios-17-1fec82c3bf00) +- [@video@Meet MapKit for SwiftUI](https://developer.apple.com/videos/play/wwdc2023/10043/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/media@nGCG74_Xp_Ngt0u7PZnZl.md b/src/data/roadmaps/ios/content/media@nGCG74_Xp_Ngt0u7PZnZl.md index 5d553f500..b6be7976b 100644 --- a/src/data/roadmaps/ios/content/media@nGCG74_Xp_Ngt0u7PZnZl.md +++ b/src/data/roadmaps/ios/content/media@nGCG74_Xp_Ngt0u7PZnZl.md @@ -1,3 +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. +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. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/memory-management@tqbg8mBJfjuXacdMlIB_L.md b/src/data/roadmaps/ios/content/memory-management@tqbg8mBJfjuXacdMlIB_L.md index 7d1b6c84b..73f4d5b14 100644 --- a/src/data/roadmaps/ios/content/memory-management@tqbg8mBJfjuXacdMlIB_L.md +++ b/src/data/roadmaps/ios/content/memory-management@tqbg8mBJfjuXacdMlIB_L.md @@ -1,15 +1,10 @@ # Memory Management - -Memory management involves allocating memory for objects and freeing it after use. Manual Retain-Release (MRR) requires developers to explicitly manage memory using reference counting, provided by the Foundation class NSObject. Automatic Reference Counting (ARC) automates this process by inserting memory management method calls during compilation, though it still uses reference counting. In contrast, Garbage Collection (GC) automatically tracks object ownership and releases unreferenced objects, using a different mechanism than MRR and ARC, and is supported only in the macOS X runtime environment, not on iOS. - -> Beginning May 1, 2015, new Mac apps and app updates submitted to the Mac App Store may no longer use garbage collection, which was deprecated in OS X Mountain Lion. Instead, migrate your apps to Automatic Reference Counting, using the migration assistant in Xcode to help with this transition. Apps may continue to use retain/release for manual memory management. For more information, read the [Transitioning to ARC Release Notes](https://developer.apple.com/library/ios/releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html). + +iOS uses Automatic Reference Counting (ARC) to manage memory. ARC tracks how many strong references point to each object and deallocates it when the count drops to zero. Developers must understand strong, weak, and unowned references to avoid retain cycles, which cause memory leaks. Visit the following resources to learn more: - [@official@WWDC2021: ARC in Swift: Basics and beyond](https://developer.apple.com/videos/play/wwdc2021/10216/) - [@official@ARC(Automatic Reference Counting)](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting/) - [@official@About Memory Management](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/MemoryMgmt.html) -- [@official@Mac Apps That Use Garbage Collection Must Move to ARC](https://developer.apple.com/news/?id=02202015a) -- [@official@MemoryLayout](https://developer.apple.com/documentation/swift/memorylayout) -- [@official@Detect and diagnose memory issues](https://developer.apple.com/videos/play/wwdc2021/10180/) -- [@official@WWDC24: Analyze heap memory](https://www.youtube.com/watch?v=X_JYRz-Hd0o) +- [@official@Mac Apps That Use Garbage Collection Must Move to ARC](https://developer.apple.com/news/?id=02202015a) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/metal@5VguZoP4h40rTWkxWxaxU.md b/src/data/roadmaps/ios/content/metal@5VguZoP4h40rTWkxWxaxU.md index 950047297..38735ada2 100644 --- a/src/data/roadmaps/ios/content/metal@5VguZoP4h40rTWkxWxaxU.md +++ b/src/data/roadmaps/ios/content/metal@5VguZoP4h40rTWkxWxaxU.md @@ -2,7 +2,7 @@ Metal is a high-performance graphics and compute framework for iOS, macOS, and tvOS, designed by Apple. It enables developers to harness the full power of the GPU for advanced 3D graphics, complex visual effects, and data-parallel computation. Metal provides low-level, low-overhead access to the GPU, allowing for fine-tuned performance optimizations in applications and games. -Learn more from the following resources: +Visit the following resources to learn more: -- [@official@Metal Documentation](https://developer.apple.com/metal/) -- [@course@Metal Tutorial](https://metaltutorial.com/) \ No newline at end of file +- [@course@Metal Tutorial](https://metaltutorial.com/) +- [@official@Metal Documentation](https://developer.apple.com/metal/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/modals-and-navigation@jb89kQxDhZND3vQo0EH7r.md b/src/data/roadmaps/ios/content/modals-and-navigation@jb89kQxDhZND3vQo0EH7r.md index 36c56f0f8..68f874fd2 100644 --- a/src/data/roadmaps/ios/content/modals-and-navigation@jb89kQxDhZND3vQo0EH7r.md +++ b/src/data/roadmaps/ios/content/modals-and-navigation@jb89kQxDhZND3vQo0EH7r.md @@ -1,15 +1,9 @@ # Modals and Navigation + +Modal presentation in UIKit shows a view controller over the current content, typically for tasks that need the user's attention before they can continue. Modals are dismissed programmatically or by the user via drag or a dismiss button. Combining modal presentation with embedded navigation controllers creates flows like editing forms or settings sheets. -UIKit navigation stacks support both modal presentations and hierarchical navigation: - -Modal presentations temporarily overlay new content using present(_:animated:completion:). They're suitable for self-contained tasks or information that doesn't fit the main navigation hierarchy. - -Hierarchical navigation uses push and pop operations on the navigation stack. pushViewController(_:animated:) adds a new screen, while popViewController(animated:) returns to the previous one. - -These can be combined: a modal can contain its own navigation stack, or a screen in the main navigation can present a modal. This flexibility allows developers to create complex navigation patterns that maintain clarity and context for users, adapting to various app structures and user flow requirements. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@animate(withDuration:animations:completion:)](https://developer.apple.com/documentation/uikit/uiview/1622515-animate) -- [@officialpushViewController](https://developer.apple.com/documentation/uikit/uinavigationcontroller/1621887-pushviewcontroller) +- [@article@@officialpushViewController](https://developer.apple.com/documentation/uikit/uinavigationcontroller/1621887-pushviewcontroller) - [@video@UIKit Programmatic Navigation](https://www.youtube.com/watch?v=c0YSGtFmik8) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/mvc@a-QDI7Ei-B5BRHbicFcfG.md b/src/data/roadmaps/ios/content/mvc@a-QDI7Ei-B5BRHbicFcfG.md index b27f70817..33a82db3f 100644 --- a/src/data/roadmaps/ios/content/mvc@a-QDI7Ei-B5BRHbicFcfG.md +++ b/src/data/roadmaps/ios/content/mvc@a-QDI7Ei-B5BRHbicFcfG.md @@ -1,11 +1,9 @@ # MVC - -The Model-View-Controller (MVC) design pattern assigns objects in an application one of three roles: model, view, or controller. The pattern defines not only the roles objects play in the application, it defines the way objects communicate with each other. Each of the three types of objects is separated from the others by abstract boundaries and communicates with objects of the other types across those boundaries. The collection of objects of a certain MVC type in an application is sometimes referred to as a layer—for example, model layer. - -MVC is central to a good design for a Cocoa application. The benefits of adopting this pattern are numerous. Many objects in these applications tend to be more reusable, and their interfaces tend to be better defined. Applications having an MVC design are also more easily extensible than other applications. Moreover, many Cocoa technologies and architectures are based on MVC and require that your custom objects play one of the MVC roles + +MVC (Model-View-Controller) is the architectural pattern used by UIKit and historically recommended by Apple for iOS apps. The Model holds data and business logic, the View displays content, and the Controller mediates between them. In practice, UIKit view controllers tend to accumulate too much responsibility, a problem known as Massive View Controller. Visit the following resources to learn more: -- [@offical@Model-View-Controller](https://developer.apple.com/library/archive/documentation/General/Conceptual/DevPedia-CocoaCore/MVC.html) -- [@offical@Model-View-Controller](https://developer.apple.com/library/archive/documentation/General/Conceptual/CocoaEncyclopedia/Model-View-Controller/Model-View-Controller.html) -- [@article@MVC in iOS – A Modern Approach](https://www.kodeco.com/1000705-model-view-controller-mvc-in-ios-a-modern-approach) +- [@article@Model-View-Controller](https://developer.apple.com/library/archive/documentation/General/Conceptual/DevPedia-CocoaCore/MVC.html) +- [@article@Model-View-Controller](https://developer.apple.com/library/archive/documentation/General/Conceptual/CocoaEncyclopedia/Model-View-Controller/Model-View-Controller.html) +- [@article@MVC in iOS – A Modern Approach](https://www.kodeco.com/1000705-model-view-controller-mvc-in-ios-a-modern-approach) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/mvp@lVNrnUK6p4eifKRVSnOje.md b/src/data/roadmaps/ios/content/mvp@lVNrnUK6p4eifKRVSnOje.md index ff3768906..a9c903d30 100644 --- a/src/data/roadmaps/ios/content/mvp@lVNrnUK6p4eifKRVSnOje.md +++ b/src/data/roadmaps/ios/content/mvp@lVNrnUK6p4eifKRVSnOje.md @@ -1,19 +1,8 @@ # MVP + +MVP (Model-View-Presenter) improves on MVC by separating UIKit view controllers into a passive View and a Presenter that contains all UI logic. The View delegates user interactions to the Presenter, which processes them and updates the View through a protocol-based interface. Moving logic out of the view controller makes it much easier to unit test. -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: +Visit the following resources to learn more: - [@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) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/mvvm-c@iLT2jAkQg-Ex0zSLquNfl.md b/src/data/roadmaps/ios/content/mvvm-c@iLT2jAkQg-Ex0zSLquNfl.md index bdf3a49d2..c8716e793 100644 --- a/src/data/roadmaps/ios/content/mvvm-c@iLT2jAkQg-Ex0zSLquNfl.md +++ b/src/data/roadmaps/ios/content/mvvm-c@iLT2jAkQg-Ex0zSLquNfl.md @@ -1,14 +1,8 @@ # MVVM-C + +MVVM-C extends the MVVM pattern by adding a Coordinator component that manages navigation between screens. Coordinators handle routing logic that would otherwise live in view controllers or ViewModels, making navigation testable and reusable. This separation is particularly valuable in apps with complex conditional navigation flows. -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: +Visit the following resources to learn more: -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) \ No newline at end of file +- [@article@iOS Architecture: MVVM-C, Introduction](https://medium.com/sudo-by-icalia-labs/ios-architecture-mvvm-c-introduction-1-6-815204248518) +- [@video@Everything you need to know about client arthitecture patterns](https://www.youtube.com/watch?v=I5c7fBgvkNY) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/mvvm@taTxZw2c3xS18JOwgkNHM.md b/src/data/roadmaps/ios/content/mvvm@taTxZw2c3xS18JOwgkNHM.md index 9d8dfc9d1..cfa412bb5 100644 --- a/src/data/roadmaps/ios/content/mvvm@taTxZw2c3xS18JOwgkNHM.md +++ b/src/data/roadmaps/ios/content/mvvm@taTxZw2c3xS18JOwgkNHM.md @@ -1,18 +1,10 @@ # MVVM + +MVVM (Model-View-ViewModel) separates the UI layer from business logic using a ViewModel that exposes observable state. The View binds to the ViewModel and updates automatically when state changes, using Combine, RxSwift, or Swift's observation framework. MVVM is widely adopted in iOS development and works well with both UIKit and SwiftUI. -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: +Visit the following resources to learn more: -**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@https://www.youtube.com/watch?v=-xTqfilaYow](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) +- [@article@MVVM - Microsoft](https://learn.microsoft.com/en-us/dotnet/architecture/maui/mvvm) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/navigation-controllers-segues@tUbMr1pGlw4JwMuW311JJ.md b/src/data/roadmaps/ios/content/navigation-controllers-segues@tUbMr1pGlw4JwMuW311JJ.md index d3d4cb608..ab077d3b0 100644 --- a/src/data/roadmaps/ios/content/navigation-controllers-segues@tUbMr1pGlw4JwMuW311JJ.md +++ b/src/data/roadmaps/ios/content/navigation-controllers-segues@tUbMr1pGlw4JwMuW311JJ.md @@ -1,12 +1,8 @@ # Navigation Controllers, Segues + +UINavigationController manages a stack of view controllers with a navigation bar at the top. Segues are the transitions between view controllers defined in a Storyboard, triggered by user interaction or called programmatically. The prepare(for:sender:) method is used to pass data to the destination view controller before a segue executes. -UIKit Navigation Controllers and Segues are key components for managing app navigation: +Visit the following resources to learn more: -Navigation Controllers (`UINavigationController`) manage a stack of view controllers, providing a hierarchical interface for navigating content. They handle push and pop transitions between screens, maintain a navigation bar, and support back-navigation functionality. - -Segues are visual connections between view controllers in storyboards, defining transitions between scenes. They can be triggered programmatically or through user interactions. Types include push, modal, and custom segues. Segues simplify the process of passing data between view controllers during transitions. - -Learn more from the following resources: - -- [@video@How to Nav Bar Programmatically](https://www.youtube.com/watch?v=wcN3-E1_ZxU) -- [@official@UINavigationController](https://developer.apple.com/documentation/uikit/uinavigationcontroller) \ No newline at end of file +- [@official@UINavigationController](https://developer.apple.com/documentation/uikit/uinavigationcontroller) +- [@video@How to Nav Bar Programmatically](https://www.youtube.com/watch?v=wcN3-E1_ZxU) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/navigation-stacks@TLm70PlTI0K3Odn1iYxWX.md b/src/data/roadmaps/ios/content/navigation-stacks@TLm70PlTI0K3Odn1iYxWX.md index ca0cc525a..5ac2f07bd 100644 --- a/src/data/roadmaps/ios/content/navigation-stacks@TLm70PlTI0K3Odn1iYxWX.md +++ b/src/data/roadmaps/ios/content/navigation-stacks@TLm70PlTI0K3Odn1iYxWX.md @@ -1,11 +1,8 @@ # Navigation Stacks - -iOS 16 introduced a new concept of navigating through SiwftUI apps: NavigationStack. -NavigationStack is data-driven, meaning that you specify navigationDestinations for each data type (models) that your app supports. -These destinations are defined once for each NavigationStack and are valid throughout the app. -Navigation itself is handled through the NavigationLink View, which allows setting a label and a value (your model). + +Navigation stacks in SwiftUI are managed by NavigationStack (iOS 16+), which maintains a path representing the current navigation state. Views are pushed onto the stack by navigating to a value, and the stack handles the back button automatically. The state-driven model enables programmatic navigation and full deep link support. Visit the following resources to learn more: - [@official@NavigationStack](https://developer.apple.com/documentation/swiftui/navigationstack) -- [@video@NavigationStack](https://www.youtube.com/watch?v=DMsALlhObNk) +- [@video@NavigationStack](https://www.youtube.com/watch?v=DMsALlhObNk) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/navigation-stacks@mUMDZsgzCB6cs_K6pfUY1.md b/src/data/roadmaps/ios/content/navigation-stacks@mUMDZsgzCB6cs_K6pfUY1.md index 409008464..2a3157657 100644 --- a/src/data/roadmaps/ios/content/navigation-stacks@mUMDZsgzCB6cs_K6pfUY1.md +++ b/src/data/roadmaps/ios/content/navigation-stacks@mUMDZsgzCB6cs_K6pfUY1.md @@ -1,3 +1,3 @@ # Navigation Stacks - -UIKit Navigation Stacks, managed by UINavigationController, provide a hierarchical way to organize content in iOS apps. The stack operates on a last-in-first-out basis, where view controllers are pushed onto or popped from the top. The root view controller remains at the bottom, while subsequent screens are added above it. This structure allows for intuitive drill-down interfaces and easy back-navigation. Navigation stacks automatically handle transitions between view controllers, maintain a navigation bar with titles and back buttons, and can be customized for specific navigation patterns. They are fundamental to creating depth in app navigation, enabling users to traverse complex information hierarchies efficiently. \ No newline at end of file + +The navigation stack in UIKit is managed by UINavigationController using a push-pop model. View controllers are pushed onto the stack when navigating forward and popped when the user taps the Back button or calls popViewController. The navigation bar automatically reflects the current top of the stack. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/navigation-view@IBr2P7dknWTnZ2a-fFCqN.md b/src/data/roadmaps/ios/content/navigation-view@IBr2P7dknWTnZ2a-fFCqN.md index ef0ea1305..34a42e65b 100644 --- a/src/data/roadmaps/ios/content/navigation-view@IBr2P7dknWTnZ2a-fFCqN.md +++ b/src/data/roadmaps/ios/content/navigation-view@IBr2P7dknWTnZ2a-fFCqN.md @@ -1,9 +1,7 @@ # Navigation View -A view for presenting a stack of views that represents a visible path in a navigation hierarchy. -Use a NavigationView to create a navigation-based app in which the user can traverse a collection of views. Users navigate to a destination view by selecting a NavigationLink that you provide. On iPadOS and macOS, the destination content appears in the next column. Other platforms push a new view onto the stack, and enable removing items from the stack with platform-specific controls, like a Back button or a swipe gesture. -> [!WARNING] -> Deprecated. Use NavigationStack and NavigationSplitView instead. For more information, see Migrating to new navigation types. + +NavigationView is the SwiftUI component for hierarchical navigation, used before NavigationStack was introduced in iOS 16. It wraps a view and provides a navigation bar and back navigation behavior. NavigationView is still relevant for apps targeting iOS 15 and earlier. Visit the following resources to learn more: -- [@official@Navigation View](https://developer.apple.com/documentation/swiftui/navigationview) +- [@official@Navigation View](https://developer.apple.com/documentation/swiftui/navigationview) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/navigation@02VAK4GMkN6nDHf1zqwPA.md b/src/data/roadmaps/ios/content/navigation@02VAK4GMkN6nDHf1zqwPA.md index 55176a8bb..75669eb20 100644 --- a/src/data/roadmaps/ios/content/navigation@02VAK4GMkN6nDHf1zqwPA.md +++ b/src/data/roadmaps/ios/content/navigation@02VAK4GMkN6nDHf1zqwPA.md @@ -1,11 +1,10 @@ # Navigation + +Navigation in SwiftUI is managed with NavigationStack (iOS 16+) or NavigationView for older deployment targets. NavigationLink connects the current view to a destination, and the navigation stack maintains a history that the user can traverse with the Back button. SwiftUI's navigation model is state-driven, enabling programmatic navigation and deep link support. -SwiftUI navigation offers a declarative approach to managing app structure and flow, primarily utilizing NavigationView for creating hierarchies and NavigationLink for inter-view navigation. The framework supports both push-based navigation for hierarchical content and modal presentations for overlays, with programmatic navigation achieved through state management for dynamic, logic-driven navigation. SwiftUI automatically handles navigation bars, back buttons, and view transitions, while supporting customization of navigation bar appearances and titles. For tab-based interfaces, TabView facilitates the creation of multi-tab applications. This navigation system integrates seamlessly with SwiftUI's state management, ensuring consistent UI updates as navigation states change, thereby simplifying the implementation of complex navigation patterns while maintaining an intuitive user experience across Apple platforms. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Apple Tutorials: Navigation and modal presentation - Creating a navigation hierarchy](https://developer.apple.com/tutorials/app-dev-training/creating-a-navigation-hierarchy) - [@official@Apple Tutorials: Navigation and modal presentation - Managing data flow between views](https://developer.apple.com/tutorials/app-dev-training/managing-data-flow-between-views) -- [@official@Apple Tutorials: Navigation and modal presentation - Creating the edit view](https://developer.apple.com/tutorials/app-dev-training/creating-the-edit-view) -- [@article@The complete guide to NavigationView in SwiftUI](https://www.hackingwithswift.com/articles/216/complete-guide-to-navigationview-in-swiftui) -- [@opensource@pointfreeco/swiftui-navigation](https://github.com/pointfreeco/swiftui-navigation) \ No newline at end of file +- [@opensource@pointfreeco/swiftui-navigation](https://github.com/pointfreeco/swiftui-navigation) +- [@article@The complete guide to NavigationView in SwiftUI](https://www.hackingwithswift.com/articles/216/complete-guide-to-navigationview-in-swiftui) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/navigation@FXUrfyvuIIOH7VDnT_E0z.md b/src/data/roadmaps/ios/content/navigation@FXUrfyvuIIOH7VDnT_E0z.md index 2fa6ab760..6cfefa29d 100644 --- a/src/data/roadmaps/ios/content/navigation@FXUrfyvuIIOH7VDnT_E0z.md +++ b/src/data/roadmaps/ios/content/navigation@FXUrfyvuIIOH7VDnT_E0z.md @@ -4,4 +4,4 @@ Navigation helps users easily find their way around an app and locate the inform Visit the following resources to learn more: -- [@official@WWDC2022: Explore navigation design for iOS](https://developer.apple.com/videos/play/wwdc2022/10001/) +- [@official@WWDC2022: Explore navigation design for iOS](https://developer.apple.com/videos/play/wwdc2022/10001/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/navigationlink@my77jLU2qxU7bQ7_Fx2iH.md b/src/data/roadmaps/ios/content/navigationlink@my77jLU2qxU7bQ7_Fx2iH.md index d315aa9ea..77368cad2 100644 --- a/src/data/roadmaps/ios/content/navigationlink@my77jLU2qxU7bQ7_Fx2iH.md +++ b/src/data/roadmaps/ios/content/navigationlink@my77jLU2qxU7bQ7_Fx2iH.md @@ -2,7 +2,7 @@ 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: +Visit the following resources to learn more: - [@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) diff --git a/src/data/roadmaps/ios/content/navigators@odKZx4SUULF1y4gmiJZdu.md b/src/data/roadmaps/ios/content/navigators@odKZx4SUULF1y4gmiJZdu.md index 2a7ebd649..edb6fe1e4 100644 --- a/src/data/roadmaps/ios/content/navigators@odKZx4SUULF1y4gmiJZdu.md +++ b/src/data/roadmaps/ios/content/navigators@odKZx4SUULF1y4gmiJZdu.md @@ -1,13 +1,3 @@ # Navigators - -Xcode navigators are a set of tools located in the Navigator Area on the left side of the Xcode window. They provide different views and organizational structures for managing various aspects of your project: - -1. Project Navigator: Displays project files and groups -2. Source Control Navigator: Shows version control information -3. Symbol Navigator: Lists symbols (classes, methods, variables) in your project -4. Find Navigator: Displays search results across the project -5. Issue Navigator: Lists warnings, errors, and analysis results -6. Test Navigator: Organizes and runs unit tests -7. Debug Navigator: Shows running processes and debug information -8. Breakpoint Navigator: Manages breakpoints throughout your code -9. Report Navigator: Displays build and run reports + +The navigator panel contains multiple navigators for different purposes. The Project Navigator shows the file hierarchy, the Issue Navigator displays errors and warnings, the Test Navigator lists test suites, and the Debug Navigator shows runtime resource usage. Switching between navigators is done using the icons at the top of the panel. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/networking@JoNoM-utp8MaL1H0oXDta.md b/src/data/roadmaps/ios/content/networking@JoNoM-utp8MaL1H0oXDta.md index da91f5c6d..1432f0ef4 100644 --- a/src/data/roadmaps/ios/content/networking@JoNoM-utp8MaL1H0oXDta.md +++ b/src/data/roadmaps/ios/content/networking@JoNoM-utp8MaL1H0oXDta.md @@ -1,3 +1,7 @@ # Networking + +Networking in iOS covers how apps communicate with remote servers and APIs. The native foundation is URLSession for HTTP requests, and Alamofire is a popular third-party library that simplifies common networking tasks. iOS apps commonly consume REST APIs over HTTPS and, increasingly, GraphQL APIs. -Networking in iOS development involves the exchange of data between an app and remote servers or services over the internet. At the core of iOS networking is URLSession, a powerful class within the Foundation framework that handles HTTP/HTTPS communications. URLSession supports a wide range of operations, from simple data fetching to complex, concurrent downloads and uploads. Developers use it to create data tasks for basic requests, download tasks for file transfers, and upload tasks for sending data to servers. URLSession manages connections, authentication, and caching automatically. iOS networking often revolves around interacting with RESTful APIs, typically using JSON for data interchange. Robust networking code requires careful error handling, efficient response parsing, and effective management of network reachability. Modern Swift features like the Combine framework and async/await syntax complement URLSession by providing more elegant ways to handle asynchronous network operations, enhancing code readability and maintainability in complex scenarios. \ No newline at end of file +Visit the following resources to learn more: + +- [@roadmap@Visit the Dedicated Network Engineer Roadmap](https://roadmap.sh/network-engineer) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/new-feature-announcements@0dbdUmWvTIJ0fkUuLp9gR.md b/src/data/roadmaps/ios/content/new-feature-announcements@0dbdUmWvTIJ0fkUuLp9gR.md index 7b17d2334..f3353ced7 100644 --- a/src/data/roadmaps/ios/content/new-feature-announcements@0dbdUmWvTIJ0fkUuLp9gR.md +++ b/src/data/roadmaps/ios/content/new-feature-announcements@0dbdUmWvTIJ0fkUuLp9gR.md @@ -1,6 +1,8 @@ # New Feature Announcements + +Apple announces new platform features at WWDC each year that affect how iOS apps are built and what they can offer users. Recent examples include StoreKit 2, Live Activities, WidgetKit updates, and Vision framework additions. Staying aware of these announcements helps iOS developers evaluate which new capabilities are relevant to their apps and plan adoption accordingly. -The latest feature announcements can be found in the following resources: +Visit the following resources to learn more: - [@official@Apple Developer Whats New](https://developer.apple.com/whats-new/) - [@official@Apple WDDC Community](https://developer.apple.com/wwdc24/community/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/new-project@BJgoAgH85U6S3RtXq7hHV.md b/src/data/roadmaps/ios/content/new-project@BJgoAgH85U6S3RtXq7hHV.md index dd82ef9f3..c37ac6429 100644 --- a/src/data/roadmaps/ios/content/new-project@BJgoAgH85U6S3RtXq7hHV.md +++ b/src/data/roadmaps/ios/content/new-project@BJgoAgH85U6S3RtXq7hHV.md @@ -2,7 +2,7 @@ To create an Xcode project for your app, select a platform template such as iOS, macOS, watchOS, or tvOS, and choose the type of app you want to develop, like a single view, game, or document-based app. Xcode templates provide essential configuration and files, allowing you to quickly start developing your app. This setup helps streamline the initial stages of app development. -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Creating an Xcode project for an app](https://developer.apple.com/documentation/xcode/creating-an-xcode-project-for-an-app) -- [@video@Build Your First iOS App For Beginners](https://www.youtube.com/watch?v=nqTcAzPS3oc) +- [@video@Build Your First iOS App For Beginners](https://www.youtube.com/watch?v=nqTcAzPS3oc) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/objective-c-basics@0BSX80W1TJ_Ia_Zh2zKyK.md b/src/data/roadmaps/ios/content/objective-c-basics@0BSX80W1TJ_Ia_Zh2zKyK.md index e380066b3..3e8f077b3 100644 --- a/src/data/roadmaps/ios/content/objective-c-basics@0BSX80W1TJ_Ia_Zh2zKyK.md +++ b/src/data/roadmaps/ios/content/objective-c-basics@0BSX80W1TJ_Ia_Zh2zKyK.md @@ -1 +1,3 @@ -# Objective-C Basics \ No newline at end of file +# Objective-C Basics + +Objective-C basics cover the core syntax and concepts needed to read and write Objective-C code. This includes pointers, message syntax, classes, categories, protocols, and property declarations. A working knowledge of these basics is useful when maintaining legacy codebases or interoperating with frameworks that expose Objective-C interfaces. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/objective-c@oOaMz9A5DZvrjxovMztXz.md b/src/data/roadmaps/ios/content/objective-c@oOaMz9A5DZvrjxovMztXz.md index ef32f1952..e0f576f58 100644 --- a/src/data/roadmaps/ios/content/objective-c@oOaMz9A5DZvrjxovMztXz.md +++ b/src/data/roadmaps/ios/content/objective-c@oOaMz9A5DZvrjxovMztXz.md @@ -1,12 +1,7 @@ # Objective-C - -Objective-C is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. - -It was the primary language used by Apple for macOS and iOS development before the introduction of Swift. - -Objective-C enables the creation of dynamic and flexible applications by allowing objects to send messages to each other. It is known for its runtime capabilities and is often used in conjunction with Apple's Cocoa and Cocoa Touch frameworks. + +Objective-C is the original language for iOS and macOS development, widely used before Swift's introduction in 2014. It is a superset of C with Smalltalk-style message passing and object-oriented features. Many older iOS codebases and some Apple frameworks are still written in Objective-C, and it can be used alongside Swift in the same project. Visit the following resources to learn more: -- [@official@Programming with Objective-C](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40011210) -- [@feed@Explore top posts about C Programming](https://app.daily.dev/tags/c?ref=roadmapsh) +- [@official@Programming with Objective-C](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40011210) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/observables--observers@k232wKg7XCb_ngjZ5Mwsy.md b/src/data/roadmaps/ios/content/observables--observers@k232wKg7XCb_ngjZ5Mwsy.md index 42998cea0..b0bd27400 100644 --- a/src/data/roadmaps/ios/content/observables--observers@k232wKg7XCb_ngjZ5Mwsy.md +++ b/src/data/roadmaps/ios/content/observables--observers@k232wKg7XCb_ngjZ5Mwsy.md @@ -1,9 +1,9 @@ # Observables & observers + +An Observable in RxSwift is a sequence that emits zero or more items over time before completing or erroring. Observers subscribe to Observables and receive emitted items, error notifications, or completion events. The relationship between Observable and Observer is the foundation of all RxSwift-based reactive code. -RxSwift Observables and Observers form the core of its reactive paradigm. Observables represent sequences of data or events over time, emitting items to subscribed Observers. Observers react to these emissions, handling new values, errors, or completion signals. This pattern allows for decoupling of data production from consumption, facilitating asynchronous programming. Observables can represent various data sources like UI events, network responses, or timer ticks. Observers can be chained with operators to transform or filter data streams. This approach simplifies complex asynchronous operations, making code more readable and maintainable. - -Learn more from the following resources: +Visit the following resources to learn more: +- [@opensource@RxSwift Documentation - Observables](https://github.com/ReactiveX/RxSwift/blob/main/Documentation/GettingStarted.md#observables-aka-sequences) - [@article@RxSwift - Observables](https://medium.com/@priya_talreja/rxswift-observables-7809b474aab) -- [@video@Creating Observables](https://www.youtube.com/watch?v=h59te-_rVYg) -- [@opensource@RxSwift Documentation - Observables](https://github.com/ReactiveX/RxSwift/blob/main/Documentation/GettingStarted.md#observables-aka-sequences) \ No newline at end of file +- [@video@Creating Observables](https://www.youtube.com/watch?v=h59te-_rVYg) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/oop@FoqlB7xBIrV4yUp4ReBkw.md b/src/data/roadmaps/ios/content/oop@FoqlB7xBIrV4yUp4ReBkw.md index 2d89cecc2..9ba7db112 100644 --- a/src/data/roadmaps/ios/content/oop@FoqlB7xBIrV4yUp4ReBkw.md +++ b/src/data/roadmaps/ios/content/oop@FoqlB7xBIrV4yUp4ReBkw.md @@ -2,6 +2,6 @@ Object-Oriented Programming **(OOP)** is a style where code is organized around "objects," which are instances of classes combining data and methods. It emphasizes encapsulation, abstraction, inheritance, and polymorphism, enabling modular, reusable, and maintainable code. OOP allows developers to model real-world entities and their interactions, making complex software design more intuitive and efficient. -Learn more from the following resources: +Visit the following resources to learn more: - [@video@Object-oriented Programming in 7 minutes](https://www.youtube.com/watch?v=pTB0EiLXUC8) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/operation-queues@mdAV4JlF08q-ZQpb5C3q6.md b/src/data/roadmaps/ios/content/operation-queues@mdAV4JlF08q-ZQpb5C3q6.md index e7853a0f5..64b04963d 100644 --- a/src/data/roadmaps/ios/content/operation-queues@mdAV4JlF08q-ZQpb5C3q6.md +++ b/src/data/roadmaps/ios/content/operation-queues@mdAV4JlF08q-ZQpb5C3q6.md @@ -1,8 +1,8 @@ # Operation Queues + +Operation Queues manage collections of NSOperation objects and execute them concurrently or serially. Operations support dependencies on each other, cancellation, and priority settings. Operation Queues provide a higher-level abstraction than GCD and are useful when tasks have complex interdependencies or need explicit cancellation logic. -Operation Queues in iOS provide a high-level, object-oriented approach to managing concurrent tasks. Built on top of Grand Central Dispatch, they offer more flexibility and control over task execution compared to raw GCD. Operation Queues work with Operation objects, which encapsulate work to be performed and can include dependencies, cancellation, and prioritization. These queues allow for easy management of task dependencies, ensuring that operations are executed in the correct order. They support both synchronous and asynchronous operations, making them suitable for a wide range of concurrency scenarios. Operation Queues provide built-in support for maximum concurrent operation limits, helping to prevent system overload. Developers can subclass NSOperation to create custom, complex operations with intricate logic and state management. This abstraction layer simplifies the implementation of advanced concurrency patterns, making Operation Queues particularly useful for managing complex, interdependent background tasks in iOS applications. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@OperationQueue](https://developer.apple.com/documentation/foundation/operationqueue) - [@article@Getting started with Operations and OperationQueues in Swift](https://www.avanderlee.com/swift/operations/) diff --git a/src/data/roadmaps/ios/content/operators--pipelines@GAn12SsVR_mPxOaOVckdz.md b/src/data/roadmaps/ios/content/operators--pipelines@GAn12SsVR_mPxOaOVckdz.md index 4fd58922a..8105dfb3c 100644 --- a/src/data/roadmaps/ios/content/operators--pipelines@GAn12SsVR_mPxOaOVckdz.md +++ b/src/data/roadmaps/ios/content/operators--pipelines@GAn12SsVR_mPxOaOVckdz.md @@ -1,9 +1,9 @@ # Operators & Pipelines + +Combine operators transform, filter, and combine publishers into processing pipelines. Common operators include map, filter, flatMap, combineLatest, merge, and debounce. Chaining operators between a publisher and a subscriber creates a declarative pipeline that expresses complex asynchronous logic in a readable way. -The Combine framework uses operators and pipelines to process and transform data streams. Operators are methods that perform operations on publishers, such as filtering, mapping, or combining data. Pipelines are chains of these operators that process data from its source to its final destination. Common operators include `map`, `filter`, `reduce`, and `merge`. Pipelines allow developers to declaratively describe complex asynchronous operations, handling tasks like data transformation, error management, and combining multiple data sources. This approach simplifies handling of asynchronous events and state changes, enabling more robust and maintainable code in iOS applications. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@video@How to master Combine like a Pro – The Operators](https://www.youtube.com/watch?v=-NDFLP7Aqeg) - [@article@Swift Combine — Combine Operators & Filtering Operators](https://nikunj-joshi.medium.com/swift-combine-introduction-to-combine-operators-filtering-operators-510d962b95f2) - [@article@Custom Operators in Swift Combine](https://bignerdranch.com/blog/custom-operators-in-swift-combine/) +- [@video@How to master Combine like a Pro – The Operators](https://www.youtube.com/watch?v=-NDFLP7Aqeg) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/operators@t7IYTY8tVjC_xzM1n8wts.md b/src/data/roadmaps/ios/content/operators@t7IYTY8tVjC_xzM1n8wts.md index d2a356610..3ac57c158 100644 --- a/src/data/roadmaps/ios/content/operators@t7IYTY8tVjC_xzM1n8wts.md +++ b/src/data/roadmaps/ios/content/operators@t7IYTY8tVjC_xzM1n8wts.md @@ -2,7 +2,7 @@ RxSwift operators are functions that process, transform, or combine observable sequences. They allow developers to manipulate data streams in powerful ways. Common operators include map (transform elements), filter (select elements based on criteria), flatMap (transform elements into new observables), merge (combine multiple observables), and debounce (limit emission rate). Operators can be chained to create complex data processing pipelines. They handle tasks like error management, retrying failed operations, and combining asynchronous operations. -Learn more from the following resources: +Visit the following resources to learn more: -- [@article@Mastering RxSwift Operators](https://medium.com/@mumensh/mastering-rxswift-operators-e66bd8ef5933) -- [@course@Interactive diagrams of Rx Observables](https://rxmarbles.com/) \ No newline at end of file +- [@course@Interactive diagrams of Rx Observables](https://rxmarbles.com/) +- [@article@Mastering RxSwift Operators](https://medium.com/@mumensh/mastering-rxswift-operators-e66bd8ef5933) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/parsing@UTVh1RHRWb5eA-S7ayLp8.md b/src/data/roadmaps/ios/content/parsing@UTVh1RHRWb5eA-S7ayLp8.md index 5941d40d8..c29d06d3b 100644 --- a/src/data/roadmaps/ios/content/parsing@UTVh1RHRWb5eA-S7ayLp8.md +++ b/src/data/roadmaps/ios/content/parsing@UTVh1RHRWb5eA-S7ayLp8.md @@ -1,9 +1,9 @@ # Parsing + +Parsing JSON in Swift is done using Codable and JSONDecoder, which automatically decode JSON data into Swift structs and classes. XMLParser provides a SAX-style parser for processing XML documents event by event. Correct parsing handles optional fields, nested structures, and type mismatches cleanly. -JSON and XML parsing in iOS involves converting structured data formats into native Swift objects for use within an application. For JSON parsing, Swift's Codable protocol provides a streamlined approach, allowing automatic encoding and decoding of JSON data to and from Swift structs or classes. This system leverages Swift's type inference to create a seamless conversion process, handling most common data structures with minimal code. For more complex JSON structures, custom coding keys and decoding strategies can be implemented. XML parsing, while less common, is typically handled using NSXMLParser or third-party libraries. These parsers often use a delegate-based approach, calling methods as it encounters different elements in the XML structure. Both JSON and XML parsing require careful error handling to manage malformed data or network issues. When dealing with large datasets, considerations for memory management and performance optimization become crucial, often leading to the use of streaming parsers for more efficient processing of extensive data structures. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@article@JSON Parsing in Swift explained with code examples](https://www.avanderlee.com/swift/json-parsing-decoding/) -- [@article@Parsing XML using Swift](https://medium.com/cracking-swift/parsing-remote-xml-using-swift-bfa9701fff84) - [@official@XMLParser](https://developer.apple.com/documentation/foundation/xmlparser) +- [@article@JSON Parsing in Swift explained with code examples](https://www.avanderlee.com/swift/json-parsing-decoding/) +- [@article@Parsing XML using Swift](https://medium.com/cracking-swift/parsing-remote-xml-using-swift-bfa9701fff84) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/pick-a-language@MrdIb9F-wSEbUz7KRnH3t.md b/src/data/roadmaps/ios/content/pick-a-language@MrdIb9F-wSEbUz7KRnH3t.md index 2764a2986..e39366e76 100644 --- a/src/data/roadmaps/ios/content/pick-a-language@MrdIb9F-wSEbUz7KRnH3t.md +++ b/src/data/roadmaps/ios/content/pick-a-language@MrdIb9F-wSEbUz7KRnH3t.md @@ -1,12 +1,10 @@ # Pick a Language - -Apple used to use Objective C for the development of apps for iOS and macOS, but since 2014 [Swift](https://www.swift.org/documentation/) has become the primary language for app development. After more than 10 years of growing strong and mature, now it is worth starting your iOS Developer journey by learning the language. - -Swift is a multi-paradigm language that has object-oriented, functional, and protocol-oriented flavors to it. For someone with a coding background in C++ and Java, the strange concepts would be Optionals, Closures, and the very fact you can skip writing semicolons when you end your statements. + +iOS development primarily uses Swift and Objective-C. Swift is Apple's modern recommended language for new projects, while Objective-C is still present in many legacy codebases and system frameworks. Visit the following resources to learn more: - [@course@Swift Programming Tutorial | FULL COURSE | Absolute Beginner](https://www.youtube.com/watch?v=CwA1VWP0Ldw) - [@course@Swift Programming For Beginners - No Programming Experience](https://www.udemy.com/course/swift-programming-for-beginners-no-experience/) - [@course@Swift Programming Tutorial – Full Course for Beginners](https://www.youtube.com/watch?v=8Xg7E9shq0U) -- [@course@Learn Swift Fast (2020) - Full Course For Beginners](https://www.youtube.com/watch?v=FcsY1YPBwzQ) +- [@course@Learn Swift Fast (2020) - Full Course For Beginners](https://www.youtube.com/watch?v=FcsY1YPBwzQ) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/preferences@SeGfULWFR7ufdv4U9Db3F.md b/src/data/roadmaps/ios/content/preferences@SeGfULWFR7ufdv4U9Db3F.md index 5b1cec87e..6d6766162 100644 --- a/src/data/roadmaps/ios/content/preferences@SeGfULWFR7ufdv4U9Db3F.md +++ b/src/data/roadmaps/ios/content/preferences@SeGfULWFR7ufdv4U9Db3F.md @@ -2,7 +2,7 @@ Xcode preferences allow you to customize your development environment to suit your workflow. They offer various settings across multiple tabs, including General, Accounts, Behaviors, Text Editing, Key Bindings, and more. These preferences let you manage your Apple developer accounts, configure source control, adjust editor and theme settings, and set up custom key bindings, helping streamline your development process. -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Configuring Source Control Preferences](https://developer.apple.com/documentation/xcode/configuring-source-control-preferences-in-xcode) - [@article@Customize Xcode](https://help.apple.com/xcode/mac/current/#/dev9d00ebc70) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/presenting--dismissing-views@4pmjLa7WvwV7D3RZlM6Hp.md b/src/data/roadmaps/ios/content/presenting--dismissing-views@4pmjLa7WvwV7D3RZlM6Hp.md index 9a40ab0d1..47cc15cec 100644 --- a/src/data/roadmaps/ios/content/presenting--dismissing-views@4pmjLa7WvwV7D3RZlM6Hp.md +++ b/src/data/roadmaps/ios/content/presenting--dismissing-views@4pmjLa7WvwV7D3RZlM6Hp.md @@ -1,14 +1,10 @@ # Presenting / Dismissing views + +Presenting views in SwiftUI is done using modifiers like sheet, fullScreenCover, and popover that show views modally over the current screen. Dismissal is handled using the dismiss environment action or by toggling the Boolean binding that controls the presentation. Knowing when to present modally versus navigate is important for designing clear user flows. -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. +Visit the following resources to learn more: -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@https://developer.apple.com/documentation/swiftui/view/sheet(ispresented:ondismiss:content:)](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) - +- [@article@How to make a view dismiss itself](https://www.hackingwithswift.com/quick-start/swiftui/how-to-make-a-view-dismiss-itself) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/profiling-instruments@Y24WWPej0C7-FiBeXpvl3.md b/src/data/roadmaps/ios/content/profiling-instruments@Y24WWPej0C7-FiBeXpvl3.md index bd7edef15..d433d9dea 100644 --- a/src/data/roadmaps/ios/content/profiling-instruments@Y24WWPej0C7-FiBeXpvl3.md +++ b/src/data/roadmaps/ios/content/profiling-instruments@Y24WWPej0C7-FiBeXpvl3.md @@ -1,9 +1,9 @@ # Profiling Instruments + +Instruments is a performance analysis tool bundled with Xcode that provides templates for profiling CPU usage, memory allocations, energy impact, network activity, and more. The Time Profiler identifies which functions consume the most CPU time, while the Allocations instrument tracks memory usage and helps detect leaks and retain cycles. -Profiling Instruments is a suite of powerful performance analysis tools integrated into Xcode, designed to help iOS developers identify and address performance issues within their applications. Instruments can track various metrics such as CPU usage, memory allocation, disk activity, network usage, and energy consumption in real-time. It offers a visual timeline and detailed data graphs, making it easier to pinpoint bottlenecks, memory leaks, and inefficient code paths. Common instruments include Time Profiler, Allocations, Leaks, and Energy Log. By running these instruments on a simulator or real device, developers gain deep insights into their app's performance, allowing for targeted optimizations and improvements. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@video@Getting Started with Instruments](https://developer.apple.com/videos/play/wwdc2019/411/) - [@article@5 Simple Steps to Find Slow Code Using Xcode Time Profiler](https://swiftsenpai.com/xcode/using-time-profiler/) -- [@article@An overview of the time profiler in Instruments](https://augmentedcode.io/2021/05/24/an-overview-of-the-time-profiler-in-instruments/) \ No newline at end of file +- [@article@An overview of the time profiler in Instruments](https://augmentedcode.io/2021/05/24/an-overview-of-the-time-profiler-in-instruments/) +- [@video@Getting Started with Instruments](https://developer.apple.com/videos/play/wwdc2019/411/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/project-files@YytdlQl41yrHSwlV-G3Pd.md b/src/data/roadmaps/ios/content/project-files@YytdlQl41yrHSwlV-G3Pd.md index e359649d2..888066b39 100644 --- a/src/data/roadmaps/ios/content/project-files@YytdlQl41yrHSwlV-G3Pd.md +++ b/src/data/roadmaps/ios/content/project-files@YytdlQl41yrHSwlV-G3Pd.md @@ -1,21 +1,9 @@ # Project Files + +The Project Navigator organizes all files in an Xcode project, including Swift source files, assets, configuration files, and frameworks. Files are listed hierarchically and can be added, deleted, or reorganized within the navigator. The project file (*.xcodeproj) stores build settings, targets, and file references. -Xcode project files organize and manage the various components of an iOS, macOS, watchOS, or tvOS application. Key elements include: +Visit the following resources to learn more: -1. .xcodeproj file: The main project file containing project settings, build configurations, and file references. -2. Source files: .swift, .h, and .m files containing the application's code. -3. Resource files: Assets like images, sounds, and data files used by the app. -4. Interface files: .storyboard and .xib files for designing the user interface. -5. Info.plist: A property list file containing essential app configuration information. -6. Entitlements file: Specifies app capabilities and security settings. -7. Frameworks and libraries: References to system and third-party dependencies. -8. Build phases and build rules: Scripts and settings that define how the project is compiled. -9. Scheme files: .xcscheme files defining build, run, and test configurations. - -These files are typically managed through Xcode's Project Navigator, providing a structured environment for developing and organizing complex applications. - -Learn more from the following resources: - -- [@article@.XCODEPROJ File Extension](https://fileinfo.com/extension/xcodeproj) - [@official@Entitlements](https://developer.apple.com/documentation/bundleresources/entitlements) -- [@official@Managing Your App’s Information Property List](https://developer.apple.com/documentation/bundleresources/information_property_list/managing_your_app_s_information_property_list) \ No newline at end of file +- [@official@Managing Your App’s Information Property List](https://developer.apple.com/documentation/bundleresources/information_property_list/managing_your_app_s_information_property_list) +- [@article@.XCODEPROJ File Extension](https://fileinfo.com/extension/xcodeproj) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/publishers--subscribers@noBaDV_PvCTzqPyw9eO4H.md b/src/data/roadmaps/ios/content/publishers--subscribers@noBaDV_PvCTzqPyw9eO4H.md index cf5b0b04e..0ffbe4798 100644 --- a/src/data/roadmaps/ios/content/publishers--subscribers@noBaDV_PvCTzqPyw9eO4H.md +++ b/src/data/roadmaps/ios/content/publishers--subscribers@noBaDV_PvCTzqPyw9eO4H.md @@ -2,8 +2,8 @@ The Combine framework in iOS uses Publishers and Subscribers as core components for reactive programming. Publishers are types that can emit a sequence of values over time, representing sources of asynchronous events or data. Subscribers receive and process these values, defining how to handle the published data. Publishers can emit multiple values, complete successfully, or terminate with an error. Subscribers can receive and react to these events, often updating UI or triggering further operations. -Learn more from the following resources: +Visit the following resources to learn more: -- [@article@Combine Publishers & Subscribers](https://www.kodeco.com/books/combine-asynchronous-programming-with-swift/v2.0/chapters/2-publishers-subscribers) - [@official@Processing Published Elements with Subscribers](https://developer.apple.com/documentation/combine/processing-published-elements-with-subscribers) +- [@article@Combine Publishers & Subscribers](https://www.kodeco.com/books/combine-asynchronous-programming-with-swift/v2.0/chapters/2-publishers-subscribers) - [@video@Combine - Publishers and Subscribers Lifecycles and Error Handling](https://www.youtube.com/watch?v=4WQskqNHxhQ) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/pushing-presenting@gqd6zjxP_qFj4Ru-6LARo.md b/src/data/roadmaps/ios/content/pushing-presenting@gqd6zjxP_qFj4Ru-6LARo.md index ef2ed8d1b..a95e8c262 100644 --- a/src/data/roadmaps/ios/content/pushing-presenting@gqd6zjxP_qFj4Ru-6LARo.md +++ b/src/data/roadmaps/ios/content/pushing-presenting@gqd6zjxP_qFj4Ru-6LARo.md @@ -1,11 +1,9 @@ # Pushing Presenting + +Pushing a view controller adds it to the navigation stack with a standard slide animation from the right. Presenting a view controller modally overlays it on the current screen, often as a sheet or full-screen cover. The choice between pushing and presenting depends on whether the new screen is part of the current flow or a separate, interruptive task. -Pushing adds a new view controller to the top of the navigation stack, ideal for hierarchical navigation. It's done using navigationController?.pushViewController(_:animated:), which slides the new view in from the right and adds a back button. +Visit the following resources to learn more: -Presenting displays a view controller modally, often covering the entire screen or as a sheet. It's achieved using present(_:animated:completion:), suitable for temporary or standalone content. - -Learn more from the following resources: - -- [@article@Pushing, Popping, Presenting, & Dismissing ViewControllers](https://medium.com/@felicity.johnson.mail/pushing-popping-dismissing-viewcontrollers-a30e98731df5) - [@opensource@presentViewController vs pushViewController](https://github.com/russell-archer/ModalStylesDemo) +- [@article@Pushing, Popping, Presenting, & Dismissing ViewControllers](https://medium.com/@felicity.johnson.mail/pushing-popping-dismissing-viewcontrollers-a30e98731df5) - [@article@UINavigationController.PushViewController](https://learn.microsoft.com/en-us/dotnet/api/uikit.uinavigationcontroller.pushviewcontroller?view=xamarin-ios-sdk-12) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/reactive-programming@28HMXXBJWd3n-ZPgeQRDa.md b/src/data/roadmaps/ios/content/reactive-programming@28HMXXBJWd3n-ZPgeQRDa.md index b1930bcd9..30ec06d6d 100644 --- a/src/data/roadmaps/ios/content/reactive-programming@28HMXXBJWd3n-ZPgeQRDa.md +++ b/src/data/roadmaps/ios/content/reactive-programming@28HMXXBJWd3n-ZPgeQRDa.md @@ -2,7 +2,7 @@ Reactive Programming is a declarative programming paradigm focused on data streams and the propagation of change. It emphasizes the automatic distribution of changes through data flows. Key concepts include observable streams of data, operators to transform and combine streams, and subscribers that react to stream changes. This approach allows for handling asynchronous data flows, managing complex event sequences, and building responsive user interfaces. In iOS development, frameworks like Combine (Apple's native solution) and RxSwift implement reactive principles. -Learn more from the following resources: +Visit the following resources to learn more: - [@article@What is reactive programming?](https://www.baeldung.com/cs/reactive-programming#:~:text=Reactive%20programming%20is%20a%20declarative,or%20reactive%20systems%20in%20general.) - [@video@What is reactive programming?](https://www.youtube.com/watch?v=X-DeG_uGFUU) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/rest@3Qw-qmy5iAE61mPbIY4Q2.md b/src/data/roadmaps/ios/content/rest@3Qw-qmy5iAE61mPbIY4Q2.md index 9c7d6eb35..3dc2fb363 100644 --- a/src/data/roadmaps/ios/content/rest@3Qw-qmy5iAE61mPbIY4Q2.md +++ b/src/data/roadmaps/ios/content/rest@3Qw-qmy5iAE61mPbIY4Q2.md @@ -1,8 +1,8 @@ # REST + +REST (Representational State Transfer) is an architectural style for networked APIs that uses standard HTTP methods like GET, POST, PUT, PATCH, and DELETE. iOS apps consume REST APIs by making URLSession or Alamofire requests and decoding JSON responses using Codable. REST is the most common API style in iOS app development. -REST (Representational State Transfer) is an architectural style for designing networked applications, widely adopted in iOS development for creating and consuming web services. RESTful APIs use standard HTTP methods to perform operations on resources, typically represented as URLs. In iOS, developers interact with REST APIs using URLSession or higher-level networking libraries. These APIs usually exchange data in JSON format, which integrates well with Swift's Codable protocol for easy serialization and deserialization. REST's stateless nature and use of standard HTTP methods (GET for retrieval, POST for creation, PUT for updates, DELETE for removal) make it intuitive and scalable. When implementing RESTful services in iOS apps, developers focus on endpoint design, proper use of HTTP status codes, and efficient data mapping between API responses and Swift objects. Understanding REST principles helps in creating more maintainable, scalable, and interoperable iOS applications that effectively communicate with backend services. - -Learn more from the following resources: +Visit the following resources to learn more: - [@article@REST API Calls in Swift: iOS Networking Architecture](https://matteomanferdini.com/swift-rest-api/) - [@article@Sending and recieving Codable data with URLSession and SwiftUI](https://www.hackingwithswift.com/books/ios-swiftui/sending-and-receiving-codable-data-with-urlsession-and-swiftui) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/rxswift-with-mvvm@g_1f5a6tIB5V_36NjgtL5.md b/src/data/roadmaps/ios/content/rxswift-with-mvvm@g_1f5a6tIB5V_36NjgtL5.md index 5ec9cefdf..5ab24c11e 100644 --- a/src/data/roadmaps/ios/content/rxswift-with-mvvm@g_1f5a6tIB5V_36NjgtL5.md +++ b/src/data/roadmaps/ios/content/rxswift-with-mvvm@g_1f5a6tIB5V_36NjgtL5.md @@ -2,8 +2,8 @@ RxSwift integrates seamlessly with the MVVM (Model-View-ViewModel) architecture in iOS development. In this combination, ViewModels expose Observable properties that Views can bind to, creating a reactive data flow. Models emit data changes through Observables, which ViewModels transform and expose to Views. This setup allows for clean, declarative bindings between Views and ViewModels, reducing boilerplate code and improving testability. RxSwift's operators facilitate complex data transformations within ViewModels, while its Subjects can handle user inputs. -Learn more from the following resources: +Visit the following resources to learn more: +- [@opensource@MVVM with RxSwift](https://github.com/yokurin/RxSwift-MVVM-iOS) - [@article@How to use RxSwift with MVVM Pattern](https://www.vincit.com/blog/how-to-use-rxswift-with-mvvm-pattern) -- [@article@Implementing MVVM With RxSwift](https://betterprogramming.pub/ios-mvvm-with-rxswift-part-1-ff9f8102a3c9) -- [@opensource@MVVM with RxSwift](https://github.com/yokurin/RxSwift-MVVM-iOS) \ No newline at end of file +- [@article@Implementing MVVM With RxSwift](https://betterprogramming.pub/ios-mvvm-with-rxswift-part-1-ff9f8102a3c9) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/rxswift@0xwoWj9jek36p1AwU3WkK.md b/src/data/roadmaps/ios/content/rxswift@0xwoWj9jek36p1AwU3WkK.md index 6725691e6..0ac541693 100644 --- a/src/data/roadmaps/ios/content/rxswift@0xwoWj9jek36p1AwU3WkK.md +++ b/src/data/roadmaps/ios/content/rxswift@0xwoWj9jek36p1AwU3WkK.md @@ -1,9 +1,9 @@ # RxSwift + +RxSwift is the Swift implementation of the ReactiveX library, providing a comprehensive API for reactive programming. It introduces Observable sequences that emit items over time and a large set of operators for combining and transforming them. RxSwift was widely adopted in iOS development before Apple introduced Combine and remains in use in many codebases. -RxSwift is a reactive programming library for iOS development, implementing ReactiveX (Rx) principles in Swift. It provides a framework for composing asynchronous and event-based programs using observable sequences. RxSwift facilitates the handling of asynchronous data streams, simplifying tasks like network requests, user interface events, and data binding. It offers a rich set of operators for transforming, combining, and filtering data streams. The library promotes a declarative programming style, reducing complexities in managing state and dependencies. While similar to Apple's Combine framework, RxSwift has broader platform support and a larger ecosystem. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@opensource@RxSwift Documentation](https://github.com/ReactiveX/RxSwift) - [@official@ReactiveX Documentation](https://reactivex.io/intro.html) +- [@opensource@RxSwift Documentation](https://github.com/ReactiveX/RxSwift) - [@video@RxSwift Basics](https://www.youtube.com/watch?v=ES5RuLSv61g) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/schedulers@UqA01PT86_w_JzN6KZBku.md b/src/data/roadmaps/ios/content/schedulers@UqA01PT86_w_JzN6KZBku.md index 3a249aa75..df7bceb50 100644 --- a/src/data/roadmaps/ios/content/schedulers@UqA01PT86_w_JzN6KZBku.md +++ b/src/data/roadmaps/ios/content/schedulers@UqA01PT86_w_JzN6KZBku.md @@ -1,8 +1,8 @@ # Schedulers + +Schedulers in RxSwift control on which thread or queue Observable work executes. MainScheduler runs work on the main thread for UI updates, while ConcurrentDispatchQueueScheduler and SerialDispatchQueueScheduler run work on background queues. The observeOn and subscribeOn operators specify which scheduler handles observation and subscription respectively. -RxSwift Schedulers manage the execution context of observable sequences and observers. They determine when and on which thread observables emit items and observers receive them. Key schedulers include MainScheduler (for UI operations), SerialDispatchQueueScheduler (for background serial work), and ConcurrentDispatchQueueScheduler (for concurrent background tasks). Schedulers enable fine-grained control over concurrency, allowing developers to optimize performance and maintain thread safety. They're crucial for operations like offloading heavy computations from the main thread or ensuring UI updates occur on the main thread. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@ReactiveX Scheduler Documentation](https://reactivex.io/documentation/scheduler.html) - [@opensource@RxSwift Scheduler Documentation](https://github.com/ReactiveX/RxSwift/blob/main/Documentation/Schedulers.md) diff --git a/src/data/roadmaps/ios/content/serializing@8rYjSCgRiJMHTNxOU6vgG.md b/src/data/roadmaps/ios/content/serializing@8rYjSCgRiJMHTNxOU6vgG.md index 95ac1da6d..a25cbcd4c 100644 --- a/src/data/roadmaps/ios/content/serializing@8rYjSCgRiJMHTNxOU6vgG.md +++ b/src/data/roadmaps/ios/content/serializing@8rYjSCgRiJMHTNxOU6vgG.md @@ -1,8 +1,8 @@ # Serializing + +Serializing converts Swift data structures into JSON or XML format for storage or network transmission. JSONEncoder turns Codable types into Data. Proper serialization handles date formats, custom key naming strategies, and optional values to produce valid output that the server or storage layer can interpret correctly. -Serialization in iOS development involves converting complex data structures or objects into a format that can be easily stored or transmitted, and later reconstructed. This process is crucial for data persistence, network communication, and inter-process data exchange. In Swift, the Codable protocol simplifies serialization, particularly for JSON and property lists. It automatically generates encoding and decoding methods for conforming types, streamlining the process of converting between Swift objects and serialized formats. For custom serialization needs, developers can implement the Encodable and Decodable protocols manually. Beyond JSON, iOS supports serialization to various formats including property lists, binary data, and custom formats. When serializing, it's important to consider data integrity, backwards compatibility for stored data, and performance implications, especially for large datasets. Proper serialization practices ensure efficient data storage and transfer while maintaining the structure and relationships of complex objects in iOS applications. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Encoding, Decoding and Serialization](https://developer.apple.com/documentation/swift/encoding-decoding-and-serialization) - [@official@Codable](https://developer.apple.com/documentation/swift/codable) diff --git a/src/data/roadmaps/ios/content/simple-ui-building@INYUFVZ-_4htveLZ6EvRu.md b/src/data/roadmaps/ios/content/simple-ui-building@INYUFVZ-_4htveLZ6EvRu.md new file mode 100644 index 000000000..0ed32c390 --- /dev/null +++ b/src/data/roadmaps/ios/content/simple-ui-building@INYUFVZ-_4htveLZ6EvRu.md @@ -0,0 +1,3 @@ +# Simple UI Building + +Simple UI building in SwiftUI covers the fundamental skills for constructing working app screens. This includes composing layout containers, applying modifiers, connecting views to state, implementing navigation between screens, and adding animated transitions. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/sqlite@3qjQbrCUchJn1bJTBWrQF.md b/src/data/roadmaps/ios/content/sqlite@3qjQbrCUchJn1bJTBWrQF.md index a665b292d..393b3450b 100644 --- a/src/data/roadmaps/ios/content/sqlite@3qjQbrCUchJn1bJTBWrQF.md +++ b/src/data/roadmaps/ios/content/sqlite@3qjQbrCUchJn1bJTBWrQF.md @@ -1,9 +1,9 @@ # SQLite + +SQLite is a lightweight, serverless relational database engine embedded in iOS. Apps can use SQLite directly through its C API or through higher-level Swift wrappers like GRDB or SQLite.swift. SQLite provides structured, queryable storage and serves as the underlying engine for Core Data and other data frameworks. -SQLite in iOS offers a lightweight, serverless, and self-contained relational database engine that's embedded directly into applications. It provides a robust solution for storing and managing structured data without the overhead of a separate database server. SQLite is particularly useful for apps that need to handle complex queries or manage large datasets efficiently. iOS includes built-in support for SQLite, allowing developers to create, read, update, and delete data using SQL queries. While powerful, working directly with SQLite can be verbose and error-prone, leading many developers to use wrapper libraries or higher-level abstractions like Core Data, which uses SQLite as its default persistent store. SQLite excels in scenarios requiring local data storage with relational capabilities, offering a balance between performance and flexibility. However, it requires careful management of database schemas and queries, making it more complex to use than simpler storage options like User Defaults or property lists. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@official@SQLite website](https://www.sqlite.org/) - [@course@SQlite with Swift tutorial](https://www.kodeco.com/6620276-sqlite-with-swift-tutorial-getting-started) +- [@official@SQLite website](https://www.sqlite.org/) - [@opensource@stephencelis/SQLite.swift](https://github.com/stephencelis/SQLite.swift) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/state-management@RvyOkQelc-GChQGJyEx72.md b/src/data/roadmaps/ios/content/state-management@RvyOkQelc-GChQGJyEx72.md index 80f15d661..39b2347ee 100644 --- a/src/data/roadmaps/ios/content/state-management@RvyOkQelc-GChQGJyEx72.md +++ b/src/data/roadmaps/ios/content/state-management@RvyOkQelc-GChQGJyEx72.md @@ -1,13 +1,10 @@ # State Management + +State management in SwiftUI determines where data lives and how it flows through the view hierarchy. @State handles local view state, @StateObject owns an observable object, @ObservedObject observes an externally owned object, and @EnvironmentObject injects shared data across the hierarchy. Choosing the right property wrapper keeps the app's data flow predictable and organized. -SwiftUI state management revolves around property wrappers that handle different types of app state. `@State` is used for local view state, `@Binding` for sharing state between views, `@ObservedObject` for external reference type state, `@EnvironmentObject` for dependency injection across the view hierarchy, and `@StateObject` for creating and managing the lifecycle of observed objects. These tools, combined with SwiftUI's declarative syntax, enable reactive UI updates based on state changes. For more complex state management, developers often use architectural patterns like MVVM or libraries such as Combine. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Managing user interface state](https://developer.apple.com/documentation/swiftui/managing-user-interface-state) - [@official@Apple Tutorials: State Management - Making classes observable](https://developer.apple.com/tutorials/app-dev-training/making-classes-observable) - [@official@Apple Tutorials: State Management - Responding to events](https://developer.apple.com/tutorials/app-dev-training/responding-to-events) -- [@official@Apple Tutorials: State Management - Managing state and life cycle](https://developer.apple.com/tutorials/app-dev-training/managing-state-and-life-cycle) -- [@official@Apple Tutorials: State Management - Updating app data](https://developer.apple.com/tutorials/app-dev-training/updating-app-data) -- [@article@Advanced: SwiftUI State Management](https://medium.com/@canakyildz/advanced-swiftui-state-management-3816d804477e) -- [@article@A Guide to Managing State in SwiftUI](https://www.waldo.com/blog/manage-swiftui-state) \ No newline at end of file +- [@official@Apple Tutorials: State Management - Managing state and life cycle](https://developer.apple.com/tutorials/app-dev-training/managing-state-and-life-cycle) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/static-library@RuXuHQhMt2nywk43LgGeJ.md b/src/data/roadmaps/ios/content/static-library@RuXuHQhMt2nywk43LgGeJ.md index 6348513fe..4c49623fc 100644 --- a/src/data/roadmaps/ios/content/static-library@RuXuHQhMt2nywk43LgGeJ.md +++ b/src/data/roadmaps/ios/content/static-library@RuXuHQhMt2nywk43LgGeJ.md @@ -1,8 +1,8 @@ # Static Library + +A static library is a compiled archive of object code that is copied directly into the app binary at link time. Static libraries increase binary size but have no runtime loading overhead. They are distributed as .a files and are commonly used to share compiled code between targets within the same Xcode project. -Static libraries in iOS development are collections of compiled code that are linked directly into an app's executable at build time. They contain object code that becomes part of the final application binary, increasing its size but potentially improving load time performance. Static libraries are typically distributed as .a files, often accompanied by header files that define their public interfaces. Using static libraries ensures that all necessary code is available within the app, eliminating runtime dependencies. Static libraries are particularly useful for distributing closed-source code or when aiming to minimize runtime overhead. They offer simplicity in distribution and version management but may require recompilation of the entire app when the library is updated. In iOS development, static libraries are gradually being replaced by more flexible options like dynamic frameworks and XCFrameworks, especially for larger or frequently updated libraries. - -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Static Library in iOS](https://swiftpublished.com/article/static-library-in-ios-part1) -- [@video@ How to Create an XCFramework - Frameworks and Static Libraries ](https://www.youtube.com/watch?v=40EmwraG4-k) +- [@video@How to Create an XCFramework - Frameworks and Static Libraries](https://www.youtube.com/watch?v=40EmwraG4-k) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/stepping@hUHxlNa6iJJbDGdFNhynB.md b/src/data/roadmaps/ios/content/stepping@hUHxlNa6iJJbDGdFNhynB.md index d47abedd0..b249ff6ea 100644 --- a/src/data/roadmaps/ios/content/stepping@hUHxlNa6iJJbDGdFNhynB.md +++ b/src/data/roadmaps/ios/content/stepping@hUHxlNa6iJJbDGdFNhynB.md @@ -1,18 +1,9 @@ # Stepping + +Stepping controls in the Xcode debugger allow developers to move through code one statement at a time during a paused breakpoint session. Step Over executes the current line without descending into called functions, Step Into enters a called function, and Step Out completes the current function and returns to the caller. -Xcode debugger stepping allows developers to execute code line by line, providing detailed control over program flow during debugging. Key stepping commands include: - -1. Step Over: Executes the current line and moves to the next, without entering functions. -2. Step Into: Enters into the function call on the current line. -3. Step Out: Completes the current function and returns to the calling line. -4. Continue: Resumes normal execution until the next breakpoint. -5. Step Into Instruction: Moves to the next machine instruction (for low-level debugging). -6. Step Over Instruction: Executes the current machine instruction without entering calls. - -These controls are accessible via the debug toolbar, keyboard shortcuts, or the Debug menu. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Stepping through code and inspecting variables to isolate bugs](https://developer.apple.com/documentation/xcode/stepping-through-code-and-inspecting-variables-to-isolate-bugs) -- [@video@Debugging Apps with Xcode 15: Stepping through Code With Breakpoints](https://www.youtube.com/watch?v=u2GoZl7iotg) -- [@article@Stepping through code](https://www.jetbrains.com/help/rider/Stepping_Through_the_Program.html) \ No newline at end of file +- [@article@Stepping through code](https://www.jetbrains.com/help/rider/Stepping_Through_the_Program.html) +- [@video@Debugging Apps with Xcode 15: Stepping through Code With Breakpoints](https://www.youtube.com/watch?v=u2GoZl7iotg) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/storyboards@a2CqrCJSxGfHq6_Y9f_re.md b/src/data/roadmaps/ios/content/storyboards@a2CqrCJSxGfHq6_Y9f_re.md index 1d93e0d5a..aa6b8ee85 100644 --- a/src/data/roadmaps/ios/content/storyboards@a2CqrCJSxGfHq6_Y9f_re.md +++ b/src/data/roadmaps/ios/content/storyboards@a2CqrCJSxGfHq6_Y9f_re.md @@ -1,9 +1,7 @@ # Storyboards + +Storyboards are XML-based files that define multiple view controllers and the transitions between them on a single visual canvas. Developers drag view controllers onto the canvas, design their views, and connect screens with segues. Storyboards give a visual overview of the app's entire navigation flow. -A storyboard is a visual representation of the user interface of an iOS application, showing screens of content and the connections between those screens. A storyboard is composed of a sequence of scenes, each of which represents a view controller and its views; scenes are connected by segue objects, which represent a transition between two view controllers. +Visit the following resources to learn more: -Xcode provides a visual editor for storyboards, where you can lay out and design the user interface of your application by adding views such as buttons, table views, and text views onto scenes. In addition, a storyboard enables you to connect a view to its controller object, and to manage the transfer of data between view controllers. Using storyboards is the recommended way to design the user interface of your application because they enable you to visualize the appearance and flow of your user interface on one canvas. - -Learn more from the following resources: - -- [@official@Storyboard](https://developer.apple.com/library/archive/documentation/General/Conceptual/Devpedia-CocoaApp/Storyboard.html) +- [@official@Storyboard](https://developer.apple.com/library/archive/documentation/General/Conceptual/Devpedia-CocoaApp/Storyboard.html) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/subjects@1xYZdnlI6JSJzNvmz4-0v.md b/src/data/roadmaps/ios/content/subjects@1xYZdnlI6JSJzNvmz4-0v.md index f107c7edf..749eb5785 100644 --- a/src/data/roadmaps/ios/content/subjects@1xYZdnlI6JSJzNvmz4-0v.md +++ b/src/data/roadmaps/ios/content/subjects@1xYZdnlI6JSJzNvmz4-0v.md @@ -1,9 +1,9 @@ # Subjects + +Subjects in RxSwift act as both Observables and Observers, making them useful for bridging non-reactive code into reactive streams. PublishSubject emits only new items to subscribers; BehaviorSubject replays the last value to new subscribers; and ReplaySubject replays a configurable number of past values. Subjects are commonly used as input channels in MVVM ViewModels. -RxSwift Subjects are a special type of Observable that act as both an observer and an observable. They can receive and emit values, serving as a bridge between the imperative and reactive programming paradigms. Subjects allow multiple observers to react to the same source of emitted items. RxSwift provides several types of Subjects, including PublishSubject (emits only new elements), BehaviorSubject (emits the latest element to new subscribers), ReplaySubject (buffers and re-emits a specified number of elements), and Variable (a deprecated wrapper around BehaviorSubject). - -Learn more from the following resources: +Visit the following resources to learn more: +- [@official@ReactiveX Subject Documentation](https://reactivex.io/documentation/subject.html) - [@article@RxSwift Subjects Reference](https://docs.rxswift.org/rxswift/subjects) -- [@article@RxSwift Subjects](https://medium.com/@jhalekhnish/rxswift-subjects-45f65649aee6) -- [@official@ReactiveX Subject Documentation](https://reactivex.io/documentation/subject.html) \ No newline at end of file +- [@article@RxSwift Subjects](https://medium.com/@jhalekhnish/rxswift-subjects-45f65649aee6) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/swift-basics@fboebSmquyJyozsMRJDtK.md b/src/data/roadmaps/ios/content/swift-basics@fboebSmquyJyozsMRJDtK.md index 5bb9b8b16..f814ff914 100644 --- a/src/data/roadmaps/ios/content/swift-basics@fboebSmquyJyozsMRJDtK.md +++ b/src/data/roadmaps/ios/content/swift-basics@fboebSmquyJyozsMRJDtK.md @@ -1,8 +1,8 @@ # Swift Basics + +Swift basics cover the fundamental syntax and language features needed to write Swift programs. This includes variables, constants, data types, control flow, functions, closures, classes, structs, enums, and optionals. A solid understanding of these basics is required before working with iOS frameworks and APIs. +Visit the following resources to learn more: -Swift is a powerful and intuitive programming language for macOS, iOS, watchOS, and tvOS. Writing Swift code is interactive and fun, the syntax is concise yet expressive, and Swift includes modern features developers love. Swift code is safe by design, yet also produces software that runs lightning-fast. - -Learn more from the following resources: - -- [@official@Tour of Swift](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/guidedtour) +- [@roadmap@Visit the Dedicated Swift & Swift UI Roadmap](https://roadmap.sh/swift-ui) +- [@official@Tour of Swift](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/guidedtour) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/swift-package-manager@KFkX8_Hv9SCFeCtZMZIQM.md b/src/data/roadmaps/ios/content/swift-package-manager@KFkX8_Hv9SCFeCtZMZIQM.md index b82bf493e..595274c87 100644 --- a/src/data/roadmaps/ios/content/swift-package-manager@KFkX8_Hv9SCFeCtZMZIQM.md +++ b/src/data/roadmaps/ios/content/swift-package-manager@KFkX8_Hv9SCFeCtZMZIQM.md @@ -1,7 +1,7 @@ # Swift Package Manager -The Swift Package Manager (SwiftPM) is a tool for managing the distribution of Swift code. It’s integrated with the Swift build system to automate the process of downloading, compiling, and linking dependencies. -The Package Manager is included in Swift 3.0 and above. + +The Swift Package Manager (SwiftPM) is a tool for managing the distribution of Swift code. It’s integrated with the Swift build system to automate the process of downloading, compiling, and linking dependencies. The Package Manager is included in Swift 3.0 and above. Visit the following resources to learn more: -- [@official@Swift Package Manager](https://www.swift.org/documentation/package-manager/) +- [@official@Swift Package Manager](https://www.swift.org/documentation/package-manager/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/swift-recommended@KJ7fM-V0_azY_lzmhjJAN.md b/src/data/roadmaps/ios/content/swift-recommended@KJ7fM-V0_azY_lzmhjJAN.md index 0fb977937..c7ffc0382 100644 --- a/src/data/roadmaps/ios/content/swift-recommended@KJ7fM-V0_azY_lzmhjJAN.md +++ b/src/data/roadmaps/ios/content/swift-recommended@KJ7fM-V0_azY_lzmhjJAN.md @@ -1,13 +1,10 @@ # Swift (Recommended) - -Swift is a powerful and intuitive programming language developed by Apple for building iOS, macOS, watchOS, and tvOS applications. It combines modern language features like type safety, concise syntax, and performance optimizations, making it easy to write and maintain. - -Swift is designed to be safe, fast, and interactive, offering a more productive coding experience compared to Objective-C. + +Swift is Apple's modern, statically typed programming language for iOS, macOS, watchOS, and tvOS development. Introduced in 2014, it has become the recommended choice for new iOS projects. Swift features a clean syntax, strong type inference, optionals for safe null handling, and built-in concurrency support through async/await. Visit the following resources to learn more: +- [@roadmap@Visit the Dedicated Swift & Swift UI Roadmap](https://roadmap.sh/swift-ui) - [@official@Swift Documentation](https://www.swift.org/documentation/) -- [@video@Swift in 100 Seconds](https://www.youtube.com/watch?v=nAchMctX4YA) -- [@feed@Explore top posts about Swift](https://app.daily.dev/tags/swift?ref=roadmapsh) - [@course@Programiz - Swift Programming Tutorials](https://www.programiz.com/swift-programming) -- [@course@HackingWithSwift - 100 Days of Swift](https://www.hackingwithswift.com/100) +- [@course@HackingWithSwift - 100 Days of Swift](https://www.hackingwithswift.com/100) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/swiftformat@TMFvfwG45Z00PzrzZIVhT.md b/src/data/roadmaps/ios/content/swiftformat@TMFvfwG45Z00PzrzZIVhT.md index 7539c88ff..57cdca470 100644 --- a/src/data/roadmaps/ios/content/swiftformat@TMFvfwG45Z00PzrzZIVhT.md +++ b/src/data/roadmaps/ios/content/swiftformat@TMFvfwG45Z00PzrzZIVhT.md @@ -1,9 +1,9 @@ # SwiftFormat + +SwiftFormat is a command-line tool that automatically reformats Swift source code to follow consistent style rules. Unlike SwiftLint, which reports violations, SwiftFormat directly edits source files. It handles formatting rules like indentation, blank lines, trailing commas, and bracket placement. -SwiftFormat is a powerful command-line tool and Xcode extension designed to automatically format Swift code according to a set of predefined or custom rules. It helps maintain consistent code style across projects and teams by automatically adjusting whitespace, braces, and other formatting details. SwiftFormat can be easily integrated into development workflows, either as a pre-commit hook, as part of a continuous integration process, or directly within Xcode. It supports a wide range of formatting rules, from basic indentation and line wrapping to more complex transformations like organizing import statements and standardizing access control modifiers. The tool is highly configurable, allowing developers to create custom rule sets that align with their team's coding standards. By automating the formatting process, SwiftFormat saves time, reduces code review discussions about style, and helps maintain a clean, readable codebase. Its ability to format entire projects quickly makes it particularly valuable for large-scale Swift applications and teams focused on code quality and consistency. - -Learn more from the following resources: +Visit the following resources to learn more: - [@opensource@nicklockwood/SwiftFormat](https://github.com/nicklockwood/SwiftFormat) - [@article@SwiftFormat Automation for iOS Apps](https://medium.com/@pranav.kasetti/swiftformat-automation-for-ios-apps-42c91000a9af) -- [@video@ How to Setup Swift Format on XCode 14 ](https://www.youtube.com/watch?v=S7e_rp_ZRKY) \ No newline at end of file +- [@video@How to Setup Swift Format on XCode 14](https://www.youtube.com/watch?v=S7e_rp_ZRKY) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/swiftlint@NnTC3R8goZQTXHmfHKHbM.md b/src/data/roadmaps/ios/content/swiftlint@NnTC3R8goZQTXHmfHKHbM.md index ec4f30156..206431bb1 100644 --- a/src/data/roadmaps/ios/content/swiftlint@NnTC3R8goZQTXHmfHKHbM.md +++ b/src/data/roadmaps/ios/content/swiftlint@NnTC3R8goZQTXHmfHKHbM.md @@ -1,8 +1,8 @@ -# SwiftLint - -SwiftLint is an open-source tool developed by Realm, that facilitates maintaining standardized code development by enabling the definition and enforcement of project-specific conventions and guidelines. It ensures developers adhere to these standards, thereby promoting organized code practices. - -Learn more from the following resources: - -- [@official@SwiftLint Documentation](https://github.com/realm/SwiftLint) +# SwiftLint + +SwiftLint is an open-source tool developed by Realm, that facilitates maintaining standardized code development by enabling the definition and enforcement of project-specific conventions and guidelines. It ensures developers adhere to these standards, thereby promoting organized code practices. + +Visit the following resources to learn more: + +- [@official@SwiftLint Documentation](https://github.com/realm/SwiftLint) - [@video@Mastering SwiftLint for Code Readability](https://www.youtube.com/watch?v=4YQ6DJ-xovY) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/swiftui@PvFp6aY7EUrYHn87RZAGj.md b/src/data/roadmaps/ios/content/swiftui@PvFp6aY7EUrYHn87RZAGj.md index aaa9f98c2..ea8d97109 100644 --- a/src/data/roadmaps/ios/content/swiftui@PvFp6aY7EUrYHn87RZAGj.md +++ b/src/data/roadmaps/ios/content/swiftui@PvFp6aY7EUrYHn87RZAGj.md @@ -1 +1,7 @@ -# SwiftUI \ No newline at end of file +# SwiftUI + +SwiftUI is Apple's declarative UI framework for building apps across iOS, macOS, watchOS, and tvOS. Introduced in 2019, it replaces UIKit's imperative approach with composable views written entirely in Swift. SwiftUI automatically handles layout, animations, and UI updates when the underlying data changes. + +Visit the following resources to learn more: + +- [@roadmap@Visit the Dedicated Swift & Swift UI Roadmap](https://roadmap.sh/swift-ui) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/swiftui@kAIKsDcDzwI1E0wSnC_uo.md b/src/data/roadmaps/ios/content/swiftui@kAIKsDcDzwI1E0wSnC_uo.md index ede37218e..c46bcf472 100644 --- a/src/data/roadmaps/ios/content/swiftui@kAIKsDcDzwI1E0wSnC_uo.md +++ b/src/data/roadmaps/ios/content/swiftui@kAIKsDcDzwI1E0wSnC_uo.md @@ -1,11 +1,10 @@ # SwiftUI + +SwiftUI is Apple's declarative UI framework for building apps across iOS, macOS, watchOS, and tvOS. Introduced in 2019, it replaces UIKit's imperative approach with composable views written entirely in Swift. SwiftUI automatically handles layout, animations, and UI updates when the underlying data changes. -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: +Visit the following resources to learn more: +- [@roadmap@Visit the Dedicated Swift & Swift UI Roadmap](https://roadmap.sh/swift-ui) - [@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) -- [@course@HackingWithSwift - 100 Days of SwiftUI](https://www.hackingwithswift.com/100/swiftui) +- [@article@Build an iOS app with SwiftUI](https://www.swift.org/getting-started/swiftui/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/tailor@F5796wzm5Ar6sQt-1y8vH.md b/src/data/roadmaps/ios/content/tailor@F5796wzm5Ar6sQt-1y8vH.md index a62914ee3..f93d85219 100644 --- a/src/data/roadmaps/ios/content/tailor@F5796wzm5Ar6sQt-1y8vH.md +++ b/src/data/roadmaps/ios/content/tailor@F5796wzm5Ar6sQt-1y8vH.md @@ -1,9 +1,9 @@ # Tailor + +Tailor is a static analysis tool for Swift that checks code style and detects common issues. It is configurable and integrates with Xcode and CI pipelines. Tailor is an alternative to SwiftLint for teams that prefer a different rule set or configuration model. -Tailor is a cross-platform static analysis and lint tool specifically designed for Swift code. It aims to enforce Swift style and conventions, helping developers maintain consistent and clean codebases. Tailor analyzes Swift source files and reports on various style, performance, and maintainability issues. It can detect problems like unused variables, overly complex functions, and violations of naming conventions. The tool is highly configurable, allowing teams to customize rules to match their specific coding standards. Tailor can be integrated into continuous integration pipelines, providing automated code quality checks with each commit. While less popular than some other linting tools like SwiftLint, Tailor offers a straightforward, cross-platform solution for Swift code analysis. Its use can help teams catch potential issues early in the development process, promote best practices, and maintain a more uniform code style across projects. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@opensource@sleekbyte/tailor](https://github.com/sleekbyte/tailor) - [@official@Tailor Website](https://sleekbyte.github.io/tailor/) +- [@opensource@sleekbyte/tailor](https://github.com/sleekbyte/tailor) - [@article@Tailor](https://docs.codeclimate.com/docs/tailor) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/tca@NhC0SBZgUFGjMLNICvbTI.md b/src/data/roadmaps/ios/content/tca@NhC0SBZgUFGjMLNICvbTI.md index 04e29a470..6df5e1327 100644 --- a/src/data/roadmaps/ios/content/tca@NhC0SBZgUFGjMLNICvbTI.md +++ b/src/data/roadmaps/ios/content/tca@NhC0SBZgUFGjMLNICvbTI.md @@ -1,19 +1,9 @@ # TCA + +The Composable Architecture (TCA) is an opinionated architecture library for Swift developed by Point-Free. It organizes app logic around unidirectional data flow with state, actions, reducers, and effects. TCA emphasizes testability and composability, allowing large app features to be built from smaller, independently testable pieces. -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: +Visit the following resources to learn more: - [@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) +- [@video@Shai Mishali - A Newbie's Guide to The Composable Architecture](https://www.youtube.com/watch?v=XWZmgbylTpc) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/test-plan--coverage@uczkyc30K_qqcarZCGTdF.md b/src/data/roadmaps/ios/content/test-plan--coverage@uczkyc30K_qqcarZCGTdF.md index b1f942ddb..ff28bba6e 100644 --- a/src/data/roadmaps/ios/content/test-plan--coverage@uczkyc30K_qqcarZCGTdF.md +++ b/src/data/roadmaps/ios/content/test-plan--coverage@uczkyc30K_qqcarZCGTdF.md @@ -1,8 +1,3 @@ # Test Plan & Coverage - -A Test Plan in iOS development is a comprehensive document that outlines the strategy, scope, resources, and schedule for testing activities. It defines the objectives, test criteria, deliverables, and the roles and responsibilities of the team members involved. Test Plans ensure systematic testing and help in tracking progress, identifying risks, and managing test activities efficiently. - -Coverage refers to the measure of how much of the codebase is exercised by the tests. Xcode provides code coverage tools that highlight the portions of code executed during tests, offering insights into untested parts. Higher code coverage typically indicates more comprehensive testing, but it’s essential to focus on meaningful coverage that validates critical functionality rather than aiming for 100% coverage without ensuring test quality. Balancing extensive unit tests, integration tests, and UI tests helps achieve effective coverage and robust application quality. - -Learn more from the following resources: - + +Test plans in Xcode define how tests are executed, including which test targets to include, environment variables, and configurations for multiple runs with different settings. Code coverage reports show which lines of code are exercised by tests, helping identify gaps. Test plans make it straightforward to run specific subsets of tests in CI and local development. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/testflight@KCJgCjMJGxIcf13XSEclO.md b/src/data/roadmaps/ios/content/testflight@KCJgCjMJGxIcf13XSEclO.md index fb0161054..d45fa1e35 100644 --- a/src/data/roadmaps/ios/content/testflight@KCJgCjMJGxIcf13XSEclO.md +++ b/src/data/roadmaps/ios/content/testflight@KCJgCjMJGxIcf13XSEclO.md @@ -1,9 +1,9 @@ # TestFlight + +TestFlight is Apple's platform for distributing beta versions of iOS apps to testers before public release. Internal testers with access to the developer's App Store Connect account can be added directly, while external testers receive email invitations. TestFlight builds expire after 90 days and can be shared with up to 10,000 external testers. -TestFlight is Apple's beta testing service for iOS applications, allowing developers to distribute their apps to internal and external testers before the official release on the App Store. Through TestFlight, developers can invite users via email or a public link to test the app and provide feedback. Testers can then download the app directly to their devices using the TestFlight app. Developers can distribute up to 100 internal testers (using iTunes Connect user roles) and up to 10,000 external testers per app. TestFlight provides valuable insights by collecting feedback and crash reports, helping identify issues and improve app quality. It supports testing of multiple builds simultaneously and manages app versioning and expiration, streamlining the beta testing process significantly. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Beta testing made simple with TestFlight](https://developer.apple.com/testflight/) -- [@video@Get started with TestFlight](https://developer.apple.com/videos/play/tech-talks/110343/) -- [@article@What is TestFlight and how to use it](https://vikramios.medium.com/what-is-testflight-how-to-use-it-44dba5d2f263) \ No newline at end of file +- [@article@What is TestFlight and how to use it](https://vikramios.medium.com/what-is-testflight-how-to-use-it-44dba5d2f263) +- [@video@Get started with TestFlight](https://developer.apple.com/videos/play/tech-talks/110343/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/toolbar@AxQ5gCjk136kXsbBFTUNp.md b/src/data/roadmaps/ios/content/toolbar@AxQ5gCjk136kXsbBFTUNp.md index a418174ee..efc42bece 100644 --- a/src/data/roadmaps/ios/content/toolbar@AxQ5gCjk136kXsbBFTUNp.md +++ b/src/data/roadmaps/ios/content/toolbar@AxQ5gCjk136kXsbBFTUNp.md @@ -1,13 +1,3 @@ # Toolbar - -The Xcode toolbar is a central control panel located at the top of the Xcode window, providing quick access to key development functions. It includes: - -1. Run and Stop buttons for building and executing the app -2. Scheme menu for selecting the active scheme and target device -3. Status display showing build progress and errors -4. Editor segmented control for switching between standard, assistant, and version editors -5. Workspace configuration buttons for showing/hiding different interface areas -6. Organizer button for accessing project and device management tools -7. Activity viewer for background tasks like indexing - -The toolbar's layout can be customized to suit individual developer preferences, allowing for the addition or removal of specific items. + +The Xcode toolbar provides quick access to common actions, including running and stopping the app, selecting a target device or simulator, and showing or hiding the navigator and inspector panels. It also displays build activity messages and scheme selection controls. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/ui-design@4fPgpGwNXmVoZoruBRb_B.md b/src/data/roadmaps/ios/content/ui-design@4fPgpGwNXmVoZoruBRb_B.md index e2e8586ca..41858afed 100644 --- a/src/data/roadmaps/ios/content/ui-design@4fPgpGwNXmVoZoruBRb_B.md +++ b/src/data/roadmaps/ios/content/ui-design@4fPgpGwNXmVoZoruBRb_B.md @@ -1,9 +1,10 @@ # UI Design + +UI design for iOS focuses on how apps should look and behave to feel native and intuitive on Apple platforms. The primary reference is Apple's Human Interface Guidelines (HIG), which provides principles and specific guidance on navigation patterns, controls, typography, color, and accessibility. Applying these principles leads to apps that feel familiar and polished to iOS users. -UI Design in iOS development focuses on creating visually appealing and functional user interfaces that adhere to Apple's Human Interface Guidelines. It involves designing layouts, choosing appropriate color schemes, typography, and interactive elements that provide a seamless user experience. iOS designers use tools like Sketch, Figma, or Adobe XD to create mockups and prototypes. Key considerations include maintaining consistency with iOS design patterns, ensuring accessibility, supporting different device sizes and orientations, and implementing intuitive navigation. Effective iOS UI design balances aesthetic appeal with usability, leveraging native UI components and custom designs to create engaging, user-friendly applications that feel at home on Apple devices. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@article@Design Patterns in iOS](https://shreethaanur.medium.com/design-patterns-in-ios-55d00c2eef4c) +- [@roadmap@Visit the Dedicated Product Design Roadmap](https://roadmap.sh/product-design) - [@official@Sketch](https://www.sketch.com/) -- [@official@Figma](https://www.figma.com/) \ No newline at end of file +- [@official@Figma](https://www.figma.com/) +- [@article@Design Patterns in iOS](https://shreethaanur.medium.com/design-patterns-in-ios-55d00c2eef4c) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/uikit@-7OW2IgiMk1eot1PaYd7m.md b/src/data/roadmaps/ios/content/uikit@-7OW2IgiMk1eot1PaYd7m.md index 9f93e507b..6a6ac8ffc 100644 --- a/src/data/roadmaps/ios/content/uikit@-7OW2IgiMk1eot1PaYd7m.md +++ b/src/data/roadmaps/ios/content/uikit@-7OW2IgiMk1eot1PaYd7m.md @@ -1,9 +1,9 @@ # UIKit + +UIKit is Apple's foundational framework for building iOS and tvOS user interfaces. It provides the core building blocks including views, view controllers, navigation controllers, table views, and gesture recognizers. UIKit uses an imperative, event-driven model and has been the basis of iOS development since the first iPhone SDK. -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. - -Learn more from the following resources: +Visit the following resources to learn more: - [@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) +- [@video@Introduction to Programmatic UI - UIKit](https://www.youtube.com/watch?v=_U6_l58Cv4E) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/uikit@pNEE5C1E1wAjH_nTlzH6N.md b/src/data/roadmaps/ios/content/uikit@pNEE5C1E1wAjH_nTlzH6N.md index 031bb9a4f..61371ddb2 100644 --- a/src/data/roadmaps/ios/content/uikit@pNEE5C1E1wAjH_nTlzH6N.md +++ b/src/data/roadmaps/ios/content/uikit@pNEE5C1E1wAjH_nTlzH6N.md @@ -1 +1,3 @@ -# UIKit \ No newline at end of file +# UIKit + +UIKit is Apple's foundational framework for building iOS and tvOS user interfaces. It provides the core building blocks including views, view controllers, navigation controllers, table views, and gesture recognizers. UIKit uses an imperative, event-driven model and has been the basis of iOS development since the first iPhone SDK. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/understanding-and-using-closures@5V7nxQKmmHWSMSBCRxkaF.md b/src/data/roadmaps/ios/content/understanding-and-using-closures@5V7nxQKmmHWSMSBCRxkaF.md index 38b25c14a..5f4e5fa52 100644 --- a/src/data/roadmaps/ios/content/understanding-and-using-closures@5V7nxQKmmHWSMSBCRxkaF.md +++ b/src/data/roadmaps/ios/content/understanding-and-using-closures@5V7nxQKmmHWSMSBCRxkaF.md @@ -1,8 +1,8 @@ # Understanding and using Closures + +Understanding closures involves knowing their syntax, how they capture surrounding values, and how to use them as function parameters and return values. Swift offers shorthand argument names and trailing closure syntax to keep closure usage concise. Closures appear throughout the Swift standard library and iOS SDK as the primary mechanism for passing behavior between components. -Closures in Swift are self-contained blocks of functionality that can be passed around and used in your code. They capture and store references to variables and constants from the surrounding context in which they're defined. Closures can be thought of as anonymous functions, capable of being assigned to variables, passed as arguments to functions, or returned from functions. They are particularly useful for writing compact, inline code for event handlers, completion handlers, and higher-order functions like map, filter, and reduce. Swift's closure syntax is flexible, allowing for shorthand argument names, implicit returns, and trailing closure syntax, which can significantly reduce boilerplate code. Understanding closures is crucial for effective Swift programming, as they are extensively used in iOS SDK and SwiftUI for handling asynchronous operations, callbacks, and reactive programming patterns. - -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Swift Closures](https://www.programiz.com/swift-programming/closures) - [@article@A guide to closures in Swift](https://medium.com/swiftable/a-guide-to-closures-in-swift-368e6aca6d71) diff --git a/src/data/roadmaps/ios/content/unit--ui-testing@5589B1DKaCd-9l9DfKH3o.md b/src/data/roadmaps/ios/content/unit--ui-testing@5589B1DKaCd-9l9DfKH3o.md index 60295c64a..ca378646d 100644 --- a/src/data/roadmaps/ios/content/unit--ui-testing@5589B1DKaCd-9l9DfKH3o.md +++ b/src/data/roadmaps/ios/content/unit--ui-testing@5589B1DKaCd-9l9DfKH3o.md @@ -1,3 +1,3 @@ # Unit & UI Testing - -Unit and UI testing are critical components of ensuring the reliability and quality of iOS applications. Unit testing involves writing tests for individual components or functions to verify that they produce the expected results under various conditions, typically using the XCTest framework. These tests are automated, fast, and help catch bugs early in the development cycle. UI testing, on the other hand, involves verifying the app's user interface and user interactions. This can be done using Xcode's UI testing framework, which allows developers to record and write automated tests that simulate user actions like taps, swipes, and text input. Together, unit and UI testing ensure that both the internal logic and the user experience of an app are robust and function correctly as changes are made to the codebase. \ No newline at end of file + +iOS apps are tested at two levels: unit tests verify individual functions and classes in isolation, and UI tests verify app behavior from the user's perspective. XCTest is the framework for both. Unit tests run on the local machine and are fast; UI tests launch the full app on a device or simulator and simulate real user interactions. \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/urlsession@WPJACNeI6jX9GGB1roeTp.md b/src/data/roadmaps/ios/content/urlsession@WPJACNeI6jX9GGB1roeTp.md index bea2d7983..e0a9f1b12 100644 --- a/src/data/roadmaps/ios/content/urlsession@WPJACNeI6jX9GGB1roeTp.md +++ b/src/data/roadmaps/ios/content/urlsession@WPJACNeI6jX9GGB1roeTp.md @@ -1,9 +1,9 @@ # URLSession + +URLSession is Apple's built-in networking API for making HTTP and HTTPS requests. It supports data tasks for simple requests, download and upload tasks for large transfers, and background sessions that continue after the app is suspended. URLSession integrates with async/await in Swift, allowing network calls to be written as sequential async functions. -URLSession is a powerful and flexible API in iOS for handling HTTP and HTTPS network requests. It serves as the foundation for networking tasks in iOS applications, providing a rich set of features for data transfer over the internet. URLSession supports various types of tasks including data tasks for simple requests and responses, download tasks for file transfers, and upload tasks for sending data to servers. It offers both synchronous and asynchronous programming models, with the latter being particularly useful for maintaining responsive UIs during network operations. URLSession handles connection management, authentication, and caching automatically, simplifying complex networking scenarios. It integrates well with Swift's modern concurrency features like async/await, making asynchronous code more readable and maintainable. Developers can configure session behaviors, set up background transfers, and implement robust error handling and retry mechanisms using URLSession, making it a versatile tool for a wide range of networking needs in iOS development. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Fetching website data into memory](https://developer.apple.com/documentation/foundation/url_loading_system/fetching_website_data_into_memory) -- [@video@Networking in iOS with URLSession](https://www.youtube.com/watch?v=zvfViYmETuc) -- [@article@URLSession in Swift](https://janviarora.medium.com/urlsession-in-swift-f0f7348e37d5) \ No newline at end of file +- [@article@URLSession in Swift](https://janviarora.medium.com/urlsession-in-swift-f0f7348e37d5) +- [@video@Networking in iOS with URLSession](https://www.youtube.com/watch?v=zvfViYmETuc) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/user-defaults@ImS1FqVicQImMw-y1ze7y.md b/src/data/roadmaps/ios/content/user-defaults@ImS1FqVicQImMw-y1ze7y.md index ea89ebf6e..2e2c364aa 100644 --- a/src/data/roadmaps/ios/content/user-defaults@ImS1FqVicQImMw-y1ze7y.md +++ b/src/data/roadmaps/ios/content/user-defaults@ImS1FqVicQImMw-y1ze7y.md @@ -1,8 +1,8 @@ # User Defaults + +User Defaults is a simple key-value store for persisting lightweight user preferences and settings across app launches. It stores basic types like strings, numbers, booleans, and dates in a plist file. User Defaults is not suitable for sensitive or large data and is intended only for small configuration values. -User Defaults in iOS provides a convenient way to store small amounts of key-value data persistently across app launches. It's primarily used for saving user preferences, app settings, and other lightweight data. The `UserDefaults` class offers a standardized interface to interact with the defaults system, allowing easy storage and retrieval of basic data types like strings, numbers, dates, and even more complex objects that conform to the Codable protocol. Data stored in User Defaults is automatically persisted to disk, making it readily available in subsequent app launches. While User Defaults is easy to use and efficient for small datasets, it's not suitable for storing large amounts of data or sensitive information. It's important to use User Defaults judiciously, as overuse can impact app launch times and performance. For more complex data structures or larger datasets, other persistence mechanisms like Core Data or file-based storage are more appropriate. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@UserDefaults](https://developer.apple.com/documentation/foundation/userdefaults) - [@article@Reading and Writing basics: UserDefaults](https://www.hackingwithswift.com/read/12/2/reading-and-writing-basics-userdefaults) diff --git a/src/data/roadmaps/ios/content/user-interactions@GKuxilB0AwjcTgCSk3FeU.md b/src/data/roadmaps/ios/content/user-interactions@GKuxilB0AwjcTgCSk3FeU.md index f7d5b79b5..a2703b249 100644 --- a/src/data/roadmaps/ios/content/user-interactions@GKuxilB0AwjcTgCSk3FeU.md +++ b/src/data/roadmaps/ios/content/user-interactions@GKuxilB0AwjcTgCSk3FeU.md @@ -2,7 +2,7 @@ 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: +Visit the following resources to learn more: - [@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/) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/version-control@sGnDm2xuJxqfU3pwmlY7H.md b/src/data/roadmaps/ios/content/version-control@sGnDm2xuJxqfU3pwmlY7H.md index 9264689e7..4c4c58740 100644 --- a/src/data/roadmaps/ios/content/version-control@sGnDm2xuJxqfU3pwmlY7H.md +++ b/src/data/roadmaps/ios/content/version-control@sGnDm2xuJxqfU3pwmlY7H.md @@ -1,11 +1,10 @@ # Version Control + +Version control enables developers to track changes to code over time and collaborate with others. Git is the standard version control tool for iOS projects, and GitHub is the most common hosting platform for iOS team repositories and open-source libraries. -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: +Visit the following resources to learn more: - [@roadmap@Visit Dedicated Git & GitHub Roadmap](https://roadmap.sh/git-github) -- [@article@What is Version Control?](https://www.atlassian.com/git/tutorials/what-is-version-control) -- [@video@Version Control System (VCS)](https://www.youtube.com/watch?v=SVkuliabq4g) -- [@video@What is a Version Control System and why you should always use it](https://www.youtube.com/watch?v=IeXhYROClZk) - [@course@Why version control? (Interactive Lesson)](https://inter-git.com/lessons/introduction) +- [@article@What is Version Control?](https://www.atlassian.com/git/tutorials/what-is-version-control) +- [@video@Version Control System (VCS)](https://www.youtube.com/watch?v=SVkuliabq4g) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/view-controllers@mfWdkUm1RhjygtMyInXiD.md b/src/data/roadmaps/ios/content/view-controllers@mfWdkUm1RhjygtMyInXiD.md index 4700dd2dd..4b989f2cf 100644 --- a/src/data/roadmaps/ios/content/view-controllers@mfWdkUm1RhjygtMyInXiD.md +++ b/src/data/roadmaps/ios/content/view-controllers@mfWdkUm1RhjygtMyInXiD.md @@ -1,8 +1,8 @@ # View Controllers + +A UIViewController manages a single screen of content in a UIKit app. It owns a root view, handles the lifecycle events for that view, and coordinates between the model layer and the UI. View controllers are the primary structural unit in UIKit apps and the main place for screen-level logic. -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: +Visit the following resources to learn more: - [@official@View Controllers](https://developer.apple.com/documentation/uikit/view_controllers) - [@video@UIKit View Controllers](https://www.youtube.com/watch?v=WuSesaZcaMQ) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/view-transitions@2tmR1yE5daz2HB4IV5qwI.md b/src/data/roadmaps/ios/content/view-transitions@2tmR1yE5daz2HB4IV5qwI.md index 0aa2423cd..813b43a8c 100644 --- a/src/data/roadmaps/ios/content/view-transitions@2tmR1yE5daz2HB4IV5qwI.md +++ b/src/data/roadmaps/ios/content/view-transitions@2tmR1yE5daz2HB4IV5qwI.md @@ -1,8 +1,8 @@ # View Transitions + +View transitions in SwiftUI animate changes in the view hierarchy when views appear or disappear. The transition modifier specifies how a view enters and exits the screen using effects like slide, opacity, scale, and move. Combined with animation, transitions make state changes and navigation feel smooth and polished. -SwiftUI view transitions provide a fluid and intuitive way to animate changes in the user interface, enhancing the overall user experience. These transitions can be applied to individual views or entire view hierarchies, allowing developers to create smooth animations for appearance, disappearance, and modification of UI elements. SwiftUI offers a range of built-in transition effects, such as fade, move, and scale, which can be easily customized and combined to create more complex animations. By leveraging the `.transition()` modifier, developers can specify how views enter and exit the screen, while the `animation()` modifier controls the timing and style of these transitions. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@article@How to add and remove views with a transition](https://www.hackingwithswift.com/quick-start/swiftui/how-to-add-and-remove-views-with-a-transition) -- [@course@Animating views and transitions ](https://developer.apple.com/tutorials/swiftui/animating-views-and-transitions) \ No newline at end of file +- [@course@Animating views and transitions](https://developer.apple.com/tutorials/swiftui/animating-views-and-transitions) +- [@article@How to add and remove views with a transition](https://www.hackingwithswift.com/quick-start/swiftui/how-to-add-and-remove-views-with-a-transition) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/view-transitions@cwVcNDTBBulBY2m4Wzn4G.md b/src/data/roadmaps/ios/content/view-transitions@cwVcNDTBBulBY2m4Wzn4G.md index de5f193b9..2419a5474 100644 --- a/src/data/roadmaps/ios/content/view-transitions@cwVcNDTBBulBY2m4Wzn4G.md +++ b/src/data/roadmaps/ios/content/view-transitions@cwVcNDTBBulBY2m4Wzn4G.md @@ -1,8 +1,8 @@ # View Transitions + +View transitions control how the app animates when moving between screens. UIKit provides built-in transition styles like push and modal presentation, and custom transitions are created using the UIViewControllerAnimatedTransitioning protocol. Transitions provide visual continuity that helps users understand where they are in the app. -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. +Visit the following resources to learn more: -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) +- [@article@View Controller Transitions](https://developer.apple.com/documentation/uikit/animation_and_haptics/view_controller_transitions) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/viewcontroller-lifecycle@DZaY060-5D6PbfryOZH9H.md b/src/data/roadmaps/ios/content/viewcontroller-lifecycle@DZaY060-5D6PbfryOZH9H.md index 2adb1e9a1..c9b159a2a 100644 --- a/src/data/roadmaps/ios/content/viewcontroller-lifecycle@DZaY060-5D6PbfryOZH9H.md +++ b/src/data/roadmaps/ios/content/viewcontroller-lifecycle@DZaY060-5D6PbfryOZH9H.md @@ -1,8 +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. +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: +Visit the following resources to learn more: -- [@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) +- [@article@ViewController Life Cycle in iOS](https://medium.com/@knoo/viewcontroller-life-cycle-in-ios-29f7da4acfc7) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/views-and-modifiers@mgUCYztUpKINqIZikT4Bh.md b/src/data/roadmaps/ios/content/views-and-modifiers@mgUCYztUpKINqIZikT4Bh.md index 49aa4d14f..6b80aad3d 100644 --- a/src/data/roadmaps/ios/content/views-and-modifiers@mgUCYztUpKINqIZikT4Bh.md +++ b/src/data/roadmaps/ios/content/views-and-modifiers@mgUCYztUpKINqIZikT4Bh.md @@ -1,11 +1,10 @@ # Views and Modifiers + +SwiftUI views are lightweight structs that describe a piece of UI. Modifiers are methods called on views that return a new, modified version, allowing chaining. Common modifiers include padding, frame, background, foregroundStyle, and font. Building layouts by composing views and chaining modifiers is the primary pattern in SwiftUI development. -SwiftUI views and modifiers form the core of UI development in the framework. Views are structs conforming to the View protocol, representing visual elements of the interface. They are lightweight, value types that describe the content and layout. Modifiers are methods called on views to adjust their appearance or behavior, such as changing colors, adding padding, or attaching gestures. These modifiers return new view instances, allowing for a chain of modifications. SwiftUI uses a declarative approach where views and modifiers are composed to create complex UI elements. The system efficiently manages view updates and redraws based on state changes. Custom views can be easily created by combining existing views and modifiers, promoting code reuse and maintainability. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Views and modifiers: Documentation](https://developer.apple.com/documentation/swiftui/viewmodifier) - [@official@Apple Tutorials: Views - Using stacks to arrange views](https://developer.apple.com/tutorials/app-dev-training/using-stacks-to-arrange-views) - [@official@Apple Tutorials: Views - Creating a card view](https://developer.apple.com/tutorials/app-dev-training/creating-a-card-view) -- [@official@Apple Tutorials: Views - Displaying data in a list](https://developer.apple.com/tutorials/app-dev-training/displaying-data-in-a-list) - [@article@Views and modifiers: Introduction](https://www.hackingwithswift.com/books/ios-swiftui/views-and-modifiers-introduction) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/views-view-controllers@XX5rCd_yTHvOfYif4Kpbl.md b/src/data/roadmaps/ios/content/views-view-controllers@XX5rCd_yTHvOfYif4Kpbl.md index 6ad45ccc3..0e26ee4a6 100644 --- a/src/data/roadmaps/ios/content/views-view-controllers@XX5rCd_yTHvOfYif4Kpbl.md +++ b/src/data/roadmaps/ios/content/views-view-controllers@XX5rCd_yTHvOfYif4Kpbl.md @@ -1,13 +1,9 @@ # Views, View Controllers + +Views and view controllers are the two primary building blocks of UIKit's architecture. Views are responsible for displaying content and receiving touch input, while view controllers manage a screen's lifecycle and coordinate between views and data. Every visible screen in a UIKit app is managed by at least one view controller with an associated view hierarchy. -UIKit Views and View Controllers are fundamental components in iOS app development. - -Views (UIView) are the basic building blocks of user interfaces, representing rectangular areas that can display content and respond to user interactions. They can be customized, combined, and nested to create complex layouts. Common subclasses include UILabel, UIButton, and UIImageView. - -View Controllers (UIViewController) manage a set of views and coordinate the flow of data between the app's data model and the views. They handle view lifecycle, respond to user actions, and manage transitions between different parts of the user interface. View controllers are crucial for organizing app structure and maintaining separation of concerns in UIKit-based applications. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@UIView Documentation](https://developer.apple.com/documentation/uikit/uiview) - [@official@UIkit View Controllers](https://developer.apple.com/documentation/uikit/view_controllers) -- [@video@Intro to UIKit and UIViews](https://www.youtube.com/watch?v=w58ncTHKiK4) +- [@video@Intro to UIKit and UIViews](https://www.youtube.com/watch?v=w58ncTHKiK4) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/views@se9w7mT1XJLGlmWUhH4Uv.md b/src/data/roadmaps/ios/content/views@se9w7mT1XJLGlmWUhH4Uv.md index 0e52e44b2..325c89eab 100644 --- a/src/data/roadmaps/ios/content/views@se9w7mT1XJLGlmWUhH4Uv.md +++ b/src/data/roadmaps/ios/content/views@se9w7mT1XJLGlmWUhH4Uv.md @@ -2,8 +2,8 @@ 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: +Visit the following resources to learn more: - [@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) \ No newline at end of file +- [@article@Performing iOS Animations On Views With UIKit And UIView](https://www.smashingmagazine.com/2019/11/performing-ios-animations-views-uikit-uiview) +- [@video@Intro to UIKit and UIViews](https://www.youtube.com/watch?v=w58ncTHKiK4) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/viper@mTdnDPGYSDupM9VBNdXRg.md b/src/data/roadmaps/ios/content/viper@mTdnDPGYSDupM9VBNdXRg.md index 90476906c..5d37ae875 100644 --- a/src/data/roadmaps/ios/content/viper@mTdnDPGYSDupM9VBNdXRg.md +++ b/src/data/roadmaps/ios/content/viper@mTdnDPGYSDupM9VBNdXRg.md @@ -1,21 +1,9 @@ # VIPER + +VIPER is an architectural pattern that divides app code into five distinct components: View, Interactor, Presenter, Entity, and Router. Each component has a single, clearly defined responsibility, making the codebase highly modular and testable. VIPER is commonly used in large iOS projects where strict separation of concerns is a priority. -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: +Visit the following resources to learn more: -**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) \ No newline at end of file +- [@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) +- [@video@Swift: VIPER Design Pattern](https://www.youtube.com/watch?v=hFLdbWEE3_Y) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/voice-over@trAMZVA4tDB7b_qAgiWNW.md b/src/data/roadmaps/ios/content/voice-over@trAMZVA4tDB7b_qAgiWNW.md index c58b6099f..1e1195da6 100644 --- a/src/data/roadmaps/ios/content/voice-over@trAMZVA4tDB7b_qAgiWNW.md +++ b/src/data/roadmaps/ios/content/voice-over@trAMZVA4tDB7b_qAgiWNW.md @@ -1,11 +1,8 @@ # Voice Over - -VoiceOver is an assistive technology that enables people to experience the interface on their devices without having to see the screen. People who are blind or have low vision depend on VoiceOver to provide auditory feedback while using their devices, but VoiceOver can be useful to people in a wide variety of contexts. For example, someone prone to motion sickness might choose to turn VoiceOver on while they’re in a moving vehicle. - -VoiceOver is a screen reader that enables people to experience an app’s interface without having to see the screen. With touch gestures on iOS and iPadOS, keyboard buttons on macOS, and remote buttons on tvOS, VoiceOver users can move through your app’s UI in reading order, from the top of the screen to the bottom, and receive descriptions in over 60 languages and locales of UI controls, text, and images audibly or in braille. - + +VoiceOver is iOS's built-in screen reader that allows users who are blind or have low vision to navigate and interact with apps using gestures and spoken audio feedback. Apps support VoiceOver by providing accessibility labels, traits, and hints on UI elements. Testing with VoiceOver enabled is essential for verifying an accessible user experience. Visit the following resources to learn more: - [@official@VoiceOver](https://developer.apple.com/documentation/accessibility/voiceover/) -- [@official@Supporting VoiceOver in your app](https://developer.apple.com/documentation/uikit/accessibility_for_uikit/supporting_voiceover_in_your_app) +- [@official@Supporting VoiceOver in your app](https://developer.apple.com/documentation/uikit/accessibility_for_uikit/supporting_voiceover_in_your_app) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/xcframework@MaHtZSIPxDzrnB33_9OdV.md b/src/data/roadmaps/ios/content/xcframework@MaHtZSIPxDzrnB33_9OdV.md index 1c87e360e..a89ec25c3 100644 --- a/src/data/roadmaps/ios/content/xcframework@MaHtZSIPxDzrnB33_9OdV.md +++ b/src/data/roadmaps/ios/content/xcframework@MaHtZSIPxDzrnB33_9OdV.md @@ -1,8 +1,8 @@ # XCFramework + +An XCFramework is a distributable binary format that bundles frameworks for multiple platforms and architectures in a single package. It supports iOS devices, iOS Simulator, macOS, and other Apple platforms simultaneously. XCFrameworks are the recommended format for distributing precompiled iOS libraries and SDKs. -XCFramework is an advanced packaging format introduced by Apple for distributing binary frameworks in iOS, macOS, tvOS, and watchOS development. It addresses limitations of traditional .framework bundles by supporting multiple architectures and platforms within a single package. XCFrameworks can contain binary code for different platforms and architectures, including simulators and devices, making them ideal for distributing cross-platform libraries. They simplify the integration process, eliminating the need for manual management of different framework versions for various platforms. XCFrameworks support both static and dynamic libraries and can include resources like headers, assets, and documentation. This format is particularly beneficial for library developers, as it allows them to distribute a single package that works across different Apple platforms and architectures. For app developers, XCFrameworks offer smoother integration of third-party dependencies, reducing compatibility issues and simplifying the build process in Xcode projects. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Creating a multiplatform binary framework bundle](https://developer.apple.com/documentation/xcode/creating-a-multi-platform-binary-framework-bundle) - [@official@Distributing binary frameworks as Swift packages](https://developer.apple.com/documentation/xcode/distributing-binary-frameworks-as-swift-packages) diff --git a/src/data/roadmaps/ios/content/xcode-debugger@WxshXCloVDkVkQV0JvI1w.md b/src/data/roadmaps/ios/content/xcode-debugger@WxshXCloVDkVkQV0JvI1w.md index 50e2fca02..5d6ae0320 100644 --- a/src/data/roadmaps/ios/content/xcode-debugger@WxshXCloVDkVkQV0JvI1w.md +++ b/src/data/roadmaps/ios/content/xcode-debugger@WxshXCloVDkVkQV0JvI1w.md @@ -1,8 +1,8 @@ # Xcode Debugger + +The Xcode debugger allows developers to pause execution at breakpoints, inspect variable values, evaluate expressions using LLDB commands in the console, and step through code line by line. The debug area displays the current thread, call stack, and local variable state during a paused session. -The Xcode Debugger is an essential tool for iOS developers, providing capabilities to diagnose and resolve issues within the code. It allows setting breakpoints to pause the execution at specific lines, enabling the inspection of variable states and program flow. Developers can step over, into, or out of functions to closely examine the logic. The LLDB (Low-Level Debugger) console supports powerful commands for deeper inspection and manipulation of the app’s state. The debugger also includes features like view debugging to analyze the UI hierarchy and memory graph debugging to detect memory leaks and retain cycles, making it a comprehensive tool for troubleshooting and optimizing iOS applications. +Visit the following resources to learn more: -Learn more from the following resources: - -- [@video@Debugging in Xcode](https://www.youtube.com/watch?v=ZAqnJQn7xp4) -- [@article@Xcode Debug Console Tour: Exploring All Options](https://www.avanderlee.com/xcode/xcode-debug-console/) \ No newline at end of file +- [@article@Xcode Debug Console Tour: Exploring All Options](https://www.avanderlee.com/xcode/xcode-debug-console/) +- [@video@Debugging in Xcode](https://www.youtube.com/watch?v=ZAqnJQn7xp4) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/xcode@la5M4VoH79bhnN8qj5Izp.md b/src/data/roadmaps/ios/content/xcode@la5M4VoH79bhnN8qj5Izp.md index 750164a25..be816d49c 100644 --- a/src/data/roadmaps/ios/content/xcode@la5M4VoH79bhnN8qj5Izp.md +++ b/src/data/roadmaps/ios/content/xcode@la5M4VoH79bhnN8qj5Izp.md @@ -2,10 +2,9 @@ Xcode is Apple’s integrated development environment (IDE) for macOS, used to develop software for iOS, macOS, watchOS, and tvOS. It includes a suite of tools for designing user interfaces, writing and testing code, and debugging applications. Xcode supports multiple programming languages such as Swift and Objective-C and offers features like a source editor, version control, performance analysis, and extensive documentation, making it a comprehensive platform for developing Apple ecosystem apps. -Learn more from the following resources: +Visit the following resources to learn more: - [@official@Xcode Documentation](https://developer.apple.com/xcode/) -- [@video@Xcode 15 Tutorial for Beginners (2024)](https://www.youtube.com/watch?v=8Xcq4yRQ0pU\&pp=ygUTeGNvZGUgdHV0b3JpYWwgMjAyNA%3D%3D) - [@official@WWDC24: What’s new in Xcode 16](https://www.youtube.com/watch?v=BAQ9EhAm2eM) - [@official@WWDC24: Xcode essentials](https://www.youtube.com/watch?v=EN7-6Oj7cL0) -- [@feed@Explore top posts about Xcode](https://app.daily.dev/tags/xcode?ref=roadmapsh) +- [@video@Xcode 15 Tutorial for Beginners (2024)](https://www.youtube.com/watch?v=8Xcq4yRQ0pU&pp=ygUTeGNvZGUgdHV0b3JpYWwgMjAyNA%3D%3D) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/xctest@xZmBJVq5FHNdm1BDuZbbS.md b/src/data/roadmaps/ios/content/xctest@xZmBJVq5FHNdm1BDuZbbS.md index d780e81c1..3b9388b26 100644 --- a/src/data/roadmaps/ios/content/xctest@xZmBJVq5FHNdm1BDuZbbS.md +++ b/src/data/roadmaps/ios/content/xctest@xZmBJVq5FHNdm1BDuZbbS.md @@ -1,7 +1,7 @@ # XCTest + +XCTest is Apple's framework for writing unit tests in Swift and Objective-C. Tests are organized into subclasses of XCTestCase, and individual test methods begin with "test". XCTest integrates with Xcode's Test Navigator for running tests, viewing results, and measuring code coverage against the app's source. -XCTest is Apple's framework for writing and running unit tests, performance tests, and UI tests in iOS, macOS, watchOS, and tvOS applications. It allows developers to create test cases and test methods to verify the correctness of their code, ensuring that individual components function as expected. XCTest supports assertions to check for expected outcomes, and it can run tests in parallel to speed up the testing process. For UI testing, XCTest provides capabilities to record user interactions and generate corresponding test scripts, which can be replayed to simulate user behavior. Additionally, XCTest integrates seamlessly with Xcode's testing infrastructure, providing detailed reports and continuous integration support to maintain code quality and performance throughout the development lifecycle. - -Learn more from the following resources: +Visit the following resources to learn more: - [@official@XCTest](https://developer.apple.com/documentation/xctest) \ No newline at end of file diff --git a/src/data/roadmaps/ios/content/xcuitest@ZQSUKPbXZl5yKra2ap8JR.md b/src/data/roadmaps/ios/content/xcuitest@ZQSUKPbXZl5yKra2ap8JR.md index 1c33dd3c8..7e3caa3d7 100644 --- a/src/data/roadmaps/ios/content/xcuitest@ZQSUKPbXZl5yKra2ap8JR.md +++ b/src/data/roadmaps/ios/content/xcuitest@ZQSUKPbXZl5yKra2ap8JR.md @@ -1,8 +1,8 @@ # XCUITest + +XCUITest is the UI testing component of XCTest that automates user interactions with a running iOS app. Tests launch the app, query elements by accessibility identifier or type, perform actions like tap, swipe, and type, and assert on UI state. XCUITest runs on a simulator or physical device and is slower than unit tests due to the app launch and interaction overhead. -XCUITest is a robust framework within XCTest designed specifically for automated UI testing of iOS applications. It allows developers to create tests that simulate user interactions with the app's interface, ensuring that the UI behaves correctly under various conditions. Using XCUITest, developers can write tests in Swift or Objective-C to tap buttons, enter text, swipe, and perform other gestures. The framework provides a recording feature to capture user actions and generate corresponding test code, simplifying the creation of test scripts. XCUITest integrates seamlessly with Xcode, enabling easy setup, execution, and debugging of UI tests. It supports running tests on multiple devices and simulators, providing detailed logs and screenshots to help diagnose issues, thus ensuring a consistent and reliable user experience. - -Learn more from the following resources: +Visit the following resources to learn more: - [@article@Getting Started with XCUITest](https://www.browserstack.com/guide/getting-started-xcuitest-framework) - [@article@Learn the Fundamentals of XCUITest Framework](https://www.headspin.io/blog/a-step-by-step-guide-to-xcuitest-framework) diff --git a/src/data/roadmaps/ios/content/xibs@RwvC4Pi18_1phcrJL-9iu.md b/src/data/roadmaps/ios/content/xibs@RwvC4Pi18_1phcrJL-9iu.md index a0ef33060..dad6e7695 100644 --- a/src/data/roadmaps/ios/content/xibs@RwvC4Pi18_1phcrJL-9iu.md +++ b/src/data/roadmaps/ios/content/xibs@RwvC4Pi18_1phcrJL-9iu.md @@ -1,8 +1,8 @@ # 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. +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: +Visit the following resources to learn more: - [@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/)