Skip to content

Knowledge Base

Home

Initializing search

Knowledge Base

Home Home
Table of contents
- Knowledge
- Interview Questions
Knowledge
Knowledge
- Data Engineering
  Data Engineering
  - Parquet
  - Lakehouse
- Distributed Systems
  Distributed Systems
  - Circuit Breaker
Interview Questions
Interview Questions
- C#
  C#
  - Basics
    Basics
    
    Value Types vs. Reference Types
    
    Creating a Custom Value Type
    
    String Immutability
    
    Choosing StringBuilder
    
    Interface vs. Abstract Class
    
    Implementing Colliding Interface Members
    
    Polymorphism
    
    Virtual Methods and Overrides
    
    Overriding, Overloading, and Hiding
    
    is, as, and Cast Expressions
    
    Equals and GetHashCode
    
    Hash Code Input Data
    
    Generic Types and Constraints
    
    Generic Type Constraints
    
    Static Fields in Generic Types
    
    Value and Reference Storage
    
    Value Type Inheritance
    
    Value Types and Interfaces
    
    Struct Parameterless Constructors
    
    The string Type
    
    Extension Methods
    
    Extension Methods on null
    
    yield return and yield break
    
    IEnumerable vs. IList
    
    IEnumerable vs. IQueryable
    
    throw vs. throw ex
    
    When to Throw Exceptions
    
    finally and using
    
    Catch-Clause Order
    
    Choosing a Type for Money
  - Asynchronous Programming
    Asynchronous Programming
    
    async and await
    
    async void
    
    Async Deadlocks
    
    ConfigureAwait
    
    Task Continuations
    
    Continuations After Success
    
    Cancelling a Task
    
    Waiting for Multiple Tasks
    
    TaskCompletionSource
  - Memory
    Memory
    
    Garbage Collector and Heaps
    
    IDisposable vs. Finalizer
    
    using Statement
    
    Lazy Initialization
    
    Memory Leaks in .NET
    
    WeakReference
    
    Finalizer Cleanup Scope
  - Reflection
    Reflection
    
    Reflection
    
    dynamic Type
    
    ExpandoObject
    
    Attributes
    
    Reflection Trade-offs
    
    Reflection Use Cases
    
    Anonymous Types vs. dynamic
    
    Values Held by dynamic
    
    Attribute Arguments
    
    Attribute Metadata Storage
  - Patterns and Architecture
    Patterns and Architecture
    
    SOLID Design Principles
    
    Test-Driven Development
    
    Domain-Driven Design
  - Tests
    Tests
    
    Unit Tests vs. Integration Tests
    
    Unit-Test Isolation
    
    Testing in Isolation
  - Version Control
    Version Control
    
    Git as Version Control
    
    Centralized vs. Distributed Version Control
    
    Merge vs. Rebase
    
    Branches
    
    Merge Conflicts
    
    Rebasing Long-Running Work
    
    Code Reviews
- Mobile
  Mobile
- Data Engineering
  Data Engineering
  - Lakehouse
    Lakehouse
    
    Updating a Single Row in a Billion-Row Parquet Table
    
    Iceberg vs. Delta Lake
    
    Parquet Update Strategy
- Distributed Systems
  Distributed Systems
  - Circuit Breaker
    Circuit Breaker
    
    Slow Downstream Service

Table of contents

Knowledge
Interview Questions

Technical Interview Knowledge Base

Technical concepts and interview practice.

Knowledge

Parquet
Lakehouse
Circuit Breaker

Interview Questions

Updating a Single Row in a Billion-Row Parquet Table
Iceberg vs. Delta Lake
Parquet Update Strategy
Slow Downstream Service

Made with Material for MkDocs