GitHub interview questions & answers

Model answer

Situation

In my previous role as a software engineer at a tech company, our team was tasked with developing a real-time data analytics platform. This project was crucial because it aimed to provide our clients with actionable insights through advanced visualizations, which was a key differentiator in our product offering. I was responsible for leading the integration of a third-party data visualization library with our custom backend solution, a complex task that required seamless collaboration across multiple teams.

Task

My specific goal was to ensure that the integration was completed smoothly and efficiently, without disrupting the existing development timeline. The main constraint was aligning the diverse perspectives and expertise of the front-end developers, back-end developers, UX designers, and data scientists involved in the project.

Action

• I initiated a series of brainstorming sessions with all stakeholders to discuss potential integration approaches and identify possible roadblocks early on. This proactive communication helped set a collaborative tone for the project.
• During these sessions, I facilitated discussions to ensure that each team member's insights were heard and considered, which helped in building a shared understanding of the project goals and challenges.
• I proposed a phased integration plan that allowed us to test and validate each component incrementally. This approach minimized risks and ensured that any issues could be addressed promptly without affecting the overall timeline.
• I maintained open channels of communication through regular updates and feedback loops, which kept everyone aligned and informed about the progress and any changes in the project scope.
• To address any technical challenges, I organized smaller focus groups within the team to dive deeper into specific issues, leveraging the expertise of team members to find effective solutions.

Result

The project was delivered successfully within the given timeline, and the client was delighted with the platform's user-friendly interface, real-time insights, and advanced visualizations. This experience reinforced the importance of strong communication and collaboration skills in my role. I learned that by fostering an environment of open dialogue and mutual respect, we could leverage the collective strengths of our diverse team to overcome complex challenges effectively.

Model answer

Situation

In my previous role as a software developer at a tech company, our team was tasked with developing a new customer relationship management (CRM) system. The project was crucial for streamlining our sales process and enhancing customer interactions. Midway through the project, we were informed of a significant change: the company decided to shift from a monolithic architecture to a microservices architecture. This change was necessary to improve scalability and maintainability but required us to adapt quickly to new technologies and methodologies.

Task

My responsibility was to lead the backend development team and ensure that our components integrated seamlessly with the new microservices architecture. This involved not only learning and implementing new technologies but also guiding my team through this transition while maintaining project timelines.

Action

• I began by enrolling in an online course on microservices architecture to build a solid theoretical understanding. This helped me grasp the core principles and best practices necessary for a successful transition.
• I organized a series of workshops and knowledge-sharing sessions with my team to disseminate what I learned and to foster a collaborative learning environment. This ensured that everyone was on the same page and could contribute effectively.
• Recognizing the complexity of the transition, I coordinated with other teams to redistribute the workload and sought additional resources where necessary. This helped balance the team's workload and ensured that we could meet our deadlines.
• I reprioritized our tasks, focusing on the most critical components first. This allowed us to address the most impactful changes early on and mitigate potential risks.
• Throughout the process, I maintained regular communication with stakeholders, providing updates on our progress and any changes to the timeline. This transparency helped manage expectations and build trust.

Result

Despite the initial challenges, we successfully transitioned to a microservices architecture and completed the CRM system on schedule. The new system was well-received, with improved performance and scalability. This experience taught me the importance of adaptability and proactive learning in the face of significant changes. It also reinforced the value of clear communication and teamwork in navigating complex transitions.

Model answer

Situation In my previous role as a software developer at a mid-sized e-commerce company, I noticed that our inventory management system was outdated and inefficient, leading to frequent errors and delays in order processing. This was a significant issue as it directly impacted our ability to fulfill customer orders promptly and accurately. Given the importance of maintaining a smooth supply chain, I saw an opportunity to improve this critical system.

Task I took the initiative to lead the development of a new inventory management system. The goal was to create a solution that could automate various tasks, handle large volumes of data, and provide real-time inventory tracking. The main challenge was to ensure minimal disruption to ongoing operations during the transition.

Action

