YouTube Video

Summary

TL;DR: A live mock Go interview where Andrey solves string, map, and concurrency questions, followed by an overview of the Shortcat mentorship program.

Verdict: WATCH — the session offers solid Go concepts, real‑time problem solving, and useful insights into preparing for technical interviews.

Key Takeaways

• Strings in Go are immutable; to modify characters you must work with byte slices or create a new string.
• Repeated string concatenation with + creates new allocations; using strings.Builder yields O(N) memory usage instead of O(N²).
• Go 1.24 changed map internals from closed addressing to open addressing with SIMD‑accelerated bucket probing, improving lookup speed.
• Only comparable types can be map keys (no slices, maps, functions). Interface equality depends on both dynamic type and value.
• Implementing a basic mutex with a buffered channel works, but handling readers‑writer semantics (RWMutex) requires tracking active readers, often via additional channels or counters.
• The Shortcat program conducts paid mock interviews, provides detailed feedback, guarantees five real interviews, and offers a money‑back guarantee.
• Audience voted Andrey’s skill level as “mid‑level” (40% of votes).
• Current Go job market is competitive; strong resumes, referrals, and targeted interview practice remain essential.

Insights

1. Go 1.24’s map redesign leverages CPU SIMD instructions to check all eight slots of a bucket in a single cycle, a subtle but powerful performance boost.
2. Even though Go strings are UTF‑8, the length in bytes isn’t reliable for character count; converting to a rune slice yields the true character count.
3. Using a buffered channel of size 1 as a lock can simulate a mutex without the sync package, but scaling to RWMutex logic quickly becomes complex.
4. The mentorship service’s guarantee of five interview opportunities is a rare market differentiator, reducing risk for candidates.

Key Topics

• Go string immutability and byte vs rune handling
• Memory impact of string concatenation and strings.Builder
• Internal changes to Go maps in version 1.24
• Comparable types and interface equality in Go
• Custom synchronization primitives with channels
• Overview of the Shortcat mock‑interview & mentorship program

Key Moments

• 0:45 – Introductions: Maruf and Andrey share their Go experience.
• 4:10 – Discussion on mutating strings and byte vs rune length.
• 6:30 – Memory cost of repeated string concatenation; strings.Builder suggestion.
• 9:15 – Deep dive into Go 1.24 map implementation (open addressing, SIMD).
• 12:00 – Which types are comparable and can be map keys.
• 15:45 – Implementing a simple mutex with a buffered channel.
• 22:20 – Presentation of Shortcat’s mock interview service and guarantees.

Notable Quotes

“In Go 1.24 maps switched to open addressing with SIMD‑enabled bucket probing, letting the CPU compare eight slots in a single instruction.”

Best For

Developers preparing for Go technical interviews and anyone considering a structured mock‑interview mentorship.

Action Items

• Review Go’s string handling: practice converting between strings, byte slices, and rune slices.
• Refactor any + string concatenations to use strings.Builder for better performance.
• Experiment with a channel‑based mutex and, if needed, extend it to an RWMutex using reader counters.
• Explore Shortcat’s mock interview offering if you need personalized feedback and interview guarantees.