uz
Feedback

Firibgarlarga uchmang! Telemetrio bunday kanallarni topadi va belgilaydi πŸ‘‰ Belgini koβ€˜rmoqchi boβ€˜lsangiz, obuna boβ€˜ling

Go

Go

Kanalga Telegram’da oβ€˜tish

// admin @denniselite // Denis Podlesnykh, a Golang Engineer go func() { channel <- news }() news := <-channel fmt.Sprintf("%s", news)

Ko'proq ko'rsatish
Xitoy12 215Texnologiyalar & Aralashmalar6 808

πŸ“ˆ Telegram kanali Go analitikasi

Go (@golang) Ingliz til segmentidagi kanali faol ishtirokchi. Hozirda hamjamiyat 19 151 obunachidan iborat bo'lib, Texnologiyalar & Aralashmalar toifasida 6 808-o'rinni va Xitoy mintaqasida 12 215-o'rinni egallagan.

πŸ“Š Auditoriya koβ€˜rsatkichlari va dinamika

Π½Π΅Π²Ρ–Π΄ΠΎΠΌΠΎ sanasidan buyon loyiha tez oβ€˜sib, 19 151 obunachiga ega boβ€˜ldi.

18 Oktabr, 2026 dagi oxirgi ma’lumotlarga koβ€˜ra kanal barqaror faollikka ega. Oxirgi 30 kunda obunachilar soni -32 ga, soβ€˜nggi 24 soatda esa -9 ga oβ€˜zgardi va umumiy qamrov yuqori darajada qolmoqda.

  • Tasdiqlash holati: Tasdiqlanmagan
  • Jalb etish (ER): Auditoriya oβ€˜rtacha 29.33% darajada jalb etiladi. Nashrdan keyingi dastlabki 24 soatda kontent odatda umumiy obunachilar sonining N/A% ini tashkil etuvchi reaksiyalarni toβ€˜playdi.
  • Post qamrovi: Har bir post oβ€˜rtacha 5 617 marta koβ€˜riladi; birinchi sutkada odatda 0 ta koβ€˜rish yigβ€˜iladi.
  • Reaksiyalar va oβ€˜zaro ta’sir: Auditoriya faol: har bir postga oβ€˜rtacha 116 ta reaksiya keladi.

πŸ“ Tavsif va kontent siyosati

Muallif resursni shaxsiy fikrni ifoda etish maydoni sifatida ta’riflaydi:
β€œ// admin @denniselite // Denis Podlesnykh, a Golang Engineer go func() { channel <- news }() news := <-channel fmt.Sprintf("%s", news)”

Yuqori yangilanish chastotasi (oxirgi ma’lumot 19 Oktabr, 2026 da olingan) sababli kanal doimo dolzarb va katta qamrovli boβ€˜lib qoladi. Analitika auditoriya kontent bilan faol hamkorlik qilishini, uni Texnologiyalar & Aralashmalar toifasidagi muhim ta’sir nuqtasiga aylantirishini koβ€˜rsatadi.

19 151
Obunachilar
-924 soatlar
-327 kun
-3230 kun
Postlar arxiv
Go
Go
19 148
It's been a while... Everything is going agentic, so there is rather an interesting project in Go about running AI agents sim
It's been a while... Everything is going agentic, so there is rather an interesting project in Go about running AI agents similar to how Kubernetes runs pods. You can declare tasks, workspaces, and models in YAML and AX sandboxes the agents and wires it all up. Check it out: AX: Google's Open Agentic Orchestration Runtime

Go
Go
19 148
If you’re working with Go and care about performance, then check out the https://goperf.dev/ Here you can find not theoretical, but practical patterns applicable to memory issues, concurrency, and overall, real bottlenecks you hit in production. The guide has been recently updated with more depth (atomics, concurrency trade-offs, etc.), so worth revisiting even if you’ve seen it before. Solid reference to keep bookmarked. Enjoy!

Go
Go
19 148
Are Atomic Operations Faster and Better Than a Mutex? It Depends From the author: "Recently, while reviewing a pull request,
Are Atomic Operations Faster and Better Than a Mutex? It Depends From the author: "Recently, while reviewing a pull request, a discussion arose about using sync/atomic versus sync.RWMutex. It’s a question that comes up often when writing concurrent Go code, so I thought it would make a great post" https://madflojo.dev/posts/are-atomic-operations-faster-than-a-mutex/

Go
Go
19 148
Hello, folks, it's bee a while. Re-sharing an interetsting recording from GopherCon 2025: Advancing Go Garbage Collection with Green Tea (youtube). TL;DR: Go 1.25 includes a new experimental garbage collector called Green Tea, available by setting GOEXPERIMENT=greenteagc at build time. Many workloads spend around 10% less time in the garbage collector, but some workloads see a reduction of up to 40%! There is an also official text version on the Green Tea Garbage Collector if one does not like to watch the video. Thanks!

Go
Go
19 148
Be Careful with Go Struct Embedding Embedding structs can quietly mask deeper-nested fields: a duplicate field name isn’t ambiguous unless it appears at the same β€˜depth’, meaning your program may choose an unintended value. https://mattjhall.co.uk/posts/be-careful-with-go-struct-embedding.html

Go
Go
19 148
[ On | No ] syntactic support for error handling The Go team has published a proposal for a new error handling syntax, aiming
[ On | No ] syntactic support for error handling The Go team has published a proposal for a new error handling syntax, aiming to simplify common error handling patterns without introducing exceptions or complex control flow. A new optional check built-in would allow the following syntax: func foo() error { x, e := check bar() y, e := check baz(x) return nil } Behind the scenes, check would automatically return the error if one occurs, making common patterns more concise while keeping Go’s explicit error handling philosophy. https://go.dev/blog/error-syntax