• I began by conducting a thorough analysis of the existing system and identifying key pain points through discussions with the operations team. This helped in understanding the specific requirements and constraints.
• I proposed a plan to develop a modern, scalable system using a tech stack that included cloud-based solutions for better data handling and real-time processing capabilities.
• To ensure stakeholder buy-in, I organized a series of workshops with the operations team to gather feedback and iteratively refine the system design. This collaborative approach ensured that the system met user needs effectively.
• I led a small team of developers, delegating tasks based on individual strengths and setting clear milestones to track progress. I also implemented agile methodologies to allow for flexibility and quick adjustments based on feedback.
• Throughout the project, I maintained open communication with all stakeholders, providing regular updates and addressing any concerns promptly to ensure alignment and support.

Result The new inventory management system was successfully launched on schedule, significantly reducing errors and improving order processing times by 30%. The operations team reported increased efficiency and satisfaction with the new system. This project not only enhanced the company's operational capabilities but also reinforced the importance of cross-departmental collaboration and clear communication. I learned valuable lessons in stakeholder management and the benefits of an iterative development process.

Model answer

Situation At my previous job as a Data Analyst at a retail company, we were tasked with increasing customer retention. However, the business problem wasn't clearly defined, and there was no consensus on what metrics to focus on or how to measure success. This ambiguity was affecting our ability to make data-driven decisions and propose actionable insights.

Task My responsibility was to clarify the business problem and develop a clear analytical approach that would guide our efforts in improving customer retention.

Action

• I initiated a series of meetings with key stakeholders, including marketing, sales, and customer service teams, to gather their perspectives on customer retention challenges.
• I conducted a thorough analysis of existing customer data to identify patterns and trends in customer behavior, which helped in understanding the underlying issues.
• I proposed a set of key performance indicators (KPIs) that aligned with the company's strategic goals, such as repeat purchase rate and customer lifetime value.
• I developed a dashboard to visualize these KPIs, making it easier for stakeholders to understand the data and track progress over time.
• I facilitated a workshop to discuss the findings and align the team on a clear definition of the business problem and the metrics to focus on.

Result The clarity we achieved led to a more focused strategy on customer retention, resulting in a 15% increase in repeat purchases over the next quarter. The stakeholders appreciated the structured approach, and it fostered a culture of data-driven decision-making. I learned the importance of communication and collaboration in defining business problems and aligning teams towards a common goal.

Model answer

function longestCommonPrefixPath(paths) {
    if (paths.length === 0) return "";

    // Split each path into components
    const splitPaths = paths.map(path => path.split('/'));

    // Initialize the prefix as the first path's components
    let prefix = splitPaths[0];

    // Compare each path's components with the prefix
    for (let i = 1; i < splitPaths.length; i++) {
        let j = 0;
        // Find the common prefix between the current prefix and the current path
        while (j < prefix.length && j < splitPaths[i].length && prefix[j] === splitPaths[i][j]) {
            j++;
        }
        // Update the prefix to the common part
        prefix = prefix.slice(0, j);
    }

    // Join the components back into a path
    return prefix.join('/');
}

// Example usage:
const paths = [
    "/home/user/docs",
    "/home/user/docs/report",
    "/home/user/docs/report/2021"
];
console.log(longestCommonPrefixPath(paths)); // Output: "/home/user/docs"

• Approach:
• Split each file path into its components using the '/' delimiter.
• Initialize the prefix with the components of the first path.
• Iterate through each path and compare its components with the current prefix.
• Update the prefix to the longest common prefix found so far.
• After processing all paths, join the prefix components back into a path string.
• Complexity:
• Time: O(N * M), where N is the number of paths and M is the average length of the paths.
• Space: O(M) for storing the prefix components.

Model answer

function twoSum(nums, target) {
  // Create a map to store the difference and its index
  const numMap = new Map();

  // Iterate through the array
  for (let i = 0; i < nums.length; i++) {
    // Calculate the difference needed to reach the target
    const complement = target - nums[i];

    // Check if the complement exists in the map
    if (numMap.has(complement)) {
      // If it exists, return the indices
      return [numMap.get(complement), i];
    }

    // Otherwise, add the current number and its index to the map
    numMap.set(nums[i], i);
  }

  // If no solution is found, return an empty array
  return [];
}

// Example usage:
// const result = twoSum([2, 7, 11, 15], 9);
// console.log(result); // Output: [0, 1]

