SBS - Specialized Business Solutions

Technical Team Lead

Gallup

Senior Software Engineer

BlackStone eIT

• Reviewed project specifications and designed technology solutions that met or exceeded performance expectations.
• Prepared detailed reports on updates to project specifications, progress, finding conflicts, and team activities.
• Communicated technical development stages and supplied design support to businesses and other stakeholders encouraging participation for on-time execution.
• Worked closely with software development and testing team members to design and develop robust solutions to meet client requirements for functionality, scalability, and performance.

EPAM Systems

• Assigned to financing projects and collaborating with EPAM international team.
• Managed to enhance my skills with internal & external courses.
• Got Microsoft Azure Certified Developer certification to apply to big projects required by relevant clients.
• Collaborated with team members to enter join EPAM internal competition.

Software Engineer ||

Software Engineer II

Crossworkers -Egypt

• Discuss best practices to implement new features and fixing current issues.
• Enhance and optimize legacy code performance.
• Performance tuning and optimization to handle huge data processing.
• Optimize Query execution using SQL performance tools.
• Code refactoring and peer review within the team.
• Participate in product development road-map, features planning and estimating, status monitoring and reporting.

Senior .Net Developer

Nokia

• Developed and participate in developing back-end and mobile app for subcontractors.
• Enhance and optimize legacy code performance.
• Optimize Query execution using SQL performance tools.

Senior Software Developer

ISnSC

• Working as software developer especially on web-apps used by our clients, and maintain it's security techniques.
• Software integration and support our clients with other technologies.
• Participate in feature planning and estimating.
• As Developer: creating windows services using C# and multithreading approach.

Software Developer

Senior .Net Developer | Senior C# Developer | Senior Back-end Developer | Senior Software Developer.

I'm a Senior Software Developer with 11 years of full-time work experience. I am currently working with C#, but I have started software development with Java.

I'm a content creator who loved to help others, so I participate in online courses on my YouTube channel.

I'm a bit of a geek, who loves finding problem-solving techniques also reading about new technologies, and participating in open-source projects.

I Seeking a challenging career in Software Development through working with a productive and creative team to gain experience and to add value to the corporation through smart working & learning new technologies.

Top 5 Kafka use cases

Kafka was originally built for massive log processing. It retains messages until expiration and lets consumers pull messages at their own pace.

Let’s review the popular Kafka use cases.

- Log processing and analysis
- Data streaming in recommendations
- System monitoring and alerting
- CDC (Change data capture)
- System migration

Over to you: Do you have any other Kafka use cases to share?

--
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq

#systemdesign #coding #interviewtips
.

Ahmed Omar

Top 9 Architectural Patterns for Data and Communication Flow 
. 
. 
🔹 Peer-to-Peer 
The Peer-to-Peer pattern involves direct communication between two components without the need for a central coordinator. 
 
🔹 API Gateway 
An API Gateway acts as a single entry point for all client requests to the backend services of an application. 
 
🔹 Pub-Sub 
The Pub-Sub pattern decouples the producers of messages (publishers) from the consumers of messages (subscribers) through a message broker. 
 
🔹 Request-Response 
This is one of the most fundamental integration patterns, where a client sends a request to a server and waits for a response. 
 
🔹 Event Sourcing 
Event Sourcing involves storing the state changes of an application as a sequence of events. 
 
🔹 ETL 
ETL is a data integration pattern used to gather data from multiple sources, transform it into a structured format, and load it into a destination database. 
 
🔹 Batching 
Batching involves accumulating data over a period or until a certain threshold is met before processing it as a single group. 
 
🔹 Streaming Processing 
Streaming Processing allows for the continuous ingestion, processing, and analysis of data streams in real-time. 
 
🔹 Orchestration 
Orchestration involves a central coordinator (an orchestrator) managing the interactions between distributed components or services to achieve a workflow or business process. 
 
-- 
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq 
 
#systemdesign #coding #interviewtips 
.

How do we design a secure system?
.
.
Designing secure systems is important for a multitude of reasons, spanning from protecting sensitive information to ensuring the stability and reliability of the infrastructure. As developers, we should design and implement these security guidelines by default.

The diagram below is a pragmatic cheat sheet with the use cases and key design points.

🔹 Authentication
🔹 Authorization
🔹 Encryption
🔹 Vulnerability
🔹 Audit & Compliance
🔹 Network Security
🔹 Terminal Security
🔹 Emergency Responses
🔹 Container Security
🔹 API Security
🔹 3rd-Party Vendor Management
🔹 Disaster Recovery

