Înapoi la articole →

Cel mai recent articol

Ultima verificare

Urmăritori 0 urmăritori
Articole: 200
  1. Message Queues in System Design

    When services call each other synchronously, they are tightly coupled.

  2. Vertical scaling - adding more CPU, RAM, or faster disks to one machine - has hard limits.

  3. Database Replication Explained

    Database replication is the process of keeping copies of the same data on multiple nodes.

  4. The CAP theorem is the first concept most interviewers reach for when probing your knowledge of distributed systems.

  5. Caching in System Design

    Caching trades memory and freshness for speed and reduced load.

  6. Code review is about to become your team’s biggest bottleneck.

  7. In Building an MCP Server in Go we built a small Model Context Protocol server that exposed a tool to an AI assistant.

  8. Google’s Agent Development Kit (ADK) just got a Go version, and in this tutorial we’re going to use it to build your first AI agent from scratch.

  9. Building an MCP Server in Go

    In this tutorial, we’re going to build a Model Context Protocol (MCP) server in Go from scratch.

  10. Variadic Functions & Closures

    Sometimes you don’t know how many arguments you’ll get — a party might have one hero or six.

  11. Variables

    Adventurers need somewhere to keep their gold, health, and gear.

  12. Types & Long-hand Variables

    The := operator is handy, but sometimes you want to be explicit about a variable’s type.

  13. Switch Statements

    When you have one value and many possible branches, a chain of else if gets noisy.

  14. Structs

    So far our heroes have been scattered across separate variables.

  15. Select & sync

    When you’re juggling several channels, select waits on all of them at once and runs whichever is ready first: select { case msg := <-orders: fmt.Println("order:", msg) case <-quit: fmt.Println("standing down") } The sync package covers the cases where…

  16. Quest: The War Party

    The war party charges, each member striking at once.

  17. Quest: The Spell Loop

    A barrage of blows is incoming, adventurer.

  18. Quest: The Locked Chest

    A locked chest sits before you.

  19. Quest: The Inventory

    You’ve returned from the dungeon with a pile of loot.

  20. Quest: The Dungeon Crawl

    Time to descend into the dungeon, adventurer.

  21. Quest: The Character Sheet

    Time to put your training to the test, adventurer.

  22. Quest: Hero vs Monster

    The moment of combat is here.

  23. Pointers

    A pointer holds the memory address of a value rather than a copy of it.

  24. Methods

    A method is a function attached to a type via a receiver in front of its name: func (m Monster) Describe() string { return m.Name + " lurks nearby" } goblin.Describe() The receiver can be a value (m Monster) or a pointer (m *Monster).

  25. Maps

    Sometimes a list isn’t enough — you want to look things up by name.

  26. Interfaces

    An interface describes what a type can do, not what it is — a contract of method signatures: type Attacker interface { Attack() int } Any type that has those methods satisfies the interface implicitly — there’s no implements keyword.

  27. If / Else Conditionals

    Every adventurer must make decisions.

  28. Hello, World

    Every great adventure begins with a single step.

  29. Goroutines

    A goroutine is a lightweight thread of execution.

  30. Functions Revisited

    Functions are how you package up a spell to cast again and again.

  31. For Loops

    Go keeps things simple: it has exactly one loop keyword, for, which covers every looping need.

  32. Error Handling

    Go doesn’t use exceptions.

  33. Defer

    defer schedules a call to run when the surrounding function returns — perfect for cleanup you don’t want to forget (closing a file, releasing a lock, snuffing a torch). func readScroll() { defer fmt.Println("scroll rolled back up") fmt.Println("reading…

  34. Constants & iota

    Some values should never change mid-quest — the size of your backpack, the name of your guild.

  35. Channels

    Goroutines need a safe way to talk to each other.

  36. Capstone: The Final Battle

    This is it, adventurer — the final battle, and the end of your journey through Go.

  37. Arrays & Slices

    Adventurers need to carry their spoils.

  38. In this tutorial we are going to take a thorough look at log/slog — the structured logging package that landed in the standard library in Go 1.21.

  39. In this tutorial, we are going to look at closures in Go.

  40. Makefiles for Go Developers

    In this tutorial we are going to look at how you can use Makefiles to automate the most common tasks in a Go project — building, running, and cross-compiling your application — all from a single make command.

  41. Part 6 - 2D Transformations

    Static images are a start, but real graphics need to move.

  42. A triangle is a great proof-of-concept, but most real graphics involve images.

  43. Part 4 - Colors and Uniforms

    So far our triangle is static.

  44. The triangle is the “hello world” of graphics programming.

  45. Part 2 - The Render Pipeline

    In Part 1 we opened a window.

  46. Welcome to the first part of this series on graphics programming with wgpu in Rust!

  47. Note: If you are working with structured data, you may also like Go JSON Tutorial.

  48. Go Interfaces Tutorial

    Source Code: The full source code for this tutorial is on GitHub: TutorialEdge/Go-Interfaces-Tutorial By the end of this tutorial, you’ll understand: What interfaces are and why Go uses them How to define your own interfaces How Go satisfies interfaces im…

  49. In this tutorial, we’re going to walk through how to use Anthropic’s Claude API in Go using the official SDK — no Python, no boilerplate frameworks.

  50. Go is a highly performant language built for concurrency.