• Approach:
• Use a hash map to store each number's complement (target - current number) and its index.
• As you iterate through the array, check if the current number's complement is already in the map.
• If found, return the indices. If not, store the current number and its index in the map.
• Complexity:
• Time: O(n), where n is the number of elements in the array. We traverse the list containing n elements only once.
• Space: O(n), where n is the number of elements in the array. In the worst case, we store all elements in the map.

Model answer

function reverseString(str) {
  // Convert the string into an array of characters
  let charArray = str.split('');
  
  // Initialize two pointers
  let left = 0;
  let right = charArray.length - 1;
  
  // Swap characters until the two pointers meet in the middle
  while (left < right) {
    // Swap the characters at left and right indices
    let temp = charArray[left];
    charArray[left] = charArray[right];
    charArray[right] = temp;
    
    // Move the pointers towards the center
    left++;
    right--;
  }
  
  // Convert the array of characters back into a string
  return charArray.join('');
}

// Example usage:
console.log(reverseString("hello")); // Output: "olleh"

• Approach:
• Use the two-pointer technique to reverse the string in place.
• Convert the string to an array to facilitate swapping characters.
• Initialize two pointers, one at the start (left) and one at the end (right).
• Swap characters at these pointers and move them towards the center until they meet.
• Convert the array back to a string and return it.

Complexity:

• Time: O(n), where n is the length of the string, as each character is visited once.
• Space: O(n), due to the character array used for swapping.

Model answer

function lengthOfLongestSubstring(s) {
    let maxLength = 0; // To store the maximum length of substring found
    let start = 0; // Start index of the current substring
    const charIndexMap = new Map(); // Map to store the last index of each character

    for (let end = 0; end < s.length; end++) {
        const currentChar = s[end];

        // If the character is already in the map and its index is within the current window
        if (charIndexMap.has(currentChar) && charIndexMap.get(currentChar) >= start) {
            // Move the start to the right of the last occurrence of currentChar
            start = charIndexMap.get(currentChar) + 1;
        }

        // Update the last index of the current character
        charIndexMap.set(currentChar, end);

        // Calculate the length of the current substring and update maxLength if it's larger
        maxLength = Math.max(maxLength, end - start + 1);
    }

    return maxLength;
}

// Example usage:
console.log(lengthOfLongestSubstring("abcabcbb")); // Output: 3
console.log(lengthOfLongestSubstring("bbbbb"));    // Output: 1
console.log(lengthOfLongestSubstring("pwwkew"));   // Output: 3

• Approach:
• Use a sliding window technique with two pointers (start and end) to represent the current substring.
• Maintain a map to store the last seen index of each character.
• If a character is repeated within the current window, move the start pointer to the right of the last occurrence of that character.
• Continuously update the maximum length of substrings found.
• Complexity:
• Time: O(n), where n is the length of the string, as each character is processed at most twice.
• Space: O(min(m, n)), where m is the size of the character set and n is the length of the string, due to the storage in the map.

Model answer

Favorite Feature: My favorite feature on GitHub is the Pull Request (PR) review system.

Reason:

• Collaboration: It facilitates collaboration by allowing multiple contributors to review and discuss code changes before merging.
• Quality Assurance: The review process acts as a quality gate, ensuring that code changes meet the project's standards.
• Learning Opportunity: It serves as a platform for learning, where developers can receive feedback and improve their coding skills.

Impact: The PR review system is integral to GitHub's value proposition, fostering a collaborative and high-quality development environment.

Model answer

Clarify & scope: The goal is to enhance user engagement by improving the notification system. Assume notifications are currently overwhelming users with volume and lack of relevance, leading to decreased engagement.

User segments & pain points: Focus on developers who are overwhelmed by irrelevant notifications, which disrupt their workflow and lead to important updates being missed.

Goals & success metrics: The North Star metric is increased user engagement with notifications. Guardrails include maintaining or reducing the overall volume of notifications.

Solutions:

1. Smart filtering: Implement AI-driven filters to prioritize notifications based on user behavior and project importance.
2. Digest emails: Send a daily or weekly digest summarizing key updates to reduce notification fatigue.
3. Customizable settings: Allow users to customize the frequency and type of notifications they receive.

Recommendation: Implement smart filtering as it directly addresses the pain point of relevance.

flowchart TD
  A[Notifications] -->|Filter| B[Relevant Notifications]
  B --> C[User Engagement]

