MOHAMED JABERI

SwiftUI Architecture Using Redux course! This course provided a deep dive into the Redux architecture and how it can be used to build scalable, maintainable apps with SwiftUI. I learned how to use the Redux pattern to manage app state, create composable and reusable views, and write testable code. I highly recommend this course to any developer looking to improve their skills and build better apps with SwiftUI. * Unidirectional Data Flow Using Redux Design Pattern in SwiftUI * Composable SwiftUI Apps Using Redux * Maintaining Global State, Actions, Multiple Reducers * Asynchronous Requests Using Middleware

Concurrency allows multiple tasks to run at the same time.  When used correctly, it can create a pleasant user experience and can even avoid crashing your app. In this course, you will learn about the new concurrency features available in Swift using Async/Await and Actors. * Understanding Concurrent Programming
 * Getting Started with Async & Await (Dates App)
 * Understanding MVVM Design Pattern
 * Dates App Using MVVM
 * Exposing your Functions as Async/Await Using Continuation
 * Understanding Structured Concurrency in Swift
 * Project: Random Images and Quotes
AsyncSequence
 * Actors
 * New async/await features of Swift language * Concurrency in Swift Using Actors * Exposing callback functions using continuation API * Running concurrent tasks using async-let and Task Groups * Writing modern asynchronous syntax using async/await

I learn in this course: - Publishers, Subscribers and Operators - Transforming Operators - Filtering Operators - Combining Operators - Sequence Operators - Combine for Networking - Debugging Combine - Combine Timers - Resources in Combine - Integrating Combine with UIKit Application - Weather App - Understanding MVVM Design Pattern - SwiftUI Basics - Understanding State and Binding - Hacker News - SwiftUI, Combine and Web API

Learn Unit Testing, Test Driven Development and Behavior Driven Development in iOS Using Swift Language: Code source on Github : https://github.com/mohamed-habib-jaberi/Testing-iOS-Apps.git Test Driven Development Types of Testing : * Unit Testing * User Interface Testing * Integration Testing * Acceptance Testing * Performance Testing
 Test Expectations : * Testing asynchronous code using Expectations * Multiple Expectations Dependency Injection and Mocks : * Using Fake, Mocks and Stubs * Mocking callbacks Behavior Driven Development * Using Gherkin language * Understanding The Outside-In Approach * Adding Cucumberish dependency * Writing Cucumberish test continued

Mastering RxSwift in iOS : - Understanding functional programming and RxSwift - Observables - Subjects - Implementing photo filter app using RxSwift - Filtering operators - Todo list app using filtering operators - Transforming operators - Building news app using transforming operators - Combining operators - Beginning RxCocoa - MVVM with RxSwift

Building New App Using MVVM Design Pattern : 1- Setting Up the User Interface 2- Implementing Web Services Layer 3- Creating and Decoding JSON to Models 4- Building ViewModels and Populating View Models 5- Persisting Settings and Converting Temperature Units 6- Setting Up Delegate to Pass Settings 7- Bindings : View to ViewModel Binding 8- Bindings : ViewModel to View Binding 9- Implementing WeatherDataSource 10- Implementing Generic Data Source 11- Unit Testing

We get after taking this Certification : - Master 40+ Six Sigma tools - Complete a realistic Lean Six Sigma Yellow Belt project in 6.5 hours - Add Minitab expertise to your skill set and analyze Six Sigma Yellow Bel project data - Become a pro at answering tough interviewer questions related to Lean Six Sigma Yellow Belt - Get access to 140+ Six Sigma pdf that are downloadable and review 30+ articles - Solve any business problem using Six Sigma principles, tools and techniques - Learn root-cause analysis techniques - Learn Graphical techniques using Minitab - Learn how to create a Lean Six Sigma Yellow Belt project storyboard - Receive trainer assistance using the Q&A Discussion board

Clean Architecture: Patterns, Practices, and Principles : - Clean Code - Invest in Clean Code - Domain-centric Architecture - Application Layer - Commands and Queries - Functional Organization - Microservices - Testable Architecture - Evolving the Architecture

Lean and Agile Enterprise Architecture: Getting Started 1- The CFBC Case Study: Introducing CFBC Case Study The Investigation What Really Transpired? 2- Understanding Lean Principles: Economics of Lean Wasteful Work & Overburden Variability and Queues 3- Strategic Agility: Strategy and VUCA World New Approaches to Strategy BMC, Strategy, & Sense-making 4- Innovation and Architecture: An Innovation Framework Shapes of Innovation Strategy, Innovation, and Architecture 5- Architecture Development Sprint: Quicksilver Case Study Traditional Process 6- Architectural Agility Transforming Legacy Architecture Microservices Architecture Realizing the Architecture Container Technologies Tools Walk-through Tools in Detail