-- 
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq

#systemdesign #coding #interviewtips
.

Who are the Fantastic Four of System Design? 
 
Scalability, Availability, Reliability, and Performance. 
 
They are the most critical components to crafting successful software systems. 
 
Let’s look at each of them with implementation techniques: 
 
1 - Scalability 
Scalability ensures that your application can handle more load without compromising performance.  
 
2 - Availability 
Availability makes sure that your application is always ready to serve the users and downtime is minimal. 
 
3 - Reliability 
Reliability is about building software that consistently delivers correct results. 
 
4 - Performance 
Performance is the ability of a system to carry out its tasks at an expected rate under peak load using available resources. 
 
Over to you: What are the other pillars of system design and strategies you’ve come across? 
 
--  
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq 
 
#systemdesign #coding #interviewtips 
.

5 books I can't recommend enough:

1. Clean Architecture ( Robert Martin )

2. Building Microservices ( Sam Newman )

3. Unit Testing ( Vladimir Khorikov )

4. Domain Driven Design ( Eric Evans )

5. Head First Design Patterns ( Eric Freeman, Ph.D.  & Elisabeth Robson )

My favorite: Building Microservices, for how well it explains all aspects regarding the move to a microservices-based architecture.

What should I read next?

Leetcode takes TIME.

25 questions to cover the most important patterns:


𝗚𝗿𝗮𝗽𝗵𝘀:

0. Clone Graph: https://lnkd.in/dV2P2TEs
1. Course Schedule: https://lnkd.in/de8Q3NBS
2. 01 Matrix: https://lnkd.in/dV2P2TEs
3. Number of Islands: https://lnkd.in/drT2MpTz
4. Rotting Oranges: https://lnkd.in/dUQVwJ-d

𝗔𝗿𝗿𝗮𝘆𝘀:

5. Insert Interval: https://lnkd.in/dfcEDFwB
6. 3Sum: https://lnkd.in/duGvuCjf
7. Product of Array Except Self: https://lnkd.in/dkGkjQVk
8. Combination Sum: https://lnkd.in/d3iStbGc
9. Merge Intervals: https://lnkd.in/dmFZxrVQ

𝗦𝘁𝗮𝗰𝗸𝘀:

10. Evaluate Reverse Polish Notation: https://lnkd.in/d-y7Zw4C
11. Min Stack: https://lnkd.in/dqbh7PeV
12. Trapping Rain Water: https://lnkd.in/dS_svBAm

𝗕𝗶𝗻𝗮𝗿𝘆 𝗧𝗿𝗲𝗲𝘀:

13. Binary Tree Level Order Traversal: https://lnkd.in/dM-VYbVB
14. Lowest Common Ancestor of a Binary Tree: https://lnkd.in/dUvJykgA
15. Serialize and Deserialize Binary Tree: https://lnkd.in/dW2cP5Wn

𝗗𝘆𝗻𝗮𝗺𝗶𝗰 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴:

16. Maximum Subarray: https://lnkd.in/dvjYye6E
17. Coin Change: https://lnkd.in/d7zZRg7H

𝗕𝗶𝗻𝗮𝗿𝘆 𝗦𝗲𝗮𝗿𝗰𝗵:

18. Search in Rotated Sorted Array: https://lnkd.in/dEuh3gie
19. Time Based Key-Value Store: https://lnkd.in/dbERGKUB

𝗦𝘁𝗿𝗶𝗻𝗴𝘀:

20. Longest Substring Without Repeating Characters: https://lnkd.in/d_vZrZda
21. Minimum Window Substring: https://lnkd.in/de8aeeQD

𝗛𝗲𝗮𝗽:

22. K Closest Points to Origin: https://lnkd.in/dUtCqYf4
23. Find Median from Data Stream: https://lnkd.in/ddDgWqUv

𝗥𝗲𝗰𝘂𝗿𝘀𝗶𝗼𝗻:

24. Permutations: https://lnkd.in/dTUqmAfy


What are you studying right now?

#softwareengineering #coding #programming

_____

If you liked this, I post big tech articles and trends on Software Engineering and AI here for free every Monday: https://hungryminds.dev

What Are the Most Important AWS Services To Learn? 
 