Prioritization & trade-offs: Use RICE. Smart filtering scores high on impact and medium on effort, making it the best choice.

MVP, measurement & rollout: Launch smart filtering as an MVP to a small user group, measure engagement metrics, iterate based on feedback, and then roll out to all users.

Model answer

Clarify: Understand the objectives of the Copilot feature, which is to assist developers in writing code more efficiently.

Define metric(s): Primary metrics include user adoption rate, the frequency of Copilot suggestions used, and user satisfaction scores. Secondary metrics could be the reduction in time spent coding and the quality of code produced.

Break down: Analyze the funnel:

funnel
  subgraph A[Copilot Usage Funnel]
    direction TB
    A1[Feature Adoption]
    A2[Suggestion Usage]
    A3[User Satisfaction]
  end

Ranked hypotheses:

1. High adoption but low suggestion usage indicates a need for better suggestions.
2. Low user satisfaction could suggest usability issues.
3. High time reduction correlates with successful feature integration.

How to investigate:

• Conduct A/B tests to measure the impact of Copilot on coding efficiency.
• Gather qualitative feedback through user surveys and interviews.

Decision & guardrails: Use insights to refine Copilot, ensuring improvements enhance user experience without compromising code quality.

Model answer

Clarify: Understand the context and timeframe of the drop in pull request submissions.

Define metric(s): The primary metric is the number of pull request submissions. Secondary metrics include the number of active repositories and user activity levels.

Break down: Analyze the funnel:

funnel
  subgraph A[Pull Request Funnel]
    direction TB
    A1[Active Repositories]
    A2[Commits]
    A3[Pull Requests]
  end

Ranked hypotheses:

1. Decrease in active repositories.
2. Users facing technical issues with pull requests.
3. Increased friction in the pull request process.

How to investigate:

• Analyze trends in active repositories.
• Check for recent changes or issues in the pull request process.
• Conduct user surveys for qualitative insights.

Decision & guardrails: Based on findings, implement targeted fixes such as process improvements or technical support, ensuring changes do not negatively impact user experience.

Model answer

1. Requirements & scale

Functional Requirements:

• Shorten a given URL.
• Redirect users from the shortened URL to the original URL.
• Track the number of times a shortened URL is accessed.
• Provide an API for URL shortening and redirection.

Non-Functional Requirements:

• High availability and reliability.
• Low latency for URL redirection.
• Scalability to handle a large number of requests.
• Consistent performance under high load.

Estimates:

• Assume 100 million URLs are shortened in a year.
• Average URL length is 100 characters, shortened to 7 characters.
• Daily active users: 1 million, each making 5 requests on average.
• QPS (Queries Per Second): 1 million users * 5 requests / 86400 seconds ≈ 58 QPS.
• Storage: 100 million URLs * 100 bytes ≈ 10 GB per year.
• Bandwidth: 58 QPS * 100 bytes ≈ 5.8 KB/s.

2. High-level architecture

flowchart TD
    subgraph Client
        A[User]
    end

    subgraph Edge/CDN
        B[CDN]
    end

    subgraph Load Balancer
        C[Load Balancer]
    end

    subgraph API / Services
        D[URL Shortening Service]
        E[Redirection Service]
    end

    subgraph Cache
        F[In-memory Cache]
    end

    subgraph Datastores
        G[SQL Database]
        H[NoSQL Database]
    end

    subgraph Message Queue
        I[Queue]
    end

    subgraph Workers
        J[Analytics Worker]
    end

    A -->|Request/Redirect| B
    B -->|Forward| C
    C -->|Shorten URL| D
    C -->|Redirect| E
    D -->|Read/Write| F
    E -->|Read| F
    F -->|Fallback| G
    D -->|Store URL| G
    E -->|Log Access| I
    I -->|Process Logs| J
    J -->|Update| H

3. API design

• POST /shorten: Accepts a long URL and returns a shortened URL.
• GET /{shortened_id}: Redirects to the original URL.
• GET /{shortened_id}/stats: Returns access statistics for a shortened URL.

4. Data model & storage

Datastores:

• SQL Database: Used for storing URL mappings and metadata. Chosen for its ACID properties, ensuring data consistency.
• NoSQL Database: Used for storing analytics data. Chosen for its scalability and ability to handle large volumes of writes.

