Lectures

In this article you will learn what limitations a local labor market has, how the global market differs, what advantages it gives specialists, and what requirements it places on candidates. The material will help you understand how to build a career in international companies and use globalization opportunities for professional growth.

We break down how packages in Go work as a namespace: why a call like fmt.Println( "hello") is “the name before the dot”, how the package line ties files into a single module, what package-level scope is, and why files in the same folder with the same package can see each other’s declarations. We’ll also discuss the role of package main and the main() function, the export rule based on the first letter (uppercase/lowercase), public API conventions, and practical naming rules—including common mistakes like a variable named fmt that “breaks” importing the package.

In this lecture, we break down a key (and very common) confusion in Go: what is the difference between package name (what you write to the left of the dot, like fmt.Println) and import path (the string inside import, like "math/rand"). Using examples from the standard library ( "encoding/json", "net/http"), we will see why rand can conflict (for example, "crypto/rand" and "math/rand"), and then we will reinforce the idea with a mini-project: StudyBuddy.

Let’s break down how imports work in Go: why import exists and why the compiler forbids unused dependencies; how to write single and grouped imports; when to use aliases (for example, crand for crypto/rand and mrand for math/rand); how to avoid shadowing; and what a blank import like import _ "pkg" means — importing for the side effect of initialization.

Let’s break down how automatic initialization via init() works in Go: why it runs before main(), what the overall package initialization order is, and why hidden side effects are dangerous. We’ll discuss when init() is acceptable, why application code often benefits more from explicit initialization via initApp(), how to handle errors via error instead of panic, and why import _ "..." (blank import) should be used deliberately.

In this lecture, we discuss common Go package design antipatterns: why package-level var turns into “hidden memory” and breaks predictability; how unnecessary imports (for example, fmt just for Println()) leak into business logic; why junk packages like utils/ helpers are dangerous; when import aliases (for example, f for fmt) hurt readability; and how shadowing via := can “erase” an imported package (for example, fmt). At the end: practical hygiene rules for a learning project and a list of common mistakes.

In this lecture, you will learn how modern development teams deliver their code to a server: from making changes and building the project to automation with CI/CD and deployment via Docker. We will go over the main tools, stages, and approaches that make deployment fast, reliable, and convenient.