Shady Yehia Selim, MSc,MBA

Full Stack React Native Developer 1. Databases:     - MongoDB, MySQL 2. Backend Framework:     - Express.js for RESTful APIs, middleware, routing, session management, and third-party API integration. 3. Frontend work:   - React Native: Cross-platform mobile app development.   - React.js for SPAs, component-based architecture, React hooks, state management (Redux, Context API), and client-side routing.   - Mobile UI/UX: Responsive design using React Native components.   - Navigation: React Navigation or Native Navigation experience 4. Backend Environment:     - Node.js for server-side execution, asynchronous programming, file handling, and WebSocket communication.   - Native Modules: Bridging native iOS/Android functionality.   - Push Notifications/Deep Linking: Firebase, OneSignal, deep linking. 5. Version Control:     - Git & GitHub for branching, merging, pull requests, and code collaboration. 6. API Design & Development:     - RESTful API design, JWT/OAuth authentication, API versioning, error handling, and GraphQL. 7. Authentication & Security:     - JWT, OAuth, bcrypt for password security, XSS, CSRF protection. 8. Frontend Design:     - HTML5, CSS3, JavaScript, responsive design (Bootstrap, Tailwind), and CSS preprocessors (SASS/SCSS). 9. State Management:     - Redux, React Context API, Redux-Thunk/Redux-Saga. 12. WebSockets:     - Real-time applications with Socket.io. 13. Performance Optimization:     - MongoDB indexing, React code-splitting, caching, load balancing. 14. Error Handling & Logging:     - Error handling across client/server, logging with Winston, and Morgan. 15. Soft Skills:     - Problem-solving, teamwork, time management, debugging.

٢

🚀 Kotlin Multiplatform Learning Roadmap 🚀 📚 Kotlin Basics - Variables, Functions, Classes, and Objects - Null Safety and Collections - Extensions and Lambdas 🔄 Kotlin Coroutines & Flow - Coroutine Basics and Builders - Suspending Functions and Scopes - Flow Basics and Operators 🛠️ Kotlin Multiplatform (KMP) Introduction - Understanding Multiplatform Projects - Common, Platform-Specific Code - Expect/Actual Mechanism 🚀 Setting Up a KMP Project - Creating a New Multiplatform Project - Configuring Gradle for KMP - Setting Up Android and iOS Targets 💻 Sharing Business Logic - Writing Common Business Logic - Shared Data Models and Repositories - Dependency Injection with Koin or Hilt 🌐 Networking in KMP - Ktor for Networking - Implementing REST API Calls - Handling JSON with Kotlinx Serialization 💾 Data Storage in KMP - Shared Preferences or Settings - SQLDelight for Multiplatform Databases - Working with Files and Caches 🔧 Platform-Specific Implementations - Expect/Actual Implementations for APIs - Using Platform-Specific Features (e.g., Camera, Location) - Integrating with Native Android/iOS Libraries 🧪 Multiplatform Testing - Unit Testing with Kotlin Test - Writing Platform-Specific Tests - Mocking and Dependency Injection in Tests 🎨 UI Development - Jetpack Compose for Android - SwiftUI or UIKit for iOS - Exploring Compose Multiplatform (Optional) 📦 Dependency Management - Managing Multiplatform Dependencies - Gradle Dependency Management - Library Compatibility and Versioning 🔍 Debugging & Optimization - Debugging Multiplatform Projects - Performance Tuning for KMP - Handling Platform-Specific Bugs ⚙️ Advanced KMP Topics - Multithreading and Concurrency in KMP - Interoperability with Java/Swift - Gradle Build Optimization 🚢 Deployment - Building for Android and iOS - App Store/Play Store Deployment - Continuous Integration/Continuous Deployment (CI/CD) 🌍 Community and Learning - Kotlin Multiplatform Forums and Groups - Attending Conferences and Meetups - Contributing to Open-Source Projects Happy learning! 📚 Learning Material https://lnkd.in/dGFVKmcu JetBrains Android Developers Google Developer Experts #androiddev #kotlin

١٢٨