Key Tables:

• urls:
• id (Primary Key, auto-increment)
• original_url (VARCHAR)
• shortened_id (VARCHAR, unique)
• created_at (TIMESTAMP)
• url_access_logs:
• shortened_id (VARCHAR, indexed)
• access_time (TIMESTAMP)

Partition Key:

• shortened_id for both SQL and NoSQL databases to distribute data evenly.

5. Deep dive

The core of the URL shortening service is the generation of unique shortened URLs. This can be achieved using a base conversion technique, converting the auto-incremented ID from the urls table into a base-62 string (using characters [a-zA-Z0-9]).

sequenceDiagram
    participant User
    participant URLService
    participant SQLDB
    participant Cache

    User->>URLService: POST /shorten {original_url}
    URLService->>SQLDB: Insert original_url, get id
    SQLDB-->>URLService: id
    URLService->>URLService: Convert id to base-62
    URLService->>Cache: Store shortened_id -> original_url
    URLService-->>User: Return shortened_id

6. Scale, bottlenecks & trade-offs

Replication and Sharding:

• Use database replication to ensure high availability and reliability. If one database server fails, another can take over.
• Shard the urls and url_access_logs tables based on shortened_id to distribute load and improve performance.

Caching:

• Use an in-memory cache (e.g., Redis) to store frequently accessed URL mappings, reducing database load and improving latency.

Single Points of Failure:

• Use multiple load balancers to prevent a single point of failure.
• Implement failover strategies for database and cache layers.

Trade-offs:

• Consistency vs. Availability: Opt for eventual consistency in analytics data to ensure high availability.
• Push vs. Pull: Use a push model for analytics data to ensure timely updates.
• SQL vs. NoSQL: Use SQL for critical data requiring ACID properties and NoSQL for analytics data requiring high write throughput.

Model answer

1. Problem Definition

• Identify the specific problem to solve.
• Define the objectives and success criteria.
• Understand the domain and gather requirements.

2. Data Acquisition

• Collect relevant data from various sources (databases, APIs, etc.).
• Ensure data is representative of the problem domain.

3. Data Exploration

• Analyze data to understand its structure and patterns.
• Use visualization tools to identify trends and anomalies.

4. Data Cleaning & Preprocessing

• Handle missing values and outliers.
• Normalize or standardize data as needed.
• Convert categorical variables into numerical formats.

5. Model Selection

• Choose appropriate algorithms based on the problem type (classification, regression, etc.).
• Consider factors like interpretability, complexity, and performance.

6. Model Training

• Split data into training and validation sets.
• Train models using the training set and tune hyperparameters.

7. Model Evaluation

• Assess model performance using metrics like accuracy, precision, recall, or F1 score.
• Validate the model on unseen data to ensure generalization.

8. Deployment

• Deploy the model to a production environment.
• Ensure the model is accessible via APIs or integrated into applications.

9. Monitoring

• Continuously monitor the model's performance in production.
• Track metrics to detect drift or degradation over time.

10. Iterative Refinement

• Gather feedback from users and stakeholders.
• Refine the model based on new data and insights.
• Repeat the lifecycle as needed for continuous improvement.

Summary

The lifecycle of a machine learning application is iterative, focusing on continuous improvement and adaptation to new data and requirements, ensuring that the model remains effective and relevant.

Model answer

1. Requirements & scale

Functional Requirements:

• Users can upvote or downvote GitHub repositories.
• Retrieve the top N repositories based on votes.
• Ensure real-time updates to the popularity rankings.

Non-Functional Requirements:

• Low latency for voting and retrieving top repositories.
• High availability and scalability to handle millions of repositories and users.
• Consistent data to ensure accurate vote counts.

Estimates:

• Assume 1 million active users, each performing 5 actions per day.
• Total actions per day = 5 million.
• Peak QPS (Queries Per Second) = 5 million / 86,400 seconds ≈ 58 QPS.
• Storage: Assume each repository vote record is 100 bytes. For 1 million repositories with 100 votes each, storage = 100 million votes * 100 bytes = 10 GB.

2. High-level architecture