Scrum Development with Jira & JIRAA Agile 1- Concepts of Scrum Development with Jira & Jira Agile : Agile Development Scrum Framework JIRA for Agile Scrum User Stories, Epics and Themes Product Owner, Scrum Master, Team Member Product Backlog Sprint Planning Meeting Daily Scrum Burndown Chart & Velocity Sprint Retrospective Sprint Review JIRA 2- Getting Started with Jira & Jira Agile : The Scrum Boards Project Overview and Administration Creating the Backlog 3- Sprint Planning & Sprint Retrospective: Sprint Planning Meeting Sprint Retrospective Meeting Sprint Review 4- Scrum & Sprints : Daily Scrum with Work Mode Work Mode Demo Report Mode Additional JIRA Reports

Structural Design Patterns in Swift 5 : - The Adapter Pattern - The Bridge Pattern - The Composite Pattern - The Decorator Pattern - The Façade Pattern - The Flyweight Pattern - The Proxy Pattern

Behavioral Design Patterns in Swift: - Chain of Responsibility Pattern - Command Pattern - Interpreter Pattern - Iterator Pattern - Mediator Pattern - Memento Pattern - Observer Pattern - State Pattern - Strategy Pattern - Template Method Pattern - Visitor Pattern

1- UI Testing : Creating a Simple UI Test Providing Access on Hard to Reach Elements Working with XCTAssert Handling the Delete Scenario 2- Unit Testing : Creating a Simple Unit Test Using setUp() and tearDown() Multiple Asserts Filling Gaps in Test Coverage 3- Advanced Testing Techniques : Global Variables Code Reuse Report Navigation and Test Coverage Debugging Tests Testing UITableView

iOS Auto Layout: Adaptive UIs for All Devices 1- Building a Dynamic User Interface : Too Many Screens Update Frames 2- Working with UIScrollView and Layout Guides : UIScrollView and Auto Layout Setting up UIScrollView UIScrollView's Content Properties View Controller's Layout Guides and Scroll Views Automatically Adjusts Scroll View Insets UILayoutSupport Protocol 3- Size Classes and Trait Collections Equal Spacing Techniques UILayoutGuide 4- Controlling Traits and Constraints UITraitEnvironments UITraitCollection Transitions 5- Leveraging Pseudo-languages for Internationalization UILabel's Number of Lines Double Length Pseudo language Remove Intrinsic Content's Width Flexible Height Right-to-Left Pseudo language 6- Supporting Accessibility with Dynamic Type UIFont Text Styles Setting Text Styles in Code Notifying Your App of Dynamic Type Changes 7- iPad Multitasking Better Readability UIView's Layout Guide Margins Responding to Other Apps Responding to Keyboard Notifications

Practical iOS Concurrency : 1- Creating and Using Blocks 2- Dispatch Queues : - Serial Queue - Concurrent Queue - Adding Tasks to a Queue 3- Operation Queues : - NSOperatios - KVO Compliance

Exploring the Pros and Cons of Design pattern UML,The Class Diagram Representing Relationships The Sequence Diagram 1- the Singleton : Implementing a Singleton Revealing Concurrency Problems Making Singleton Thread-safe Improving Performance Through Dispatch Berriers 2- The Prototype : Copying Value vc Reference Types Clonig Reference Type Implementing Shalow Copying Implementing Deep Copying 3- The Builder Pattern: Building Class the Wrong Way and Applying the Builder Pattern 4- The Factory Method : Exposing Too Many Types Applying the Factory Method 5- The Abstract Factory: A Tightly Coupled Class Implementing the Abstract Factory Removing the Unwanted Dependencies

1-Establishing the data Persistence Landscape : - Setting the Stage for Data Persistence - Persisting with a purpose - Encoding and Decoding Data 2- Saving Settings and Configuration : - Managing Preference with UserDefaults - Synchronize Setting with iCloud - Configuring Apps with Property List 3- Saving Objects and Object Graphs 4-Saving Data as Documents and Files : - Understing the Use Case - Designing a Document - Creating and Loading Documents - Customise App’s File Extension - Interacting with Document Data