├── README.md
├── backend
├── dotnet
│ ├── categories
│ │ ├── ddd.md
│ │ ├── dotnet.md
│ │ ├── entity-framework.md
│ │ └── oop.md
│ └── questions
│ │ └── entity-framework.md
└── general
│ ├── categories
│ ├── cryptography.md
│ ├── data-structure.md
│ ├── design-patterns.md
│ ├── docker.md
│ ├── event-driven.md
│ ├── fault-tolerant-system.md
│ ├── git.md
│ ├── microservices.md
│ ├── network.md
│ ├── nosql.md
│ ├── os.md
│ ├── sql.md
│ ├── test.md
│ └── web-servers.md
│ └── questions
│ └── microservices.md
├── images
├── framework-architecture.png
├── network-architecture.png
└── stream-architecture.png
└── interview.png
/README.md:
--------------------------------------------------------------------------------
1 |
2 | Technical Interview
3 |
4 |
5 |
6 | Technical interview questions for Alibaba Travels Co.
7 |
8 |
9 |
10 | 
11 |
12 |
--------------------------------------------------------------------------------
/backend/dotnet/categories/ddd.md:
--------------------------------------------------------------------------------
1 | # DDD
2 |
3 | * Problem-Domain
4 | * Solution-Domain
5 | * Strategic Design
6 | * Ubiquitous Language
7 | * Bounded Context
8 | * Sub-domains
9 | * Tactical Design
10 | * Aggregate Root & Aggregate
11 | * Value-Object
12 | * Domain Services
13 | * Application Services
14 | * Domain Events
15 | * Context Mapping
16 | * Integration between BCs (Messaging, RPC, ...)
17 | * Entity Persistence
18 | * Patterns
19 | * Factory
20 | * Repository
21 | * Unit of Work
22 | * Event Sourcing
23 | * CQRS
24 |
--------------------------------------------------------------------------------
/backend/dotnet/categories/dotnet.md:
--------------------------------------------------------------------------------
1 | # .NET
2 |
3 | * Common Language Runtime
4 | * Intermediate Language (IL)
5 | * Managed language
6 | * Managed code
7 | * Just-In-Time (JIT)
8 |
9 | ___
10 |
11 | * Frameworks and Base Class Libraries
12 | * The Base Class Libraries (BCL)
13 | * Application framework layers
14 | * .NET Standard
15 |
16 | 
17 |
18 | ___
19 |
20 | * Data Types and Memory Allocation
21 | * Value Types
22 | * Reference Types
23 | * double Versus decimal
24 | * Stack
25 | * Heap
26 |
27 | ___
28 |
29 | * Local method
30 | * CLR behind the scene implementations
31 | * new versus override
32 | * Initialization order
33 | * Boxing and unboxing
34 | * Struct
35 | * Ref Structs
36 | * Friend Assemblies
37 | * Interface implementations
38 | * Enum Type-Safety Issues
39 |
40 | ___
41 |
42 | * Generics
43 | * Constraints
44 | * Covariance
45 | * Contravariance
46 |
47 | ___
48 |
49 | * Events
50 | * Delegate
51 | * Parameter compatibility
52 | * Return type compatibility
53 | * Generic delegate type
54 |
55 | ___
56 |
57 | * Lambda Expressions
58 | * Closures
59 | * Captured variables
60 | * Expression tree
61 | * Lambda Expressions Versus Local Methods
62 |
63 | ___
64 |
65 | * `try` Statements and Exceptions
66 | * Enumeration and Iterators
67 | * The `Array` Class
68 | * `Nullable` Struct
69 | * Nullable Reference Types
70 | * Extension Methods
71 | * Anonymous Types
72 | * Tuple and ValueTuple
73 |
74 | ___
75 |
76 | * Patterns
77 | * Property Patterns
78 | * Tuple Patterns
79 | * Positional Patterns
80 | * `var` Patterns
81 | * Constant Patterns
82 |
83 | ___
84 |
85 | * Caller Info Attributes
86 | * CallerMemberName
87 | * CallerFilePath
88 | * CallerLineNumber
89 |
90 | ___
91 |
92 | * Dynamic Binding
93 | * Unsafe Code and Pointers
94 |
95 | ___
96 |
97 | * Preprocessor Directives
98 | * Conditional Attributes
99 |
100 | ___
101 |
102 | * Comparing Strings
103 | * Equality comparison
104 | * Order comparison
105 | * Ordinal versus culture comparison
106 |
107 | ___
108 |
109 | * StringBuilder
110 | * Text Encodings and Unicode
111 |
112 | ___
113 |
114 | * Dates and Times
115 | * TimeSpan
116 | * DateTime and DateTimeOffset
117 | * Time Zones
118 | * Alternatives
119 |
120 | ___
121 |
122 | * BigInteger
123 | * Complex
124 | * Random
125 | * The `Guid` Struct
126 |
127 | ___
128 |
129 | * Standard Equality Protocols
130 | * == and !=
131 | * The virtual object.Equals method
132 | * The static object.Equals method
133 | * The static object.ReferenceEquals method
134 | * The IEquatable interface
135 | * When Equals and == are not equal
136 | * Overriding GetHashCode
137 | * Overriding Equals
138 |
139 | ___
140 |
141 | * Collections
142 | * BitArray
143 | * HashSet and SortedSet
144 | * Dictionaries
145 | * EqualityComparer
146 |
147 | ___
148 |
149 | * LINQ Query
150 | * Deferred Execution
151 | * Subqueries
152 | * Interpreted Queries
153 |
154 | ___
155 |
156 | * Garbage Collection and Memory Consumption
157 | * Finalizers
158 | * How the GC Works
159 | * Managed Memory Leaks
160 |
161 | ___
162 |
163 | * Cross-Platform Diagnostics Tools
164 | * dotnet-counters
165 | * dotnet-trace
166 | * dotnet-dump
167 |
168 | ___
169 |
170 | * Concurrency and Asynchrony and Threading
171 | * Concurrency vs Multi-Threading vs Async vs Parallelism
172 | * Single-core vs multicore or multiprocessor machine
173 | * Related Data-Structures (ex: ConcurrentDictionary, Channels)
174 | * Sleep
175 | * Yield
176 | * Blocking
177 | * Spinning
178 | * Local versus Shared State
179 | * Passing Data to a Thread
180 | * Exception Handling
181 | * Foreground versus Background Threads
182 | * IAsyncStateMachine
183 | * IAsyncEnumerable
184 | * IAsyncDisposable
185 | * Synchronization Contexts
186 | * `async void`
187 | * The Thread Pool
188 | * Worker Thread vs I/O Thread
189 | * Tasks
190 | * Long-running tasks & Task.Run()
191 | * AggregateException
192 | * awaiter.GetResult() vs .Result
193 | * TaskCompletionSource
194 | * Task.Delay
195 | * Awaiting
196 | * Asynchronous call graph execution
197 | * `ValueTask`
198 | * Precautions
199 | * `ConfigureAwait(false)`
200 | * Cancellation
201 | * Synchronization
202 | * Categories
203 | * Exclusive locking
204 | * lock Statement
205 | * Monitor.Enter and Monitor.Exit
206 | * Choosing the Synchronization Object
207 | * Deadlocks
208 | * Performance
209 | * Mutex
210 | * Locking and Thread Safety
211 | * Nonexclusive locking
212 | * Semaphore and SemaphoreSlim
213 | * Reader/Writer Locks
214 | * Signaling
215 | * AutoResetEvent
216 | * ManualResetEvent
217 | * CountdownEvent
218 | * Barrier Class
219 | * Lazy Initialization
220 | * Thread-Local Storage
221 | * Timers
222 | * SpinLock and SpinWait
223 | * Nonblocking synchronization techniques
224 | * Interlocked
225 | * memory barriers
226 | * volatile
227 | * Monitor.Wait and Monitor.Pulse
228 |
229 | ___
230 |
231 | * Stream Architecture
232 | * Backing stores
233 | * FileStream
234 | * NetworkStream
235 | * MemoryStream
236 | * PipeStream
237 | * Named pipes
238 | * Anonymous pipes
239 | * Decorators
240 | * BufferedStream
241 | * DeflateStream
242 | * GZipStream
243 | * CryptoStream
244 | * Adapters
245 | * TextReader
246 | * TextWriter
247 | * StreamReader
248 | * StreamWriter
249 | * StringReader
250 | * StringWriter
251 |
252 | 
253 |
254 | * Thread Safety
255 | * `File` and `Directory` class vs `FileInfo` and `DirectoryInfo`
256 | * Memory-Mapped Files
257 |
258 | ___
259 |
260 | * Network Architecture
261 |
262 | 
263 |
264 | * URIs
265 | * WebClient
266 | * HttpClient
267 | * HttpListener
268 | * TCP and UDP
269 |
270 | * Serialization Engines
271 | * XmlSerializer
272 | * JsonSerializer
273 | * The data contract serializer
274 | * The binary serializer
275 |
276 | * Assemblies
277 | * The Assembly Manifest
278 | * Resources and Satellite Assemblies
279 | * assembly loading
280 | * Assembly resolution
281 | * Assembly Load Contexts
282 | * AssemblyDependencyResolver
283 |
284 | * Reflection and Metadata
285 | * `GetType` Method vs `typeof` Operator
286 | * Obtaining a Type
287 | * Array types
288 | * Nested types
289 | * Type Names
290 | * Instantiating Types
291 | * Member Types
292 | * C# Members versus CLR Members
293 | * Late binding
294 | * Using Delegates for Performance
295 | * Attributes
296 | * Types
297 | * Bit-mapped
298 | * Custom
299 | * Pseudocustom
300 | * Properties and constructor parameters constraints
301 |
302 | ___
303 |
304 | * Dynamic Code Generation
305 | * Generating IL with DynamicMethod
306 | * Emitting Assemblies and Types
307 |
308 | ___
309 |
310 | * Dynamic Programming
311 | * Dynamic Language Runtime
312 | * Call Sites
313 | * Dynamic Member Overload Resolution
314 | * Anonymously Calling Members of a Generic Type
315 | * `ExpandoObject`
316 |
317 | ___
318 |
319 | * Cryptography
320 | * Hash Algorithms
321 | * Hashing Passwords
322 | * Symmetric Encryption
323 | * Public-Key Encryption and Signing
324 |
325 | ___
326 |
327 | * Parallel Programming
328 | * Channel
329 | * Data parallelism and task parallelism
330 | * PLINQ
331 | * The Parallel Class
332 | * Task Parallelism
333 | * Concurrent Collections
334 | * BlockingCollection
335 |
336 | ___
337 |
338 | * Span and Memory
339 | * Spans and Slicing
340 | * Forward-Only Enumerators
341 |
342 | ___
343 |
344 | * Native and COM Interoperability
345 | * Calling into Native DLLs
346 | * The Purpose of COM
347 |
348 | ___
349 |
350 | * Regular Expressions
351 | * Compiled Regular Expressions
352 | * Character Escapes
353 | * Character Sets
354 | * Quantifiers
355 |
356 | ___
357 |
358 | * The Roslyn Compiler
359 | * Roslyn Architecture
360 | * Parsing code into syntax trees (the syntactic layer)
361 | * Binding identifiers to symbols (the semantic layer)
362 | * Emitting Intermediate Language (IL)
363 |
--------------------------------------------------------------------------------
/backend/dotnet/categories/entity-framework.md:
--------------------------------------------------------------------------------
1 | # Entity Framework
2 |
3 | * Change-Tracker
4 | * Inheritance (TPT, TPH)
5 | * Migrations
6 | * Code-First vs Database-First
7 | * Database-Provider mechanisms (SQL-Server, PostgreSQL, SQLite, In-Memory, ...)
8 | * Fluent-API
9 | * SaveChanges(), When & Why?
10 | * Transaction Management
11 | * DbContext Lifetime
12 | * Value-Converters
13 |
--------------------------------------------------------------------------------
/backend/dotnet/categories/oop.md:
--------------------------------------------------------------------------------
1 | # Object-Oriented Programming
2 |
3 | * Paradigm
4 | * Principles
5 | * Inheritance
6 | * Encapsulation and Information Hiding
7 | * Method Hiding and Overriding
8 |
9 | * Abstraction
10 | * Data Abstraction
11 | * Procedural (Process,Control) Abstraction
12 | * Procedural Abstraction by Parameterization
13 | * Procedural Abstraction by Specification
14 |
15 | * Polymorphism
16 | * Ad hoc Polymorphism
17 | * Overloading Polymorphism
18 | * Coercion Polymorphism
19 | * Universal Polymorphism
20 | * Inclusion Polymorphism
21 | * Parametric polymorphism
22 | * Invariant Parametric polymorphism
23 | * Covariant Parametric polymorphism
24 | * Contravariant Parametric polymorphism
25 |
26 | * Dispatch
27 | * Static Dispatch
28 | * Dynamic Dispatch
29 | * Single dynamic dispatch
30 | * Multiple dynamic dispatch
31 |
--------------------------------------------------------------------------------
/backend/dotnet/questions/entity-framework.md:
--------------------------------------------------------------------------------
1 | # Entity Framework
2 |
3 | * Change-Tracker
4 | * What's change-tracker?
5 | * What's .AsNoTracking()?
6 | * How EF detect changes when you update a property value?
7 | * Inheritance (TPT, TPH)
8 | * What's TPT?
9 | * What's TPH?
10 | * Migrations
11 | * What are migrations?
12 | * What we achieve with them?
13 | * Code-First vs Database-First
14 | * What's code-first approach?
15 | * What's database-first approach?
16 | * How to use code-first when we have an existing database schema?
17 | * Database-Provider mechanisms (SQL-Server, PostgreSQL, SQLite, In-Memory, ...)
18 | * What are Providers in EF-Core?
19 | * How can we use EF-Core in unit-tests?
20 | * Fluent-API
21 | * What's fluent-api?
22 | * Advantages and downsides against Attributes
23 | * SaveChanges(), When & Why?
24 | * Transaction Management
25 | * How can we rollback a failed transaction in EF?
26 | * DbContext Lifetime
27 | * What's EF-Core's default lifetime? Do you know Why?
28 | * Can we use Singleton as DbContext's lifetime? Why?
29 | * Value-Converters
30 | * What are value-converters in EF?
31 | * What are its usages?
32 |
--------------------------------------------------------------------------------
/backend/general/categories/cryptography.md:
--------------------------------------------------------------------------------
1 | # Cryptography
2 |
3 | * Types of Attacks
4 | * Cryptoanalysis
5 | * Brute Force Attack
6 | * Types of Cryptography
7 | * Symmetric
8 | * Asymmetric
9 | * Block vs Stream Cipher
10 | * DES
11 | * Symmetric
12 | * Block Cipher (64 bits each)
13 | * Insecure due to the relatively short 56-bit key size
14 | * Triple DES
15 | * AES
16 | * Symmetric
17 | * Also known as Rijndael
18 | * Block Cipher (128 bits each)
19 | * RSA
20 | * Asymmetric
21 | * Rivest–Shamir–Adleman
22 | * Encryption key is public and distinct from the decryption key, which is kept secret (private)
23 | * Diffie-Hellman key exchange
24 | * Digital signature
25 | * Digital certificate
26 | * SSL and SSL certificate
27 | * SSL/TLS handshake protocol
28 |
--------------------------------------------------------------------------------
/backend/general/categories/data-structure.md:
--------------------------------------------------------------------------------
1 | # Data Structure
2 |
3 | * Time complexity
4 | * Space complexity
5 | * Array
6 | * Linked-List
7 | * Stack
8 | * Queue
9 | * Hash table
10 | * Collision
11 | * Bubble sort
12 | * Selection sort
13 | * Insertion sort
14 | * Merge sort
15 | * Quick sort
16 | * Linear search
17 | * Binary search
18 | * Binary search tree
19 | * Traversing tree approaches
20 | * Breadth first
21 | * Depth first
22 | * Pre-order
23 | * Post-order
24 | * In-order
25 | * Balanced tree
26 | * Self Balancing Trees
27 | * AVL Tree
28 | * Red-Black Tree
29 | * B-Tree
30 | * Heaps
31 | * Heap sort
32 | * Priority Queue
33 | * Tries (Digital or Radix or Prefix tree)
34 | * Graphs
35 | * Adjacency matrix
36 | * Adjacency List
37 | * Traverse
38 | * Depth-First
39 | * Breadth-First
40 | * Topological sort
41 | * Cycle detection
42 |
--------------------------------------------------------------------------------
/backend/general/categories/design-patterns.md:
--------------------------------------------------------------------------------
1 | # Design Patterns
2 |
3 | * Design Patterns
4 | * Creational
5 | * Factory Method
6 | * Abstract Factory
7 | * Builder
8 | * Singleton
9 | * Structural
10 | * Facade
11 | * Proxy
12 | * Decorator
13 | * Composite
14 | * Adapter
15 | * Flyweight
16 | * Bridge
17 | * Behavioral
18 | * Strategy pattern
19 | * Builder pattern
20 | * Template method
21 | * Visitor
22 | * Chain of Responsibility
23 | * Mediator
24 | * State
25 | * Observer
26 | * Principles
27 | * SOLID
28 | * Dependency Inversion vs Inversion Of Control vs Dependency Injection
29 | * DRY
30 | * KISS
31 | * YAGNI
32 | * Separation of Concerns
33 | * Least Knowledge
34 | * The Hollywood
35 | * Favor Composition over Inheritance
36 | * Program to an interface, not an implementation
37 | * Code Smells
38 | * Bloaters
39 | * Long Method
40 | * Large Class
41 | * Primitive Obsession
42 | * Long Parameter List
43 | * Data Clumps
44 | * Object-Orientation Abusers
45 | * Switch Statements
46 | * Temporary Field
47 | * Refused Bequest
48 | * Alternative Classes with Different Interfaces
49 | * Change Preventers
50 | * Divergent Change
51 | * Shotgun Surgery
52 | * Parallel Inheritance Hierarchies
53 | * Dispensables
54 | * Comments
55 | * Duplicate Code
56 | * Lazy Class
57 | * Data Class
58 | * Dead Code
59 | * Speculative Generality
60 | * Couplers
61 | * Feature Envy
62 | * Inappropriate Intimacy
63 | * Message Chains
64 | * Middle Man
65 |
--------------------------------------------------------------------------------
/backend/general/categories/docker.md:
--------------------------------------------------------------------------------
1 | # Docker
2 |
3 | * Basic Definition
4 | * .Net Containerization
5 | * Containerization Tools
6 | * Compose
7 | * Compose CLI
--------------------------------------------------------------------------------
/backend/general/categories/event-driven.md:
--------------------------------------------------------------------------------
1 | # Event-Driven
2 |
3 | ## Definition
4 | * What's an Event-Driven Architecture?
5 | * What's an Event?
6 | * What's an Event Producer?
7 | * What's an Event Emitter (Agents)?
8 | * What's an Event Notification?
9 | * What's an Event Handler?
10 | * What's an Event Loop?
11 | * What's an Event Carried State Transfer?
12 | * What's an Event Store?
13 | * What's an Event Sourcing?
14 | * What's an Event Queue?
15 | * What's an Event Mediator?
16 | * What's an Event Channel?
17 | * What's an Event Processor?
18 | * What's an Event Consumer?
19 | * What are the benefits of Event-Driven Architecture?
20 | * What are the considerations of Event-Driven Architecture?
21 | * Advantages of the Event-driven architecture?
22 | * Explain Orchestration and Choreographing differences?
23 | * How to resolve duplicates problem?
24 | * What's idempotence?
25 | ## Patterns
26 | * Event Sourcing
27 | * How does Event Sourcing work?
28 | * How Event Sourcing reliably/atomically updates the database and publish messages/events?
29 | * What differences between Event Sourcing and Outbox Pattern are there?
30 | * Outbox Pattern
31 | * How does Outbox Pattern work?
32 | * How Outbox Pattern reliably/atomically updates the database and publish messages/events?
33 | * What differences between Event Sourcing and Outbox Pattern are there?
34 | * Explain Change Data Capture (CDC)?
35 | * CQRS
36 | * How to implement a query that retrieves data from multiple services in a microservice architecture?
37 | ## Topology
38 | * What types of EDA Topology are there?
39 | * Mediator Topology
40 | * Broker Topology
41 | * Which EDA Topology Should You Choose?
42 | ## Event Driven Architecture Models
43 | * Publish/Subscribe (Pub/Sub) Model
44 | * Event streaming model
45 | * Simple Event Model
46 | * Stream Event Model
47 | * Complex Event Model
48 | ## Event-Driven Architecture Flows Layer
49 | * EVENT Generator
50 | * Event Channels
51 | * Event Processing
52 | * Event-Driven Downstream Activity
53 |
54 |
--------------------------------------------------------------------------------
/backend/general/categories/fault-tolerant-system.md:
--------------------------------------------------------------------------------
1 | # Fault-Tolerant System
2 |
3 | * Asynchronous communication
4 | * Fallback
5 | * Timeouts
6 | * Retries
7 | * Circuit breaker
8 | * Deadline
9 | * Rate limiter
10 | * Cascading failures
11 | * Single point of failure
12 |
--------------------------------------------------------------------------------
/backend/general/categories/git.md:
--------------------------------------------------------------------------------
1 | # Git
2 |
3 | * HEAD
4 | * Remote
5 | * Merge
6 | * Rebase
7 | * Revert
8 | * Cherry Pick
9 | * Pull Request
10 | * Submodules
11 | * Reset
12 | * Working area VS Staging area
13 | * bisect
14 |
--------------------------------------------------------------------------------
/backend/general/categories/microservices.md:
--------------------------------------------------------------------------------
1 | # Microservices
2 |
3 | * Monolith's downsides and advantages
4 | * Microservices downsides and advantages
5 | * Service Registry & Discovery
6 | * Load-Balancing
7 | * Distributed Transactions
8 | * Metrics, Monitoring, Tracing, Logging
9 | * Key-Vaults
10 | * Service-Mesh
11 | * Communication Patterns
12 | * Message Delivery Semantics
13 | * Retry Mechanisms
14 |
--------------------------------------------------------------------------------
/backend/general/categories/network.md:
--------------------------------------------------------------------------------
1 | # Network
2 |
3 | * Basic concepts
4 | * OSI model
5 | * How web works
6 | * TCP/IP Model
7 | * NAT
8 | * Basic knowledge of firewalls and waf
9 |
10 | * Application layer protocols
11 | * HTTP/1 vs HTTP/2.* vs HTTP/3
12 | * Keep-Alive concept pros and cons in different versions
--------------------------------------------------------------------------------
/backend/general/categories/nosql.md:
--------------------------------------------------------------------------------
1 | # NoSQL
2 |
3 | * SQL vs NoSQL
4 | * Data Models
5 | * Distribution Models
6 | * Types of NoSQL Databases
7 | * CAP Theorem
8 | * Consistency In Distribution
9 |
--------------------------------------------------------------------------------
/backend/general/categories/os.md:
--------------------------------------------------------------------------------
1 | # Operating System
2 |
3 | * Process Control Block
4 | * Degree of multiprogramming
5 | * Short Term Scheduler
6 | * Also known as the CPU scheduler
7 | * decides which of the ready, in-memory processes is to be executed (allocated a CPU)
8 | * Medium Term Scheduler
9 | * Removes the processes from the memory
10 | * Long Term Scheduler
11 | * Also called a job scheduler
12 | * Selects processes from the queue and loads them into memory for CPU scheduling
13 | * Loading process into memory
14 | * Contiguous allocation
15 | * Fixed partitioning
16 | * Dynamic partitioning
17 | * Compaction
18 | * Non-contagious allocation
19 | * Frame
20 | * Page and page table
21 | * Paging and multi-level paging
22 | * Virtual memory
23 | * Page hit and fault
24 | * Process synchronization
25 | * Lock variable
26 | * Binary and counting semaphore
27 | * File system
28 | * File allocation table (FAT)
29 | * Seek Time
30 | * Rotational latency
31 | * Disk scheduling
32 | * First come first served
33 | * Shortest seek time first
34 | * Scan
35 | * C-Scan
36 | * Look
37 | * C-Look
38 | * Kernel
39 | * Fork
40 | * Context switching
41 | * User-level and kernel-level thread
42 | * Process and thread and scheduler
43 | * Multi-threading and multi-processing
44 | * Starvation
45 |
--------------------------------------------------------------------------------
/backend/general/categories/sql.md:
--------------------------------------------------------------------------------
1 | # SQL Server
2 |
3 | * Normalization
4 | * Suitable for online transaction processing systems (OLTP)
5 | * 1NF
6 | * 2NF
7 | * 3NF
8 | * Denormalization
9 | * Suitable for online analytical processing systems (OLAP)
10 | * Primary-key constraint
11 | * Enforces the uniqueness of rows and also disallows NULLs in the constraint attributes
12 | * To enforce the uniqueness of the logical primary-key constraint, SQL Server will create
13 | a unique index behind the scenes. A unique index is a physical mechanism used by
14 | SQL Server to enforce uniqueness
15 | * Unique constraint
16 | * SQL Server will create a unique index behind the scenes as the physical mechanism to enforce
17 | the logical unique constraint.
18 | * Two NULLs value were equal to each other
19 | * Foreign-key constraint
20 | * Check constraint
21 | * Default constraint
22 | * Inheritance
23 | * Table-per-Type
24 | * Table-per-Hierarchy
25 | * Index
26 | * Clustered
27 | * Nonclustered
28 | * Three-Valued predicate logic
29 | * Logical query processing
30 | * All-at-once operations
31 | * Self-Contained sub query
32 | * Scalar
33 | * Multivalued
34 | * Correlated sub query
35 | * Table expression
36 | * Derived table
37 | * View
38 | * CTE
39 | * Recursive CTE
40 | * Inline table-valued function
41 | * Cross and outer apply operator
42 | * Window functions
43 | * Ranking
44 | * ROW_NUMBER
45 | * RANK
46 | * DENSE_RANK
47 | * NTILE
48 | * Offset
49 | * LEAD
50 | * LAG
51 | * FIRST_VALUE
52 | * LAST_VALUE
53 | * Inserting data
54 | * INSERT VALUES
55 | * INSERT SELECT
56 | * INSERT EXEC
57 | * SELECT INTO
58 | * BULK INSERT
59 | * The identity property and the sequence object
60 | * Deleting data
61 | * Delete statement
62 | * Truncate
63 | * Merge statement
64 | * The OUTPUT clause and nested DML
65 | * Transactions and isolation levels
66 | * ACID property
67 | * Isolation Levels
68 | * READ UNCOMMITTED
69 | * Dirty reads
70 | * READ COMMITTED
71 | * *Non-Repeatable Reads* or *Inconsistent Analysis*
72 | * REPEATABLE READ
73 | * Prevent phenomenon called a lost update
74 | * SERIALIZABLE
75 | * Prevent phenomenon called phantom reads
76 | * Isolation levels based on row versioning
77 | * SNAPSHOT
78 | * READ COMMITTED SNAPSHOT
79 | * Deadlocks
80 | * SQL Server chooses to terminate the transaction that did the least work
81 | (based on the activity written to the transaction log)
82 | * DEADLOCK_PRIORITY
83 | * Deadly embrace deadlock
84 | * Temporary tables
85 | * Local
86 | * Global
87 | * Table variable
88 | * Dynamic SQL
89 | * The *EXEC* command
90 | * The *sp_executesql* stored procedure
91 | * User-defined functions
92 | * Scalar
93 | * table-valued
94 | * Stored procedure
95 | * trigger
96 | * DML
97 | * After
98 | * Permanent tables
99 | * Instead of
100 | * Permanent tables
101 | * Views
102 | * DDL
103 | * Database scope
104 | * For events with a database scope, such as CREATE TABLE
105 | * Server scope
106 | * For events with a server scope, such as CREATE DATABASE
107 | * SQL Server supports only after DDL triggers; it doesn’t support instead of DDL triggers
108 | * Can be used for
109 | * Auditing
110 | * Policy enforcement
111 | * Change management
112 |
--------------------------------------------------------------------------------
/backend/general/categories/test.md:
--------------------------------------------------------------------------------
1 | # Test
2 |
3 | * Test Pyramid & Code-Coverage
4 | * Unit-Tests
5 | * Integration-Tests
6 | * E2E-Tests
7 | * TDD
8 | * BDD
9 |
--------------------------------------------------------------------------------
/backend/general/categories/web-servers.md:
--------------------------------------------------------------------------------
1 | # Web-Servers
2 |
3 | * Different Web-Servers (Nginx, IIS, Kestrel)
4 | * In-Process vs Out-Process hosting
5 | * Load Balancing
6 | * Reverse Proxy (Proxy vs ReverseProxy, what are the diferences?)
7 | * URL Rewriting
8 | * Request Filtering & Logging
9 | * Request Limiting & Throttling
10 |
--------------------------------------------------------------------------------
/backend/general/questions/microservices.md:
--------------------------------------------------------------------------------
1 | # Microservices
2 |
3 | * What are monolith's downsides and advantages?
4 | * What are microservices downsides and advantages?
5 | * Service Registry & Discovery
6 | * What's service registry?
7 | * Tools for service-discovery (Consul, Redis, ...)
8 | * Where do we need them?
9 | * Load-Balancing
10 | * What are the application requirements for load-balancing?
11 | * What's HA?
12 | * What's replication?
13 | * What's sharding?
14 | * What is the difference between Horizontal-Scaling and Vertical-Scaling?
15 | * Distributed Transactions
16 | * What's SAGA?
17 | * What's two-phase commit?
18 | * Metrics, Monitoring, Tracing, Logging
19 | * What's CorrelationId?
20 | * What's distributed tracing? Why we need that?
21 | * What are metrics? How to collect them?
22 | * What's monitoring? How it's related to the metrics?
23 | * What's centralized logging?
24 | * What's ELK?
25 | * How to keep the logs while the logging provider is down?
26 | * Key-Vaults
27 | * Where to store secret things like passwords, api-keys, ...?
28 | * What's key-vault?
29 | * Service-Mesh
30 | * What's service-mesh? Why we need that?
31 | * What's Side-Car pattern?
32 | * Communication Patterns (Inbox/Outbox, Fan-in/Fan-Out, Pub/Sub, Peer-2-Peer, ...)
33 | * How microservices can talk to each other?
34 | * What's gRPC? What's protobuf?
35 | * Message Delivery Semantics (At-Least-Once, At-Most-Once, Exactly-Once) + Retry
36 | * What's at-least-once in messaging?
37 | * What's at-most-once in messaging?
38 | * How to achieve exactly-once delivery in messaging?
39 | * What should we do when a message not get delivered?
40 | * What's retry pattern?
41 |
--------------------------------------------------------------------------------
/images/framework-architecture.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MoienTajik/technical-interview/fdd63aaad1a8f659a4c43a2a10948fd17381f43e/images/framework-architecture.png
--------------------------------------------------------------------------------
/images/network-architecture.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MoienTajik/technical-interview/fdd63aaad1a8f659a4c43a2a10948fd17381f43e/images/network-architecture.png
--------------------------------------------------------------------------------
/images/stream-architecture.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MoienTajik/technical-interview/fdd63aaad1a8f659a4c43a2a10948fd17381f43e/images/stream-architecture.png
--------------------------------------------------------------------------------
/interview.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MoienTajik/technical-interview/fdd63aaad1a8f659a4c43a2a10948fd17381f43e/interview.png
--------------------------------------------------------------------------------