flowchart TD
    subgraph Client
        A[User Interface]
    end

    subgraph Edge/CDN
        B[Edge Servers]
    end

    subgraph Load Balancer
        C[Load Balancer]
    end

    subgraph API / Services
        D[Vote Service]
        E[Ranking Service]
    end

    subgraph Cache
        F[Redis Cache]
    end

    subgraph Datastores
        G["SQL Database (PostgreSQL)"]
    end

    subgraph Message Queue
        H[Kafka]
    end

    subgraph Workers
        I[Vote Processor]
    end

    A -->|Vote/Fetch Request| B
    B --> C
    C --> D
    C --> E
    D -->|Update Vote| F
    D -->|Store Vote| G
    D -->|Publish Vote| H
    E -->|Fetch Top N| F
    E -->|Fetch Top N| G
    H --> I
    I -->|Update Rankings| F
    I -->|Update Rankings| G

3. API design

• POST /repositories/{repo_id}/vote: Allows a user to upvote or downvote a repository.
• GET /repositories/top: Retrieves the top N repositories based on votes.

4. Data model & storage

Datastore Choice:

• Use a SQL database (PostgreSQL) for relational data and consistency.
• Redis for caching top repositories and vote counts for quick retrieval.

Key Tables:

• Votes Table:
• vote_id: Primary Key
• repo_id: Foreign Key
• user_id: Foreign Key
• vote_type: Enum (UPVOTE, DOWNVOTE)
• timestamp: DateTime
• Repositories Table:
• repo_id: Primary Key
• vote_count: Integer (cached in Redis)

Partition Key:

• repo_id for sharding to distribute load across multiple database instances.

5. Deep dive

The core of this system is the efficient processing and aggregation of votes to update repository rankings in real-time. We utilize a message queue (Kafka) to decouple the vote submission from the ranking update process.

sequenceDiagram
    participant User
    participant API
    participant Cache
    participant DB
    participant Queue
    participant Worker

    User->>API: Submit Vote
    API->>Cache: Update Vote Count
    API->>DB: Store Vote
    API->>Queue: Publish Vote Event
    Worker->>Queue: Consume Vote Event
    Worker->>DB: Aggregate Votes
    Worker->>Cache: Update Top N Repositories

6. Scale, bottlenecks & trade-offs

Scaling:

• Replication and Sharding: Use database sharding based on repo_id to distribute load. Replicate databases for read scalability and high availability.
• Caching: Use Redis to cache vote counts and top repositories to reduce database load and latency.
• Message Queue: Kafka ensures that vote events are processed asynchronously, allowing the system to handle spikes in voting activity.

Bottlenecks:

• Database Write Load: High write load due to frequent voting can be mitigated by batching updates and using a message queue.
• Cache Invalidation: Ensure cache consistency by invalidating or updating cache entries when votes are processed.

Trade-offs:

• Consistency vs. Availability: Prioritize consistency for vote counts to ensure accurate rankings, potentially sacrificing some availability during network partitions (CAP theorem).
• Push vs. Pull: Use a pull model for fetching top repositories, which simplifies cache management and reduces unnecessary data pushes.

This design ensures a scalable, efficient system for tracking and retrieving the popularity of GitHub repositories, balancing real-time performance with data consistency.

Model answer

1. Requirements & scale

Functional Requirements:

• Deliver notifications to GitHub users for events such as pull requests, issues, comments, and mentions.
• Support multiple notification channels: email, web, and mobile push notifications.
• Allow users to customize notification preferences.
• Ensure notifications are delivered in near real-time.

Non-Functional Requirements:

• High availability and reliability.
• Scalability to handle millions of users and events.
• Low latency in notification delivery.
• Secure and private handling of user data.

Estimates:

• Assume 50 million active users, with each user receiving an average of 10 notifications per day.
• Total notifications per day = 500 million.
• Average notifications per second (QPS) = 500 million / 86,400 seconds ≈ 5,800 QPS.
• Storage: Assuming each notification is 1 KB, daily storage requirement = 500 million KB ≈ 500 GB.

2. High-level architecture

