Golang
What primitive approach allows to write all values absolutely in parallel and correctly, considering we have a fixed array and a fixed number of goroutines?
Tell me what you know about Kafka.
Model a simple banking system: - `accounts` table: - `id`, - `owner_id`, - `currency`, - `created_at`. - `transactions` table: - `id`, - `account_id`, - `amount`, - `created_at`. **Requirements:** 1. Write SQL to create the schema with necessary constraints (NOT NULL, FK, CHECK on non-zero `amount`). 2. Write a query: - to get the current account balance by `account_id` (sum of amount). 3. Harder: support debit/credit (double entry). Cleanup.
Maybe you can suggest something else besides Mutex and sync.Map for record protection?
What happened when you rolled back the index, rewrote the query, and then applied the same index again?
Have you added jobs to the pipeline — linters and other steps?
What type of index is the default in PostgreSQL?
How did you implement atomicity of writing in Redis? What algorithm did you use (Lua script)?
What is wrong with the counter increment code in 1000 goroutines? How to fix it using mutex, atomic, or channels?
Tell me more about your role in the team.
Have you written operators for Kubernetes?
How does the Go scheduler work? Tell about the GMP model.
Questions about loads, architecture of new services (calculation sheets and tariffs) — how do you perceive this?
Why are you considering leaving your current job now?
What is a composite index (index on multiple columns)?
What data would you pass inside this channel (what data structure)?
What is a goroutine? How does it differ from a system thread? Tell me about the Go scheduler (GMP).
What databases have you worked with?
How is the map structured in Go in general terms?
Can you tell more about your experience working with Kubernetes on your current project?