ال Refactoring عملية مستمرة مش بس علشان نخلي الكود يشتغل، إنما علشان نحسّن الكود المكتوب كويس عشان يبقى أحسن. Refactoring المستمرة بتساعدنا نحسّن قابلية القراءة، نقلل التعقيد، ونحافظ على مستوى عالي من جودة الكود. لو دمجنا Refactoring في سير العمل اليومي بتاعنا، هنمنع تراكم الـ technical debt ونتأكد إن (codebase) تفضل قوية وقابلة للتوسع (scalable). مهم نلاحظ إن Refactoring مش إصلاح للأخطاء، ولا هوا تغيير الكود لحد ما يبقى خالي من الأخطاء. بالعكس، ده عن إعادة هيكلة الكود الحالي من غير ما نغيّر سلوكه الخارجي علشان نحسّن هيكله الداخلي. Refactoring is an ongoing process. It's not just about making code work, it's about enhancing well-written code to make it even better. Continuous refactoring helps us improve readability, reduce complexity, and maintain a high standard of code quality. By integrating refactoring into our regular development workflow, we prevent the buildup of technical debt and ensure our codebase remains robust and scalable. It's important to note that refactoring is not bug fixing, nor is it about changing code until it's free of errors. Instead, it's about restructuring existing code without altering its external behavior to improve its internal structure. “Driving is not about getting the car going in the right direction. Driving is about constantly paying attention, making a little correction this way, a little correction that way.” - Kent Beck (Extreme Programming, Embrace Change)

٤

What is DDD in .NET with Clean Architecture? In .NET, Domain-Driven Design (DDD) builds upon the foundation of Clean Architecture to provide guidelines for solving complex problems within the domain of software. By defining aggregates, entities, and value objects, DDD enables developers to model the core business concepts effectively. Leveraging features such as C# records and pattern matching enhances expressiveness, enabling developers to closely mirror domain models in their code. Advantages of Integrating Clean Architecture and DDD in .NET: Maintainability Testability Scalability I recommend that you learn more about DDD

١٣

That's a good visual flow of MVI architecture #kotlin #android #architecture #code #Success

١

ASP.Net Core Web API

٣

Implementing MVVM in SwiftUI: My Journey😍 In my latest project at the Apple Developer Academy | TUWAIQ , I applied the MVVM (Model-View-ViewModel) pattern to structure my code more effectively in Swift. Using MVVM allowed me to separate the Model, View, and ViewModel components, which helped make the app more manageable and scalable: • Model: Holds the core data and business logic. In my case, it stores the main data structure of the app. •View: The user interface, where users interact with tasks and data. MVVM made updating the UI much easier and faster for a smoother experience. •ViewModel: Serves as the bridge between Model and View. When data in the Model changes, the ViewModel automatically updates the View, so the app feels seamless and responsive. 🔄 💡 What I Learned: Implementing MVVM taught me how to organize code effectively, improve user experience, and make future updates or testing simpler. I’m excited to keep learning and refining this skill as I grow as a developer! 💪 #SwiftUI #MVVM #iOSDevelopment #AppleDeveloperAcademy

١٩

٢ تعليق

Three Types of Concurrency in Swift : Structural Concurrency: Execute one after another & if throws error , cancel & return . UnStructural Concurrency: Execute parallel but if throws 1 error, another will be canceled , then return to Parent Task . Detached Concurrency: Execute independently with priority #swift #concurrency #Task #ios #swiftUI #async #await

٤

iOS Interview - Understanding Dynamic Dispatch and Static Dispatch in Swift In Swift, the concept of dispatch refers to the process of determining which implementation of a method or function to call at runtime. Swift supports two types of dispatch: dynamic dispatch and static dispatch. Understanding the differences between these two dispatch mechanisms is crucial for writing efficient and maintainable Swift code. In this blog post, you’ll explore dynamic dispatch and static dispatch in detail, along with code examples to illustrate their usage. https://lnkd.in/dKAbWdZv #ios #iosdevelopment #swift #swiftui #swiftlang 

١٢٧

١ تعليق واحد

