Intermediate

Getters and Setters in JavaScript

Master getters and setters in JavaScript classes. Learn property accessors, validation, computed properties, and best practices for encapsulation.

XMLHttpRequest and AJAX in JavaScript

Master XMLHttpRequest and AJAX. Learn asynchronous HTTP requests, handling responses, and practical AJAX patterns for modern web development.

Event Loop and Microtasks in JavaScript

Understand JavaScript's event loop, the difference between microtasks and macrotasks, execution order, and how blocking the main thread degrades performance.

Date and Time Handling in JavaScript

Master date and time handling in JavaScript. Learn Date object, formatting, parsing, and practical patterns for working with dates and times.

Geolocation API in JavaScript

Master the Geolocation API. Learn how to get user location, handle permissions, and implement location-based features.

Notification API in JavaScript

Master the Notification API. Learn how to send desktop notifications, handle permissions, and implement notification features.

Benchmarking Go Code

Master benchmarking in Go. Learn to measure performance, identify bottlenecks, and optimize code effectively.

Buffered vs Unbuffered Channels

Master buffered and unbuffered channels in Go. Learn when to use each, deadlock prevention, and channel patterns for concurrent programming.

Custom Errors and Error Wrapping in Go

Master custom error types and error wrapping in Go — implementing the error interface, adding structured context, Unwrap chains, multi-error with errors.Join, and patterns for …

Empty Interface and Reflection in Go

Master Go's any/interface{}, reflection with reflect.TypeOf and reflect.ValueOf, struct field inspection, modifying values via reflection, and when to prefer generics over …

Implicit Interfaces and Duck Typing in Go

Master Go's implicit interfaces and duck typing. Learn how Go's interface system enables flexible, decoupled code without explicit implementation declarations.

Interface Composition and Embedding in Go

Master Go interface composition — embedding interfaces to build larger contracts, struct embedding for method promotion, the middleware wrapper pattern, and when composition beats …

Logging in Go

Master logging in Go — the standard log package, Go 1.21 slog structured logging, log levels, context-aware logging, third-party libraries (zap, zerolog), and production best …

Methods and Receivers in Go

Master Go methods and receivers — when to use value vs pointer receivers, method sets and interface satisfaction, method chaining, embedding method promotion, and the consistency …

Race Conditions and Data Races

Master race conditions and data races in Go. Learn to detect, prevent, and fix concurrency bugs using the race detector and synchronization primitives.

Regular Expressions in Go

Master regular expressions in Go using the regexp package. Learn pattern matching, capturing groups, and practical regex patterns.

Worker Pools and Concurrency Patterns in Go

Master Go worker pool patterns — fixed-size pools, fan-out/fan-in, pipelines, and backpressure. Includes production patterns with context cancellation and error propagation.

Callbacks and Asynchronous JavaScript

Understand JavaScript's non-blocking execution model, how callbacks work, the error-first convention, callback hell, and when to migrate to Promises and async/await.

ES6 Classes: Syntax and Features

Master ES6 class syntax for modern object-oriented programming in JavaScript — constructors, methods, getters/setters, private fields, static members, and inheritance.

Form Handling and Validation in JavaScript

Learn how to handle form events, collect data with FormData, implement real-time validation, manage submit state, and build multi-step forms and file uploads.

Anonymous Functions and Closures in Go

Master Go anonymous functions and closures — function literals, how closures capture variables, practical patterns for callbacks and state, the loop variable trap, and using …

Defer, Panic, and Recover in Go

Master Go's defer, panic, and recover — how defer executes (LIFO, argument capture, named returns), when panic is appropriate, how recover works at service boundaries, and …

Go Interfaces: Definition and Implementation

Master Go interfaces — defining single and composed interfaces, implicit satisfaction, the Stringer and error contracts, common standard library interfaces, and how interface …

Go Pointers and Memory Management

Master Go pointers — address-of and dereference operators, pointer vs value receivers, nil pointer safety, escape analysis, new vs make, and how the GC manages heap memory …

Go Structs: Composition and Embedding

Master Go structs — field declaration, initialization, methods, anonymous embedding for code reuse, struct tags for JSON/database mapping, and why Go chooses composition over …

Goroutines: Lightweight Concurrency in Go

Master goroutines in Go — how they work under the hood, how to start and stop them safely, synchronization with WaitGroup, and patterns to avoid goroutine leaks.

Type Assertions and Type Switches in Go

Master Go type assertions and type switches — the two-value assertion idiom, avoiding panics, type switches with interfaces, errors.As for error type extraction, and when to use …

Working with JSON in Go

Master JSON in Go — struct tags, marshaling edge cases, streaming with Encoder/Decoder, custom marshalers, json.RawMessage, and performance tips for high-throughput JSON workloads.