flowchart TD
    subgraph Client
        A[User Devices]
    end

    subgraph "Edge/CDN"
        B[CDN]
    end

    subgraph "Load Balancer"
        C[Load Balancer]
    end

    subgraph "API / Services"
        D[Notification Service]
        E[User Preference Service]
    end

    subgraph "Cache"
        F[Redis]
    end

    subgraph "Datastores"
        G["SQL DB (User, Notification)"]
        H["NoSQL DB (Notification Logs)"]
    end

    subgraph "Message Queue"
        I[Kafka]
    end

    subgraph "Workers"
        J[Notification Workers]
    end

    A -->|Requests| B
    B -->|Requests| C
    C -->|API Calls| D
    D -->|Fetch Preferences| E
    E -->|Preferences| F
    D -->|Store Notification| G
    D -->|Publish Event| I
    I -->|Process Event| J
    J -->|Send Notification| A
    J -->|Log Notification| H

3. API design

• GET /notifications: Retrieve notifications for a user.
• POST /notifications: Create a new notification event.
• PUT /notifications/preferences: Update user notification preferences.
• DELETE /notifications/{id}: Delete a specific notification.

4. Data model & storage

Datastores:

• SQL Database: Used for storing user data and notification preferences. SQL is chosen for its ACID properties, ensuring consistency in user settings.
• NoSQL Database: Used for logging notifications. NoSQL is chosen for its scalability and ability to handle large volumes of data.

Key Tables:

• User Table: user_id (PK), email, preferences.
• Notification Table: notification_id (PK), user_id (FK), type, content, status.
• Notification Log Table: log_id (PK), notification_id (FK), timestamp.

Partition Key:

• For the Notification Log Table, use user_id as the partition key to distribute data evenly across nodes.

5. Deep dive

The core of the notification system is the event-driven architecture facilitated by a message queue like Kafka. When an event occurs (e.g., a new pull request), the Notification Service processes it and publishes a message to Kafka. Workers consume these messages to deliver notifications to users.

sequenceDiagram
    participant U as User
    participant NS as Notification Service
    participant MQ as Message Queue
    participant W as Worker
    participant D as Datastore

    U->>NS: Trigger Event (e.g., PR created)
    NS->>MQ: Publish Notification Event
    W->>MQ: Consume Notification Event
    W->>D: Fetch User Preferences
    W->>U: Send Notification (Email/Push)
    W->>D: Log Notification

6. Scale, bottlenecks & trade-offs

Scalability:

• Use Kafka to handle high throughput of notification events.
• Redis caching for quick access to user preferences and reducing database load.

Bottlenecks:

• Database write operations can become a bottleneck; use sharding and indexing to optimize.
• Network latency in delivering notifications, especially for mobile push notifications.

Trade-offs:

• Consistency vs. Availability: Prioritize availability to ensure notifications are delivered even if some components are temporarily unavailable.
• Push vs. Pull: Use push notifications for real-time updates, but allow users to pull notifications via API for flexibility.
• SQL vs. NoSQL: SQL for structured, relational data (user preferences); NoSQL for unstructured, high-volume data (notification logs).

By designing with these considerations, the notification system can efficiently handle GitHub's scale and user requirements.

Model answer

Difference Between Shallow Copy and Deep Copy

1. Definition: - Shallow Copy: A shallow copy creates a new object, but does not create copies of nested objects. Instead, it copies references to the nested objects. This means that changes to nested objects in the copied object will reflect in the original object and vice versa. - Deep Copy: A deep copy creates a new object and recursively copies all objects found within the original object. This means that changes to nested objects in the copied object do not affect the original object.
2. Use Cases: - Shallow Copy: Suitable when the object contains immutable nested objects or when changes to nested objects should be reflected across copies. - Deep Copy: Necessary when you need a completely independent copy of an object, including all nested objects, to ensure that changes in the copied object do not affect the original.
3. Implementation: - Shallow Copy: In JavaScript, you can use Object.assign() or the spread operator (...) to create a shallow copy of an object. - Deep Copy: In JavaScript, a common approach is to use JSON.parse(JSON.stringify(object)) for deep copying, though it has limitations (e.g., it cannot handle functions or undefined values). Libraries like Lodash provide more robust deep copy functions.
4. Example:

   // Original object
   const original = {
     name: "GitHub",
     details: {
       type: "Repository",
       language: "JavaScript"
     }
   };

   // Shallow copy
   const shallowCopy = { ...original };
   shallowCopy.details.language = "Python";
   console.log(original.details.language); // Output: "Python"

   // Deep copy
   const deepCopy = JSON.parse(JSON.stringify(original));
   deepCopy.details.language = "Go";
   console.log(original.details.language); // Output: "Python"