Go
Go
19 148

Go
Go
19 148
Go 1.24: A Major Improvement for Tooling: go tools πŸ›  Hello, folks! The upcoming Go 1.24 (supposed to be coming this month, Feb 2025) introduces a new go tool command, aiming to significantly improve the way project-specific tools are managed. This update eliminates the need for the tools.go workaround, reduces dependency bloat, and improves performance through caching. So, - No more tools.go hacks - Faster execution with caching - Cleaner and more efficient dependency management How it works? Simple! Add a tool: 

go get -tool github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen@v2.4.1
Run it: 

go tool github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen --config=config.yaml openapi.yaml
List available tools: 
go tool
Some people say this is one of the most useful changes to Go's tooling in years, making project setups more efficient and maintainable, so take a look in more details here https://www.jvt.me/posts/2025/01/27/go-tools-124/ πŸš€ PS More official docs can be found in the Go 1.24's release notes here: https://tip.golang.org/doc/go1.24#tools

Go
Go
19 148
Hello, dear community! I wish you Merry Christmas πŸŽ„ Happy New Year 🎊 and great winter holidays ahead!β˜ƒοΈ ❄️ See you in 2025 πŸ‘‹

Go
Go
19 148
Coming in Go 1.24: testing/synctest experiment for time and concurrency testing Testing code that involves time or concurrency can be a struggle. It often leads to hard-to-debug flakes in CI or long-running tests. Go 1.24 is scheduled to be released in February and the release freeze has begun. It’s set to include an experimental testing/synctest package designed to make testing code that involves time or concurrency precise and fast. https://danp.net/posts/synctest-experiment/

Go
Go
19 148
Go Blueprint: A Quick Way to Start Go Projects βš’ The tool helps you setting up new Go projects fast, with ready-made templates and all the basic setup done for you. While I’m not really into using tools like this, some might find it useful to save time and focus on development. From the authors: "Powerful CLI tool designed to streamline the process of creating Go projects with a robust and standardized structure. Not only does Go Blueprint facilitate project initialization, but it also offers seamless integration with popular Go frameworks, allowing you to focus on your application's code from the very beginning." https://docs.go-blueprint.dev/

Go
Go
19 148
Go sync.Map: The Right Tool for the Right Job In Go, sync.Map offers a thread-safe alternative to traditional maps. While sync.Map can be highly effective in scenarios involving heavy concurrent access, it isn't always the best choice. In this article by VictoriaMetrics, you'll learn when to opt for sync.Map, how it differs from regular maps, and the performance trade-offs involved. https://victoriametrics.com/blog/go-sync-map/index.html

Go
Go
19 148
The standard library of Go 1.23 now includes the new unique package. The purpose behind this package is to enable the canonicalization of comparable values. In other words, this package lets you deduplicate values so that they point to a single, canonical, unique copy, while efficiently managing the canonical copies under the hood. You might be familiar with this concept already, called β€œinterning”. Let’s dive in to see how it works, and why it’s useful. https://go.dev/blog/unique

Go
Go
19 148
If you use Timer.Reset() in Go 1.22 or earlier, you may be doing it wrong. Even the book 100 Go Mistakes (which is usually right about Go nuances) got it wrong. Let's see what the problem might be and how to work around it. https://antonz.org/timer-reset/

Go
Go
19 148
Profile-guided optimisation (PGO) is a technique where CPU profile data for an application is collected and fed back into the
Profile-guided optimisation (PGO) is a technique where CPU profile data for an application is collected and fed back into the next compiler build of Go application. The compiler then uses this CPU profile data to optimise the performance of that build by around 2-14% currently (future releases could likely improve this figure further). In this article, the Grab tech folks show off their wins and learnings, along with the Dockerfile used to make it happen. https://engineering.grab.com/profile-guided-optimisation Enjoy!

Go
Go
19 148
Okay based on the first reactions it seems like the naming convention issue brought by Zach didn't get much reflection in you. In this case, I'd like to share a more practical guidance I used recently when had to test a k8s operator setup locally. The topic is: Go: Testing Kubernetes Applications with EnvTest Enjoy πŸ™‚ https://blog.marcnuri.com/go-testing-kubernetes-applications-envtest

Go
Go
19 148
"ok" considered harmful? β€œJust like there’s an unwritten law that every error variable in Go must be named err, there’s an un
"ok" considered harmful? β€œJust like there’s an unwritten law that every error variable in Go must be named err, there’s an unwritten law that every map existence variable in Go must be named ok.” But Zach thinks we can, and should, look at doing better. https://www.dolthub.com/blog/2024-05-10-ok-considered-harmful/

Go
Go
19 148
https://go.dev/blog/chacha8rand Explore the recent advancements in randomness within the Go programming language. Authors Russ Cox and Filippo Valsorda, part of the Go team, look closely at the complexities of addressing security requirements for specific use cases and the implementation of the ChaCha(Rand8) algorithm. Discover how these improvements have enhanced random number generation in Go, culminating in the seamless security enhancements introduced in Go 1.22.

Go
Go
19 148
Mastering Maps in Go: Everything You Need to Know Maps, also known as associative arrays or hash tables, are vital data structures for solving algorithmic problems in programming. Understanding their features, operations, time and space complexities, and implementation in code is crucial for developers. With this knowledge and practical experience, developers can effectively apply maps to problem-solving scenarios. This article offers a comprehensive guide to using maps, covering their overview, implementation in Go programming, and strategies for using them in concurrent code.

Go
Go
19 148
The Impact of Pre-Allocating Slice Memory on Performance β€” The author wanted to establish, in numbers, how pre-allocating memory improves performance using quantitative measurements and tools for automated detection.