Systems Computing Skill
Skill Metadata
skill_config:
version: "1.0.0"
category: systems
prerequisites: [cs-foundations]
estimated_time: "10-12 weeks"
difficulty: intermediate-advanced
parameter_validation:
domain:
type: string
enum: [cpu, memory, os, network, database, distributed]
required: true
scale:
type: string
enum: [single, cluster, global]
default: single
retry_config:
max_attempts: 3
backoff_strategy: exponential
initial_delay_ms: 500
observability:
log_level: INFO
metrics: [domain_usage, design_pattern_frequency]
Quick Start
Master how modern computers actually work, from circuits to distributed systems.
Digital Logic & CPU
CPU Concepts
- Instruction execution cycle
- Registers and cache hierarchy
- Pipelining
- Branch prediction
Cache Memory
- L1, L2, L3 hierarchy
- Temporal and spatial locality
- Cache lines and blocks
Operating Systems
Process Management
- Process states and context switching
- Scheduling algorithms: FCFS, SJF, round-robin
Memory Management
- Virtual memory and paging
- Page tables and TLB
- Page replacement: LRU, optimal
Concurrency
- Race conditions and critical sections
- Mutual exclusion: locks, semaphores
- Deadlock: conditions, detection, recovery
Networking
OSI Model
- Layer 1: Physical (signals, cables)
- Layer 2: Data Link (MAC, switching)
- Layer 3: Network (IP, routing)
- Layer 4: Transport (TCP, UDP)
Protocols
- HTTP/HTTPS: Web
- TCP: Reliable connection
- UDP: Fast connectionless
- DNS: Name resolution
Distributed Systems
CAP Theorem
- Consistency: all nodes same data
- Availability: responds to requests
- Partition tolerance: survives splits
- Can guarantee only 2 of 3
Consensus Algorithms
- Paxos: proven consensus
- Raft: simpler consensus
Troubleshooting
| Issue |
Root Cause |
Resolution |
| High latency |
Slow DB queries |
Add indexes, cache |
| Memory exhaustion |
Memory leak |
Profile, fix leaks |
| Connection exhaustion |
Pool too small |
Increase pool size |
| Cascading failure |
No circuit breaker |
Add circuit breakers |
Key Concepts
- Latency: Time to complete one task
- Throughput: Tasks completed per unit time
- Scalability: Performance with increasing load
- Fault tolerance: Reliability despite failures
Interview Questions
- How do caches work?
- Explain virtual memory
- What is thrashing?
- Difference between TCP and UDP?
- How do transactions work?
- Design a system that scales to millions of users
1---2name: systems-computing3description: Understand computer systems from digital logic through operating systems, networks, databases, and distributed systems.4---5
6# Systems Computing Skill
7
8## Skill Metadata
9
10```yaml
11skill_config:
12 version: "1.0.0"
13 category: systems
14 prerequisites: [cs-foundations]
15 estimated_time: "10-12 weeks"
16 difficulty: intermediate-advanced
17
18 parameter_validation:
19 domain:
20 type: string
21 enum: [cpu, memory, os, network, database, distributed]
22 required: true
23 scale:
24 type: string
25 enum: [single, cluster, global]
26 default: single
27
28 retry_config:
29 max_attempts: 3
30 backoff_strategy: exponential
31 initial_delay_ms: 500
32
33 observability:
34 log_level: INFO
35 metrics: [domain_usage, design_pattern_frequency]
36```
37
38---
39
40## Quick Start
41
42Master how modern computers actually work, from circuits to distributed systems.
43
44### Digital Logic & CPU
45
46**CPU Concepts**
47- Instruction execution cycle
48- Registers and cache hierarchy
49- Pipelining
50- Branch prediction
51
52**Cache Memory**
53- L1, L2, L3 hierarchy
54- Temporal and spatial locality
55- Cache lines and blocks
56
57### Operating Systems
58
59**Process Management**
60- Process states and context switching
61- Scheduling algorithms: FCFS, SJF, round-robin
62
63**Memory Management**
64- Virtual memory and paging
65- Page tables and TLB
66- Page replacement: LRU, optimal
67
68**Concurrency**
69- Race conditions and critical sections
70- Mutual exclusion: locks, semaphores
71- Deadlock: conditions, detection, recovery
72
73### Networking
74
75**OSI Model**
76- Layer 1: Physical (signals, cables)
77- Layer 2: Data Link (MAC, switching)
78- Layer 3: Network (IP, routing)
79- Layer 4: Transport (TCP, UDP)
80
81**Protocols**
82- HTTP/HTTPS: Web
83- TCP: Reliable connection
84- UDP: Fast connectionless
85- DNS: Name resolution
86
87### Distributed Systems
88
89**CAP Theorem**
90- Consistency: all nodes same data
91- Availability: responds to requests
92- Partition tolerance: survives splits
93- Can guarantee only 2 of 3
94
95**Consensus Algorithms**
96- Paxos: proven consensus
97- Raft: simpler consensus
98
99---
100
101## Troubleshooting
102
103| Issue | Root Cause | Resolution |
104|-------|------------|------------|
105| High latency | Slow DB queries | Add indexes, cache |
106| Memory exhaustion | Memory leak | Profile, fix leaks |
107| Connection exhaustion | Pool too small | Increase pool size |
108| Cascading failure | No circuit breaker | Add circuit breakers |
109
110---
111
112## Key Concepts
113
114- **Latency**: Time to complete one task
115- **Throughput**: Tasks completed per unit time
116- **Scalability**: Performance with increasing load
117- **Fault tolerance**: Reliability despite failures
118
119---
120
121## Interview Questions
122
123- How do caches work?
124- Explain virtual memory
125- What is thrashing?
126- Difference between TCP and UDP?
127- How do transactions work?
128- Design a system that scales to millions of users
majiayu000