Since its inception in 2006, AWS has rapidly evolved from simple offerings like S3 and EC2 to an expansive, versatile cloud ecosystem. 
 
Today, AWS provides a highly reliable, scalable infrastructure platform with over 200 services in the cloud, powering hundreds of thousands of businesses in 190 countries around the world. 
 
For both newcomers and seasoned professionals, navigating the broad set of AWS services is no small feat. 
 
From computing power, storage options, and networking capabilities to database management, analytics, and machine learning, AWS provides a wide array of tools that can be daunting to understand and master. 
 
Each service is tailored to specific needs and use cases, requiring a deep understanding of not just the services themselves, but also how they interact and integrate within an IT ecosystem. 
 
This attached illustration can serve as both a starting point and a quick reference for anyone looking to demystify AWS and focus their efforts on the services that matter most. 
 
It provides a visual roadmap, outlining the foundational services that underpin cloud computing essentials, as well as advanced services catering to specific needs like serverless architectures, DevOps, and machine learning. 
 
Over to you: What has your journey been like with AWS so far? 
  
–  
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq  
  
#systemdesign #coding #interviewtips  
. 

How can cache systems go wrong?

The diagram below shows 4 typical cases where caches can go wrong and their solutions.

1. Thunder herd problem
This happens when a large number of keys in the cache expire at the same time. Then the query requests directly hit the database, which overloads the database.

There are two ways to mitigate this issue: one is to avoid setting the same expiry time for the keys, adding a random number in the configuration; the other is to allow only the core business data to hit the database and prevent non-core data to access the database until the cache is back up.

2. Cache penetration
This happens when the key doesn’t exist in the cache or the database. The application cannot retrieve relevant data from the database to update the cache. This problem creates a lot of pressure on both the cache and the database.

To solve this, there are two suggestions. One is to cache a null value for non-existent keys, avoiding hitting the database. The other is to use a bloom filter to check the key existence first, and if the key doesn’t exist, we can avoid hitting the database.

3. Cache breakdown
This is similar to the thunder herd problem. It happens when a hot key expires. A large number of requests hit the database. 

Since the hot keys take up 80% of the queries, we do not set an expiration time for them. 

4. Cache crash
This happens when the cache is down and all the requests go to the database. 

There are two ways to solve this problem. One is to set up a circuit breaker, and when the cache is down, the application services cannot visit the cache or the database. The other is to set up a cluster for the cache to improve cache availability.

Over to you: Have you met any of these issues in production?

–
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq

#systemdesign #coding #interviewtips 
.

Top 6 Cloud Messaging Patterns.
.
.
How do services communicate with each other? The diagram below shows 6 cloud messaging patterns.

🔹 Asynchronous Request-Reply
This pattern aims at providing determinism for long-running backend tasks. It decouples backend processing from frontend clients. 

In the diagram below, the client makes a synchronous call to the API, triggering a long-running operation on the backend. The API returns an HTTP 202 (Accepted) status code, acknowledging that the request has been received for processing.

🔹 Publisher-Subscriber
This pattern targets decoupling senders from consumers, and avoiding blocking the sender to wait for a response.

🔹 Claim Check
This pattern solves the transmision of large messages. It stores the whole message payload into a database and transmits only the reference to the message, which will be used later to retrieve the payload from the database.

🔹 Priority Queue
This pattern prioritizes requests sent to services so that requests with a higher priority are received and processed more quickly than those with a lower priority.

🔹 Saga
Saga is used to manage data consistency across multiple services in distributed systems, especially in microservices architectures where each service manages its own database. 

The saga pattern addresses the challenge of maintaining data consistency without relying on distributed transactions, which are difficult to scale and can negatively impact system performance.

🔹 Competing Consumers
This pattern enables multiple concurrent consumers to process messages received on the same messaging channel. There is no need to configure complex coordination between the consumers. However, this pattern cannot guarantee message ordering.

Reference: Azure Messaging patterns

--
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq

#systemdesign #coding #interviewtips
.

How do we design effective and safe APIs?

The diagram below shows typical API designs with a shopping cart example.

Note that API design is not just URL path design. Most of the time, we need to choose the proper resource names, identifiers, and path patterns. It is equally important to design proper HTTP header fields or to design effective rate-limiting rules within the API gateway.

Over to you: What are the most interesting APIs you’ve designed?
 
--
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq

#systemdesign #coding #interviewtips
.