Microservices using ASP.NET Core Online Training with Real-time Application Development This Microservices using ASP.NET Core Online Training Program is entirely industry-oriented, and the concepts mostly used in the industry will be explained in depth. Please find the Course Details below: Course: Microservices using ASP.NET Core Web API Date and Time: 1st August, 2024, 8 PM to 9.30 PM, IST Contact Mobile/WhatsApp Number: 91 7021801173 Duration: 2 Months Contact Email: [email protected] Course Details Link: https://lnkd.in/gZ4cRK36 Join Our Telegram Group and ask anything: https://lnkd.in/g8Rwhz89 Registration Link: https://lnkd.in/gGsYTwme The following concepts will be covered in depth. Please find the detailed Course Syllabus in the attached PDF. Chapter 1: Understanding Monolithic Architecture Chapter 2: Microservices Architecture Chapter 3: Handling Data in Microservices Chapter 4: API Gateway Pattern Chapter 5: Setup Microservice Based Application and Perform CRUD Operations Chapter 6: Build UI Service Chapter 7: Introduction to Containers and Docker Chapter 8: Developing Docker Custom Images using .NET Core Chapter 9: Docker Compose Chapter 10: Hosting Microservices using Docker Containers Chapter 11: Using Redis Cache in Microservices Chapter 12: Introduction to Web Sockets and Kafka Chapter 13: WebSocket Basics with .NET Core Chapter 14: Kafka Basics with .NET Core Chapter 15: Implementing Security for Microservices Chapter 16: Understanding OAuth2, OpenIdConnect, and Identity Chapter 17: Implementing the CQRS Pattern Chapter 18: Vertical/Clean Architecture Chapter 19: MassTransit Chapter 20: YARP Gateway Chapter 21: RabbitMQ with ASP.NET Core Web API Chapter 22: Handling Failures Chapter 23: Microservices Deployment in App Services Chapter 24: Monitoring and Observability Chapter 25: Performance Optimization Chapter 26: Advanced Topics in Microservices Chapter 27: Azure CI/CD Pipeline for .NET Core Web API

٢

#architecture #software #layer #domain #backend 💡when use Clean Architecture you should have some layers such as Domain Layer in this layer the solid folder structure is : ✅Contracts / Interfaces : all interfaces or abstraction layers that used in DomainServices. ✅DomainServices : all business behavior that need more than one entity or services to do Something in business scope. ✅Entities : all types identified by Id or any unique data (data + behavior) and most of the time is mutable. ✅Exceptions : all business exceptions. ✅ValueObjects : all types identified by its value not Id or any unique data and most of the time is immutable.

٤٤

١٠ تعليق

Best Practices for Improving Performance of ASP.NET Core Applications: Use caching: HTTP-based response caching Set by the Cache-Control header Distributed cache Use a distributed cache to store data that needs fast access. Caching with third-party libraries For example, Redis Cache In-memory caching In-memory caching uses the server's memory to store cached data. This type of caching is suitable for one or more servers.  Cache Tag Helper Use cache tag helper in MVC applications, for example: <cache expires-after="@TimeSpan.FromSeconds(120)"> Current Time Inside Cache Tag Helper: @DateTime.Now </cache> Always use asynchronous programming and avoid blocking requests: Recommendations: X  Do not use: Method calls that can block asynchronous calls by exiting Task.Wait orTask.Result. Avoid blocking at all stages of application development. ASP.NET Core is designed to run everything asynchronously. ✔  Use  Make 'hot code path' locations asynchronous. Make requests to the Data access layer and long API operations asynchronously. Make Controller methods asynchronous. The entire call stack is asynchronous, allowing you to take advantage of async/await patterns. Minimize large object allocations: Recommendations: X  Don't create  many large short-lived objects in the 'hot code path. ✔  Use  caching of large objects that are frequently used. Caching of large objects prevents expensive allocations. You can also use one of the classic  Flyweight patterns to work with such objects. ✔  Use ArrayPool<T>  for storing large arrays. Using a class ArrayPool<T> to "rent" and "return" buffers (using the Rent and Return methods) can improve performance in situations where arrays are frequently created and destroyed, resulting in significant memory pressure on the garbage collector. Optimizing Data Access Layer Efficient reading and writing of data is essential for good performance. Recommendations: ✔  Use  asynchronous requests to the Data access layer. ✔  Use  caching of frequently used data retrieved from a database or remote service (if business logic allows it). Depending on the scenario, use MemoryCache or DistributedCache. For more information, see Use Caching . ✔  Minimize  the number of requests to get data (the goal is to get data in one request, without making multiple requests) ✔  Use  LINQ query filtering and aggregation (for example, using .Where, .Select, or .Sum operators) to let the database do the filtering. X  Don't request  more data than necessary. Your requests should return only the data that is needed for the current HTTP request. X  Avoid  more than N + 1 problems

٣