1. Complexity: - Shallow Copy: Generally faster and uses less memory since it only copies references for nested objects. - Deep Copy: Slower and uses more memory as it creates new instances of all nested objects.

Understanding the difference between shallow and deep copies is crucial for managing object references and ensuring data integrity in software development, especially when dealing with complex data structures.

Model answer

What is Prometheus?

Prometheus is an open-source monitoring and alerting system that is designed to collect and store metrics from various applications and infrastructure components.

Key Features

• Pull-based model: Prometheus actively scrapes metrics from configured endpoints at specified intervals, allowing for real-time monitoring.
• Powerful query language (PromQL): Prometheus Query Language enables users to perform complex queries and aggregations on the collected time-series data.
• Time-series database: It stores metrics as time-series data, which is ideal for tracking changes over time, such as CPU, memory, and network usage.

Use Cases

• Monitoring application performance: Track metrics such as response times, error rates, and throughput to ensure optimal application performance.
• Infrastructure monitoring: Monitor resource usage across servers, containers, and cloud services to maintain system health.
• Alerting: Set up alerts based on specific thresholds, such as high error rates or latency, to proactively address issues before they impact users.

Conclusion

Prometheus is widely used because of its flexibility, scalability, and robust features that cater to modern monitoring needs in dynamic environments like microservices and cloud-native applications.

Model answer

Differences Between Numerical Data and Categorical Data

1. Definition - Numerical Data: Represents measurable quantities. - Categorical Data: Represents labels or categories.
2. Types - Numerical Data: - Continuous: Can take any value within a range (e.g., height, weight). - Discrete: Can only take specific values (e.g., number of students).

• Categorical Data:
• Nominal: No intrinsic order (e.g., colors, names).
• Ordinal: Has a defined order (e.g., rankings, satisfaction levels).

1. Examples - Numerical Data: - Temperature (e.g., 20°C, 30°C) - Age (e.g., 25 years, 30 years)

• Categorical Data:
• Gender (e.g., Male, Female)
• Car brands (e.g., Toyota, Ford)

1. Statistical Analysis - Numerical Data: Can be analyzed using mean, median, standard deviation. - Categorical Data: Analyzed using frequency counts, mode, and chi-square tests.
2. Visualization - Numerical Data: Often visualized using histograms, scatter plots. - Categorical Data: Visualized using bar charts, pie charts.

Model answer

Forking in GitHub

1. Definition: Forking is a feature in GitHub that allows users to create a personal copy of someone else's repository on their own GitHub account. This enables users to freely experiment with changes without affecting the original project.
2. Purpose: - Collaboration: Forking is commonly used to contribute to open-source projects. By forking a repository, a contributor can make changes and improvements in their own copy before proposing these changes to the original repository via a pull request. - Experimentation: Developers can use forks to try out new ideas or features without risking the stability of the original codebase. - Backup and Personalization: Users can maintain their own versions of a project, adding custom features or configurations specific to their needs.
3. Process: - Fork a Repository: Click the "Fork" button on the GitHub repository page to create a copy under your GitHub account. - Clone the Fork: Use git clone to download the forked repository to your local machine for development. - Make Changes: Implement changes, add features, or fix bugs in your local copy. - Push Changes: Commit and push changes back to your forked repository on GitHub. - Create a Pull Request: Once changes are ready, create a pull request to propose merging your changes into the original repository.
4. Key Considerations: - Syncing with Original Repository: Regularly pull updates from the original repository to keep your fork up-to-date. This can be done by adding the original repository as a remote and fetching changes. - Conflict Resolution: Be prepared to resolve merge conflicts when integrating updates from the original repository or when your pull request is reviewed.
5. Benefits: - Decentralization: Forking supports a decentralized workflow, allowing multiple contributors to work independently. - Version Control: Each fork acts as a full-fledged Git repository, preserving the complete history and enabling robust version control.
6. Limitations: - Storage and Management: Forks can consume storage space, and managing multiple forks may become complex. - Visibility: Changes in a fork are not automatically visible to the original repository unless a pull request is made and accepted.

Forking is a fundamental aspect of GitHub's collaborative model, empowering developers to innovate and contribute to projects globally while maintaining the integrity of the original codebase.