𝗕𝗼𝗼𝗸𝘀 𝗘𝘃𝗲𝗿𝘆 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿 𝗠𝘂𝘀𝘁 𝗥𝗲𝗮𝗱 𝗶𝗻 𝟮𝟬𝟮𝟰.

You probably already noticed that I'm a big fan of reading. I usually read 3-4 books per month. There are two ways to learn from knowledgeable people: to work directly with them or to read what they have written. The first option is the best, yet it is often impossible. So, we have books written by people who were probably the best at this at the time of writing. 

If we look at the software engineering world, there are many gems here, but I will recommend the best books per area of work. These books will help you not only to become good at specific technology but to become a great software engineer overall.

𝟭. 𝗚𝗲𝗻𝗲𝗿𝗮𝗹: 

🔹 The Pragmatic Programmer by David Thomas and Andrew Hunt (https://amzn.to/3KzpVwj)
🔹 Code Complete: A Practical Handbook of Software Construction (https://amzn.to/3xbRF5O))
🔹 Software Engineering at Google (Free - https://lnkd.in/d9Z2uDRF)

𝟮. 𝗖𝗼𝗱𝗶𝗻𝗴 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀: 

🔹 Clean Code by Uncle Bob Martin (https://amzn.to/3KyVoyV)
🔹 Head First Design Patterns by Eric Freeman (https://amzn.to/3Kzq2YX)
🔹 Refactoring by Martin Fowler (https://amzn.to/3m8bAgo)

𝟯. 𝗗𝗮𝘁𝗮 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝘀 𝗮𝗻𝗱 𝗮𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝘀: 

🔹 Grokking Algorithms by Aditya Bhargava (https://amzn.to/3ksUw4e)

𝟰. 𝗧𝗲𝘀𝘁𝗶𝗻𝗴: 

🔹 TDD by Example by Kent Beck (https://amzn.to/3EEHwiC)
🔹 Unit Testing Principles, Practices, and Patterns by Vladimir Khorikov (https://amzn.to/3ZBZYAJ)
🔹 The Art of Unit Testing by Roy Osherove (https://amzn.to/3kr7m2K)

𝟱. 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲: 

🔹 Fundamentals Of Software Architecture by Mark Richards and Neil Ford (https://amzn.to/3xQ1EuD)
🔹 A Philosophy of Software Design by John Ousterhout (https://amzn.to/3IopUZm)
🔹 Clean Architecture by Uncle Bob Martin (https://amzn.to/3ERwsPw)
🔹 Software Architecture the Hard Parts (https://amzn.to/3Zmg15r)

𝟲. 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝘀𝘆𝘀𝘁𝗲𝗺𝘀: 

🔹 Understanding Distributed Systems by Roberto Vitillo (https://amzn.to/3XZOFkG) 
🔹 Designing Data-Intensive Applications by Martin Kleppman (https://amzn.to/41uO65o)

𝟳. 𝗗𝗲𝘃𝗢𝗽𝘀: 

🔹 Continuous Delivery by Jez Humble and David Farley (https://amzn.to/3ECoVUo)
🔹 Accelerate by Nicole Forsgren (https://amzn.to/3StOug6)

𝟴. 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴: 

🔹 The Hundred-Page Machine Learning Book (https://amzn.to/3Y1SIwN)
🔹 Designing Machine Learning Systems (https://amzn.to/4cw5FHM)

𝟵. 𝗟𝗲𝗮𝗱𝗲𝗿𝘀𝗵𝗶𝗽: 

🔹 The Five Dysfunctions of a Team by Patrick Lencioni (https://amzn.to/3Z20fwW)
🔹 Drive by Daniel Pink (https://amzn.to/3EZTALR)
🔹 The Making of a Manager by Julie Zhuo (https://amzn.to/3PB9Vvv)

𝟭𝟬. 𝗣𝗲𝗿𝘀𝗼𝗻𝗮𝗹 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁:

🔹 How to Win Friends & Influence People (https://amzn.to/4anDgSc)
🔹 Deep Work (https://amzn.to/4a2y8mT)

#technology #softwareengineering #programming #techworldwithmilan #books

Roadmap for Learning Cyber Security

By Henry Jiang. Redrawn by ByteByteGo.

Cybersecurity is crucial for protecting information and systems from theft, damage, and unauthorized access. Whether you're a beginner or looking to advance your technical skills, there are numerous resources and paths you can take to learn more about cybersecurity. Here are some structured suggestions to help you get started or deepen your knowledge:

🔹 Security Architecture
🔹 Frameworks & Standards
🔹 Application Security
🔹 Risk Assessment
🔹 Enterprise Risk Management
🔹 Threat Intelligence
🔹 Security Operation

– 
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq 

#systemdesign #coding #interviewtips 
.

What does a typical microservice architecture look like? 👇
.
.
The diagram below shows a typical microservice architecture. 

🔹Load Balancer: This distributes incoming traffic across multiple backend services. 

🔹CDN (Content Delivery Network): CDN is a group of geographically distributed servers that hold static content for faster delivery. The clients look for content in CDN first, then progress to backend services.

🔹API Gateway: This handles incoming requests and routes them to the relevant services. It talks to the identity provider and service discovery.

🔹Identity Provider: This handles authentication and authorization for users. 

🔹Service Registry & Discovery: Microservice registration and discovery happen in this component, and the API gateway looks for relevant services in this component to talk to. 

🔹Management: This component is responsible for monitoring the services.

🔹Microservices: Microservices are designed and deployed in different domains. Each domain has its own database. The API gateway talks to the microservices via REST API or other protocols, and the microservices within the same domain talk to each other using RPC (Remote Procedure Call).

Benefits of microservices:
- They can be quickly designed, deployed, and horizontally scaled.
- Each domain can be independently maintained by a dedicated team.
- Business requirements can be customized in each domain and better supported, as a result.

Over to you: 1). What are the drawbacks of the microservice architecture?
2). Have you seen a monolithic system be transformed into microservice architecture? How long does it take?
 
– 
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq 

#systemdesign #coding #interviewtips 
.

Want to build fast and scalable applications? 
 
Here's how the CQRS pattern can help. 
 
The CQRS pattern separates the writes and reads in the application. 
 
This separation can be logical or physical - and this is where many developers get it wrong. 
 
CQRS has many benefits: 
 
- Complexity management 
- Improved performance 
- Scalability 
- Flexibility 
- Security 
 
My preferred approach is starting with logical CQRS. 
 
I have one database and separate flows for writing and reading data. 
 
You can design a data model fine-tuned for each operation. 
 
If you want to learn more about CQRS, I wrote an in-depth article explaining how to implement each step. 
 
You can read it here: https://lnkd.in/eJbt8bQK 
 
--- 
 
✍️ Would you use CQRS? 
♻️ Reshare if you liked this.

Do you know all the components of a URL? 
 
Uniform Resource Locator (URL) is a term familiar to most people, as it is used to locate resources on the internet. When you type a URL into a web browser's address bar, you are accessing a "resource", not just a webpage. 
 
URLs comprise several components: 
 
🔹The protocol or scheme, such as http, https, and ftp. 
🔹The domain name and port, separated by a period (.) 
🔹The path to the resource, separated by a slash (/) 
🔹The parameters, which start with a question mark (?) and consist of key-value pairs, such as a=b&c=d. 
🔹The fragment or anchor, indicated by a pound sign (#), which is used to bookmark a specific section of the resource. 
 
--
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq

#systemdesign #coding #interviewtips
.

API Design Best Practices: A Technical Deep Dive

Beyond the foundational concepts, crafting a stellar API requires attention to detail.

Here's a technical breakdown of best practices to elevate your API design:

𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲-𝗖𝗲𝗻𝘁𝗿𝗶𝗰 𝗗𝗲𝘀𝗶𝗴𝗻:

• Nouns in URLs:  Use descriptive nouns (e.g., /𝚞𝚜𝚎𝚛𝚜, /𝚙𝚛𝚘𝚍𝚞𝚌𝚝𝚜) to represent resources, not verbs indicating actions.
  
• HTTP Verbs:  Leverage HTTP verbs (GET, POST, PUT, DELETE) to denote actions on resources (GET: retrieve,  POST: create, PUT: update, DELETE: remove).
  
• Plural Nouns for Collections:  Identify collections of resources with plural nouns (e.g., /𝚞𝚜𝚎𝚛𝚜, not /𝚞𝚜𝚎𝚛).
  
• Nested Resources:  Model hierarchical relationships with nested URLs (e.g., /𝚞𝚜𝚎𝚛𝚜/:𝚞𝚜𝚎𝚛𝙸𝚍/𝚙𝚘𝚜𝚝𝚜).

𝗗𝗮𝘁𝗮 𝗙𝗼𝗿𝗺𝗮𝘁𝘀 & 𝗘𝗿𝗿𝗼𝗿 𝗛𝗮𝗻𝗱𝗹𝗶𝗻𝗴:

• Standardized Formats:  Opt for industry-standard data formats like JSON or XML for request and response payloads.
  
• Descriptive Error Codes:  Utilize HTTP status codes (e.g., 200: success, 400: bad request, 404: not found) and provide clear error messages for troubleshooting.
  
• Validation:  Implement robust input validation on the server-side to prevent malformed requests.

𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 & 𝗦𝗰𝗮𝗹𝗮𝗯𝗶𝗹𝗶𝘁𝘆:

• Caching:  Utilize caching mechanisms to reduce server load and improve response times for frequently accessed data.
  
• Pagination:  Enable result pagination (e.g., limit, offset parameters) to handle large datasets efficiently.
  
• Rate Limiting:  Implement rate limiting to prevent abuse and ensure fair access for all users.

𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆:

• Authentication & Authorization:  Enforce proper authentication and authorization mechanisms to control access to sensitive data and functionalities.
  
• HTTPS:  Always enforce HTTPS for secure communication and data encryption.

𝗔𝗱𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗖𝗼𝗻𝘀𝗶𝗱𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀:

• Versioning:  Implement API versioning to manage changes and ensure compatibility with existing integrations.
  
• Documentation:  Provide comprehensive API documentation covering endpoints, parameters, responses, and code samples.
  
• Testing:  Write thorough unit and integration tests to ensure API functionality and maintainability.

By adhering to these technical best practices, you can create a robust, well-documented, and secure API that empowers developers and fosters a thriving developer ecosystem.

What is the RIGHT way to use HttpClient in .NET? 
 
HttpClient is an excellent abstraction and incredibly easy to work with. 
 
Unfortunately, it's also easy to misuse, leading to problems like port exhaustion. 
 
You need to know how NOT to use it. 
 
If you think IHttpClientFactory will solve all your problems, you're only partly right. 
 
Should you use named clients or typed clients? 
 
Find all the answers here: https://lnkd.in/ep4ZpkYh 
 
--- 
 
✍️ What would you add? 
♻️ Reshare if you agree with this.

𝗦𝘁𝗮𝗰𝗸 𝗢𝘃𝗲𝗿𝗳𝗹𝗼𝘄 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗜𝘀 𝗡𝗼𝘁 𝗪𝗵𝗮𝘁 𝗬𝗼𝘂 𝗠𝗲𝗮𝗻 𝗜𝘁 𝗜𝘀

In the interview with Scott Hanselman, 𝗥𝗼𝗯𝗲𝗿𝘁𝗮 𝗔𝗿𝗰𝗼𝘃𝗲𝗿𝗱𝗲, 𝗛𝗲𝗮𝗱 𝗢𝗳 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗮𝘁 𝗦𝘁𝗮𝗰𝗸 𝗢𝘃𝗲𝗿𝗳𝗹𝗼𝘄, revealed the story about the architecture of Stack Overflow. They handle more than 6000 requests per second and 2 billion page views per month, and they manage to render a page in about 12 milliseconds. If we think about it a bit, we could imagine they use some kind of 𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲 𝘀𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝘁𝗵𝗮𝘁 𝗿𝘂𝗻𝘀 𝗶𝗻 𝘁𝗵𝗲 𝗖𝗹𝗼𝘂𝗱 𝘄𝗶𝘁𝗵 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀. 

But the story is a bit different. Their solution is 15 years old, and it is a 𝗯𝗶𝗴 𝗺𝗼𝗻𝗼𝗹𝗶𝘁𝗵𝗶𝗰 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗿𝘂𝗻𝗻𝗶𝗻𝗴 𝗼𝗻-𝗽𝗿𝗲𝗺𝗶𝘀𝗲𝘀. It is 𝗮 𝘀𝗶𝗻𝗴𝗹𝗲 𝗮𝗽𝗽 on IIS, which runs 200 sites. This single app is running on nine web servers and a single SQL Server (with the addition of one hot standby). 

They also use 𝘁𝘄𝗼 𝗹𝗲𝘃𝗲𝗹𝘀 𝗼𝗳 𝗰𝗮𝗰𝗵𝗲, one on SQL Server with large RAM (1.5TB), where 30% of DB access is in RAM. They also use two Redis servers (master and replica). In addition, they have three tag engine servers and three Elastic search servers, which process 34 million daily searches.

All this is handled by a 𝘁𝗲𝗮𝗺 𝗼𝗳 𝟱𝟬 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝘀, who manage to 𝗱𝗲𝗽𝗹𝗼𝘆 𝘁𝗼 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗶𝗻 𝟰 𝗺𝗶𝗻𝘀 several times daily. 

Their 𝗳𝘂𝗹𝗹 𝘁𝗲𝗰𝗵 𝘀𝘁𝗮𝗰𝗸 is:

🔹 C# + ASP. NET MVC
🔹 Dapper ORM
🔹 StaeckExchange Redis
🔹 MiniProfiler
🔹 Jil JSON Deseliazier
🔹 Exceptional logger for SQL
🔹 Sigil, a .Net CIL generation helper (for when C# isn’t fast enough)
🔹 NetGain, a high-performance web socket server
🔹 Opserver, monitoring dashboard polling most systems and feeding from Orion, Bosun, or WMI.
🔹 Bosun, backend monitoring system, written in Go

_______
If you found this valuable, I share insights like this in more detail every Thursday in my newsletter. To join, tap the 'View my blog' link in my bio.

♻️ Reshare if you found this helpful.

#technology #softwareengineering #programming #techworldwithmilan #softwarearchitecture 

Do you have a job interview soon?

What API questions do you need to know the answer to? 👇 

I am giving you 30 questions with all answers written by Postman.

Beginner:

1. What is API design?
2. What is API-first design?
3. Why are APIs important in software development?
4. What is a REST API?
5. What are the different components of an HTTP request?
6. What are the different components of an HTTP response?
7. What is an HTTP status code?
8. What are the most common HTTP status codes you see when working with REST APIs?
9. What is a payload?
10. Why is versioning important in API design?

Intermediate:

1. What are the key principles of good API design?
2. How do you ensure consistent API design?
3. How do you handle errors and exceptions in API responses?
4. What is the purpose of pagination in API responses, and how would you design it?
5. What’s the difference between REST and RESTful?
6. What are the advantages of RESTful APIs?
7. What are the disadvantages of RESTful APIs?
8. How do you handle a long-running operation with a REST API?
9. How do you represent a “do something” operation in a REST API?
10. What tools do you consider essential for the API design process?


Advanced:

1. What is the process of designing an API from scratch?
2. What are some best practices for RESTful API design?
3. How would you handle the versioning and deprecation of an API?
4. How do you handle backward compatibility in API evolution?
5. Is it always a problem to introduce a breaking change?
6. What are caching best practices?
7. What is content negotiation in HTTP, and how does it relate to API design?
8. How do you ensure security in API design, especially when handling sensitive data?
9. How do you ensure you’re creating the “right” API?

All the answers you can find here: https://lnkd.in/dhWkvaJb

What question do you not know the answer to?

Using multiple EF Core DbContexts in a single application? 
 
It's possible (and sometimes required), here's how. 👇 
 
Where you'll need this: 
 
- Working with multiple databases 
- Separating concerns 
- Modular monolith 
- Read replicas 
 
But, multiple DbContexts have some limitations: 
 
1. It's not possible to do a join between different DbContext instances because EF Core doesn't know if they are using the same database 
 
2. Transactions will only work if the DbContexts are using the same database. You have to create a new transaction and share it between the DbContexts by calling the UseTransaction method. 
 
Ready to implement this? 
 
Here's a complete guide: https://lnkd.in/emvW7wx6 
 
--- 
 
✍️ Would you use this? 
♻️ Reshare if this was helpful.

Taplio

Ahmed Omar's Linkedin Analytics

Ahmed Omar

Ahmed Omar's Best Posts (last 30 days)

Want to drive more opportunities from LinkedIn?

Taplio

.css-1jgreyo{background-image:linear-gradient(284deg, rgba(39,43,72,1) 0%, rgba(33,47,183,1) 100%);color:transparent;-webkit-background-clip:text;background-clip:text;}Ahmed Omar's Linkedin Analytics

Ahmed Omar

Ahmed Omar's Best Posts .css-qqfgvy{font-size:var(--chakra-fontSizes-md);}(last 30 days)

Want to drive more opportunities from LinkedIn?

Ahmed Omar's Linkedin Analytics

Ahmed Omar's Best Posts (last 30 days)