ASP.NET CORE (Repository Pattern) The Repository Pattern is a design pattern in software development that acts as an intermediate layer between the business logic and the data access layer. In the context of ASP.NET Core, the repository pattern abstracts direct interactions with the database or ORM (such as Entity Framework) and centralizes these operations in a repository interface. This helps maintain cleaner, decoupled, and easily testable code. Benefits of the Repository Pattern 1. Decoupling: The Repository Pattern decouples business logic from data access logic. This means that controllers or services do not depend on implementation details of the ORM (such as Entity Framework), but instead interact with an abstraction (the repository). 2. Testability: By decoupling data access through interfaces, it becomes easier to perform unit testing through dependency injection and the use of mocks for testing services and business logic. By mocking the repository, you can avoid accessing the real database during testing. 3. Code Reuse: By having a generic repository, you can reuse it for several entities. Additionally, it is possible to have a specialized repository that extends the functionalities of the generic repository. 4. Maintenance: If you ever want to change data access technology (for example, switching from Entity Framework to Dapper), you only need to modify the repository implementations without affecting the rest of the system. 5. Centralization of Data Access Logic: The repository pattern centralizes all database access in one place, facilitating change management and improving consistency in data operations. 6. Complies with the Dependency Inversion Principle (DIP): The Repository Pattern follows one of the SOLID principles (DIP), where dependencies are directed towards abstractions (interfaces) instead of concrete implementations. This allows for a higher level of flexibility and modularity.

٤

Hello .NET Developers, Today, we are going to discuss the first primary challenge: 𝐃𝐞𝐟𝐢𝐧𝐢𝐧𝐠 𝐌𝐢𝐜𝐫𝐨𝐬𝐞𝐫𝐯𝐢𝐜𝐞 𝐁𝐨𝐮𝐧𝐝𝐚𝐫𝐢𝐞𝐬 𝐏𝐚𝐫𝐭 𝟏. Some important points to consider are: 1-𝐌𝐞𝐚𝐧𝐢𝐧𝐠𝐟𝐮𝐥 𝐒𝐞𝐩𝐚𝐫𝐚𝐭𝐢𝐨𝐧 𝐎𝐯𝐞𝐫 𝐆𝐫𝐚𝐧𝐮𝐥𝐚𝐫𝐢𝐭𝐲: The primary goal is not to achieve the smallest possible microservices but to ensure meaningful separations based on business capabilities and domain knowledge. 2-𝐂𝐨𝐡𝐞𝐬𝐢𝐨𝐧 𝐚𝐧𝐝 𝐃𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐢𝐞𝐬: High cohesion within a service and minimal dependencies across services indicate well-defined boundaries. Services with a high number of interdependencies should be considered for merging. 3-𝐈𝐭𝐞𝐫𝐚𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐜𝐞𝐬𝐬: Determining the right size and boundaries for microservices is an iterative process. As you gain more domain knowledge, you should adapt the boundaries and sizes accordingly. 𝐻𝑎𝑣𝑒 𝑦𝑜𝑢 𝑓𝑎𝑐𝑒𝑑 𝑎𝑛𝑦 𝑐ℎ𝑎𝑙𝑙𝑒𝑛𝑔𝑒𝑠 𝑤𝑖𝑡ℎ 𝑡ℎ𝑖𝑠 𝑖𝑛 𝑦𝑜𝑢𝑟 𝑝𝑟𝑜𝑗𝑒𝑐𝑡𝑠? 𝑆ℎ𝑎𝑟𝑒 𝑦𝑜𝑢𝑟 𝑒𝑥𝑝𝑒𝑟𝑖𝑒𝑛𝑐𝑒𝑠 𝑖𝑛 𝑡ℎ𝑒 𝑐𝑜𝑚𝑚𝑒𝑛𝑡𝑠 𝑏𝑒𝑙𝑜𝑤! #mgendi #DOTNET #Microservices #Azure

٢٥

١ تعليق واحد

A good overview of SaveChanges in Entity Framework Core (EF Core)

٤

💡Discover 10 Must Flutter Widgets  📞 𝐈𝐧𝐟𝐨𝐥𝐢𝐧𝐞: (+𝟐𝟏𝟔) 𝟐𝟗 𝟕𝟖𝟏 𝟒𝟕𝟑 / 𝟕𝟑 𝟑𝟔𝟎 𝟔𝟏𝟔   #flutter #widgets #JobGate #Job #Bootcamp #Formation #Reconversion #flutter

١

Great insights on the Domain-Driven Design (DDD) approach. A fundamental principle in microservices strategy is business modeling, and using DDD enables predictability in isolating domain contexts. The good news is that the Devprime platform applies 100% DDD in business classes in practice and enables the development of the first microservice in minutes. Follow: Devprime Try it free now: https://devprime.io #devprime #ddd #domain #software #microservices #microsservicos #cloud #cloudnative #dotnet #visualstudio #csharp #startup #startupfounder #startupinvestment #startupfunding #dx #developerproductivity #developerengineer #softwareengineer

١٦