Sources

### Memory-intensive and not ideal for large datasets While Redis’s approach to storing data in RAM contributes to its speed, this has its consequences. RAM is significantly more expensive than disk storage, which means that using Redis for large datasets can become expensive, especially when scaling up. Companies that store and process terabytes of data must make significant investments when working with Redis. This is why it’s rarely used as a standalone solution and is often paired with other databases to balance performance and cost. ### Manual memory management Redis does not automatically manage memory like relational databases do. Developers must manually configure eviction policies to decide what happens when memory is full. This disadvantage is addressed once you move to Redis Cloud since it’s a fully-managed Redis service.

1. **Memory Consumption**: Redis is an in-memory data store, which means it can consume a significant amount of memory. If not monitored and managed properly, this can lead to high memory usage, potentially causing the system to slow down or even crash. Example: A Redis instance running on a server with 16GB of RAM might start to experience performance issues if it consumes more than 8GB of memory, leaving insufficient space for the operating system and other applications. 2. **Persistence Issues**: Redis offers several persistence options like RDB snapshots and AOF logs. Misconfiguration or issues with these mechanisms can lead to data loss. Example: If Redis is configured to persist data only through RDB snapshots and the server crashes before a snapshot is taken, any data changes since the last snapshot will be lost. 3. **Network Latency**: Redis performance can be severely impacted by network latency, especially in distributed environments where Redis instances are spread across multiple servers or data centers. Example: A Redis cluster spanning across two geographically distant data centers might experience high latency due to the physical distance between the servers, leading to slow response times. 4. **Configuration Errors**: Misconfigurations in Redis settings, such as maxmemory policies, timeout settings, or binding IP addresses, can lead to unexpected behavior or security vulnerabilities. Example: Setting the `maxmemory` policy too low might cause Redis to evict keys prematurely, leading to data loss or application errors. 5. **Concurrency Issues**: While Redis is generally good at handling concurrent operations, improper use of commands that modify data (like INCR, HSET, etc.) without proper locking mechanisms can lead to race conditions and inconsistent data. Example: Two clients simultaneously updating the same key without proper locking might result in one of the updates being overwritten, leading to data inconsistency.

### 2 - all the data types you need in one place Redis is a NoSQL database. This means you won’t get the old SQL transactions, tables, foreign and unique key-contraints, etc. I was ‘raised’ as a developer in a time where SQL was the only option, so we did everything with it. While it is convenient you don’t have to think about data consistency in your code, there are serious drawbacks as well, mostly in terms of speed, data size, and scalability. When I reflect on old projects, I wonder how often I really needed that absolute - stop the world - level of forced consistency in the database layer.

In 2007, some of the programmers at Google looked at their options for writing software and didn’t like what they saw. They needed to manage millions of lines of code that would be constantly storing and shipping data for the world wide web. The code would juggle thousands or maybe millions of connections on networks throughout the globe. … What some developers love about Go, others hate just as much. \n8 reasons developers love or hate the Go language\n\nIt's easy to learn\nIt doesn't play favorites\nThe C-based syntax\n(Too) many rules\nExtra error handling\nThe standard library\nThe executable size\nBig daddy Google\n\nGo is easy to learn\nGo's designers deliberately created a language that would be quick to learn, because it didn’t have too many complex features or idiosyncrasies. … Would a witch choose an abridged spell book? Would a quarterback choose a playbook with just a few plays? Some coders feel that programming with Go is like coding with one hand tied behind their back. The language lacks all the cleverness other language designers have delivered to the world, and that's a high price to pay.\nGo doesn't play favorites\nThe original developers wanted to create a small language, and they did so at the expense of many favorite features found in other languages. … There are no curly punctuation marks to delineate blocks of code and the typing is deliberately dynamic. Anyone who loves the Python approach will find plenty to dislike about Go. From this perspective, programming with Go feels like a step or three backward.\nGo has (too) many rules\nFrom the beginning, Go's creators wanted to define not just the syntax but also much of the style and usage patterns of the language. … There’s even a separate type system for errors that allows programmers to create more specific forms of errors, then spell out how they should be handled.\nWhy some love it: The Go approach acknowledges that errors exist and encourages the programmer to make a plan for handling them. This encourages programmers to plan ahead and build in the kind of resilience that makes for better software.\nWhy some hate it: Unnecessary error handling makes Go functions fatter and harder to understand. … Problems like vendor lockin and lack of control are serious issues for anyone trying to curate a tech stack. All of Google’s generosity still leaves programmers leery, especially when other language choices have large, open source communities built around them.

- Having added a useless digit to the go line on go.mod. go line should have remained the language version not a specific patch level that everybody now needs to set to .0 anyway. - golang.org/x forcing cascading updates by bumping said go line even without any other change actually using the new features. Libraries shouldn’t force upgrades without benefits (which isn’t to say you shouldn’t use a stable/supported version to build final binaries) … adding it / making unnecessary changes. - Enums (or at least whitelisted go:generate for stringer and other trustworthy tool so one doesn’t need to commit to source control generated files) - Unions - goroutineid not exposed (and bad justification for that in the go faq, that reads like bad faith). It’s very useful for logging. - generics are half baked. having type switches is super ugly - improvements that are a bit silly like … ) or iterators instead of the above - size of binaries - go playground and go doc not doing basic syntax highlighting because some early go team member don’t like colors. - go doc preview improved and yet still not working - Need … ``` - Embedded struct init - Testing dependencies showing up in go.mod - A pain to to use a fork while waiting for a bug fix to get upstream - GOMEMLIMIT being so soft you can ask for 10x - ``` := ```

- Broadly speaking, Go developers asked for help with identifying and applying best practices, making the most of the standard library, and expanding the language and built-in tooling with more modern capabilities. - Most Go developers are now using AI-powered development tools when seeking information (e.g., learning how to use a module) or toiling (e.g., writing repetitive blocks of similar code), but their satisfaction with these tools is middling due, in part, to quality concerns. … In that spirit, this year’s top challenges are not radically different from last year’s. The top three frustrations respondents reported were “Ensuring our Go code follows best practices / Go idioms” (33% of respondents), “A feature I value from another language isn’t part of Go” (28%), and “Finding trustworthy Go modules and packages” (26%). We examined open-text responses to better understand what people meant. Let’s take a minute to dig into each. Respondents who were most frustrated by writing idiomatic Go were often looking for more official guidance, as well as tooling support to help enforce this guidance in their codebase. As in prior surveys, questions about how to structure Go projects were also a common theme. For example: … The second major category of frustrations were language features that developers enjoyed working with in other ecosystems. These open-text comments largely focused on error handling and reporting patterns, enums and sum types, nil pointer safety, and general expressivity / verbosity: … > pointer, or using a value without checking the err first. ... > “I often find it hard to build abstractions and to provide clear intention > to the future readers of my code.” — Somewhat dissatisfied / < 3 years / Technology The third major frustration was finding trustworthy Go modules. Respondents often described two aspects to this problem. One is that they considered many 3rd-party modules to be of marginal quality, making it hard for really good modules to stand out. The second is identifying which modules are commonly used and under which types of conditions (including recent trends over time). … > “Being able to filter by criteria like stable version, number of users and ... Respondents told us that except for `go test`, between 15% – 25% of them felt they “often needed to review documentation” with working with these tools. This was surprising, especially for commonly-used subcommands like `build` and `run`. Common reasons included remembering specific flags, understanding what different options do, and navigating the help system itself. Participants also confirmed that infrequent use was one reason for frustration, but navigating and parsing command help appears to be the underlying cause. In other words, we all expect to need to review documentation sometimes, but we don’t expect to need help navigating the documentation system itself. As on respondent described their journey: ... What is driving this lower rate of satisfaction? In a word: quality. We asked respondents to tell us something good they’ve accomplished with these tools, as well as something that didn’t work out well. A majority said that creating non-functional code was their primary problem with AI developer tools (53%), with 30% lamenting that even working code was of poor quality. … They can explain code effectively but > struggle to generate new, complex features” — Somewhat satisfied / 3 – 10 years / Retail and consumer goods

2025 Go survey of 5,379 developers shows 91% satisfaction but identifies friction with idiomatic patterns, error handling, and module discovery as top challenges. ## Key Points - 91% of Go developers report satisfaction; 65% 'very satisfied' — stable since 2019 - Top three frustrations: idiomatic code patterns (33%), missing language features (28%), trustworthy module discovery (26%) - 13% of respondents new to Go (vs. 21% in 2024), attributed to entry-level hiring decline - 78% not building AI features; 14-point year-over-year decline in AI adoption among survey respondents ... Developers switching between Go and Python/Rust/TypeScript face cognitive load from different idioms—addressing this could improve onboarding and reduce friction for polyglot teams. Source: go.dev

This is a story about the downsides of the Go programming language, the part about it that makes us less productive and our codebases less safe and less maintainable. ... ### Lack of Visibility Modifiers The first root cause of namespace pollution is the lack of visibility modifiers. In what I believe to be an effort to reduce redundant keywords and enhance simplicity, the language designers decided to omit visibility modifier keywords (`public`, `private`, etc…) in favor of symbol naming. Symbols starting with an uppercase letter are automatically public and the rest are private. Sounds like a great choice to promote simplicity. But over time it’s becoming clear that this method has a stronger downside than upside: In most other languages, type names, by convention, begin with an uppercase letter, and variable names begin with a lowercase one. This convention has a very powerful implication — it means that variables can never shadow types. … ``` |1 2 3 4 5 6 7 8 9 10|// type shadowing in Go type user struct { name string } func main() { user := &user{name: "John"} anotherUser := &user{name: "Jane"} // compilation error: user is not a type }| |--|--| ``` This is very common in Go, and I bet most Gophers run into this at some point. In most cases, your coding scopes deal with one user instance, so naming it `user` should be a clear and reasonable choice. However, in Go, whenever you store a private type into a private variable or a public type into a public variable — you run into this. **So you simply start naming your user variables** `u`. … Other problems with lack of native enum support? What about **iterating all possible values** of an enum? That’s something you need every now and then, maybe if you need to send it to the UI for a user to choose one. Not possible. What about **namespacing**? Isn’t it better for all HTTP status codes to reside in a single namespace providing only HTTP status codes? Instead, Go has them mixed with the rest of the public symbols of an HTTP package — like Client, or Server, and error instances. … Initially, I was furious with the designers of the library for not enforcing prevention of such a mistake, “if it happened to me” and everything. Then I thought about it more and realized, they can’t. Go simply does not provide it. At glance, struct literals look like the perfect candidate for config params use case, allowing you to pass in exactly what you need, and omit the rest. But turns out it’s the opposite. … In Go, wrapping each error with another error up the entire call stack, and then garbage collecting all the created objects is almost as expensive. Not to mention the manual coding. If this is what you’re advocating, you’d better off in a try-catch environment, to begin with. Stacked traces can be very useful when investigating errors and bugs, **but the rest of the time they’re highly expensive redundant information**. Maybe a perfect error-handling mechanism would have a switch to turn them on and off when needed. 🤷‍♀️ … This is terrible in terms of performance. But more scary is the fact that it’s not guaranteed. Obviously, `"oops...network error"` can change at any time, and there isn’t any compiler enforcement to help us out. When the author of the package decides to change the message to `"oops...there has been a network error"`, **my error handling logic breaks**, you’ve gotta be kidding me. … In my opinion, the lack of solid community conventions in combination with an ineffective async return value mechanism is the **root cause of terrible coding**, and this is kind of a **standard in the Go community.** [my deepest and sincere apologies to everyone who’s hurt by this paragraph]. Some examples? How about a 400-line function in one of the most popular HTTP frameworks in Go 😨, how about a 100-line function in Google’s gRPC library? … ## Summary If you combine community conventions and naming problems with async return value problems, you end up with **hugely popular libraries** shipping code with complex, 100+ line functions, using one-letter undocumented variables, declared at the other side of the package. This is extremely **unreadable and unmaintainable, and surprisingly common**. In addition, as opposed to other modern languages, Go doesn’t provide any kind of runtime value safety. This results in many **value-related runtime issues** which can easily be avoided.

{ts:357} working with AI powered applications already use go or would like to migrate to go for their AI powered workloads and the most serious challenges developers encountered are related to the the library and documentation ecosystems rather than the core language and runtimes that said the most commonly documented paths for getting started are {ts:373} currently python Centric resulting in many organizations starting AI powered work in Python before moving to a more production ready language the word workload makes me laugh I don't know why I think it's the way you say it but I'm really aggressive when I say it um what you're you're an … {ts:1350} responses in the closed Forum were learning how to write go effectively and verbosity of error handling this matches what we saw in open text form where 11% of responses mentioned learning go learning best practices or issues with documentation as their biggest challenges and another 11% mentioning error handling uh my guess is that

**Observability in Go is still a puzzle** Go offers incredible performance and simplicity – but when it comes to observability, it lags behind its peers. Across interviews, we consistently heard the same theme: **instrumentation in Go is painful**. Compared to Java or Python, where tools like OpenTelemetry work out-of-the-box, Go often requires significant manual effort, boilerplate, and careful context propagation. Instrumentation in Go took us 6–8 months. It was worth it – but a huge pain.Others simply gave up on manual instrumentation entirely. **The cost of too much data** Another recurring pain point was **data overload**. As one user put it: “We generate trillions of requests. Filtering that down is everything.” … Still, even with all this tuning, **telemetry costs and data quality issues**remain a problem for many. **Tracing: loved and hated** There’s a universal recognition of the power of **distributed tracing**, but also wide frustration with the current tools and workflows. **Common issues:** - Lack of automation in Go - Forgetting to pass context - Weak trace search (especially with Jaeger) - Span gaps (especially around databases and queues) Despite these challenges, nearly everyone wanted better tracing – not fewer traces. *Tracing helped us catch a memory spike that would have taken weeks otherwise.* ... **Auto-instrumentation**: Especially for HTTP/gRPC and third-party libraries **Span coverage tools**: “Why is this path not instrumented?” **Minimal code pollution**: Nobody wants another

## The Challenges of Plain Go in 2025 While Go still has significant strengths, using plain Go without any frameworks presents several challenges in the modern development landscape, especially for more complex applications. ### Increasing Complexity of Modern Applications In 2025, even a simple microservice may need to integrate with multiple dependencies to meet production standards. These might include tools for distributed tracing, metrics collection, circuit breaking, and various communication protocols. Managing these integrations manually in plain Go often results in significant boilerplate code and a higher maintenance burden. |Challenge|Plain Go|Frameworks (e.g., GoFr)| |--|--|--| |Integration|Manual|Built-in integration of logging, tracing, and messaging| |Code Redundancy|High|Low (predefined patterns)| |Maintenance|High|Low (centralized updates)| ### Reinventing Common Patterns Without frameworks, developers often find themselves reimplementing common patterns and solutions to recurring challenges. This might include setting up logging, configuring middleware, implementing health checks, or managing database connections. Such redundant work can slow down development and introduce inconsistencies across projects. ### Onboarding and Knowledge Transfer In today's competitive job market, the speed at which new team members become productive is crucial. With plain Go, developers may spend days or even weeks learning the project-specific implementations of common patterns before they can contribute effectively. This extended onboarding process can negatively impact project timelines and team productivity. … #### GoFr's Unified Architecture ### Unified Communication Patterns In today's development world, applications rarely rely on a single communication protocol. They often need to support RESTful APIs, WebSockets, event-driven architectures, and other messaging patterns. Plain Go requires developers to integrate different libraries and maintain separate handlers for each communication style. … The ideal approach may be a pragmatic one: use plain Go where its simplicity and performance are paramount, and leverage frameworks like GoFr where productivity and standardization matter most. By making these decisions deliberately, teams can maximize Go's strengths while minimizing its limitations in the complex software development landscape of 2025.

- The biggest challenge for teams using Go was **maintaining consistent coding standards** across their codebase. This was often due to team members having different levels of Go experience and coming from different programming backgrounds, leading to inconsistencies in coding style and adoption of non-idiomatic patterns. … This suggests that current offerings are ... Similarly, in 2023, 47% respondents said they would like suggestions for best practices while coding, while only 14% a year later said they are using AI assistance for this use case. 46% said they wanted help catching common mistakes while coding, and only 13% ... … The most commonly reported challenges for teams were maintaining consistent coding standards across our Go codebase (58%), identifying performance issues in a running Go program (58%) and identifying resource usage inefficiencies in a running Go program (57%). 21% of respondents said their team would benefit most from maintaining consistent coding standards across their Go codebase. This was the most common response, making it a good candidate to address. ... According to the write-in responses, many teams face challenges maintaining consistent coding standards because their members have varying levels of experience with Go and come from different programming backgrounds. This led to inconsistencies in coding style and the adoption of non-idiomatic patterns. ... They seem to struggle maintaining the code consistency following the Go guidelines.”—Go developer with 2–4 years of experience.* ... For those who were at least slightly familiar with SIMD, we asked some follow -up questions to understand how respondents were affected by the absence of native SIMD support in Go. Over a third, about 37%, said they had been impacted. 17% of respondents said they had been limited in the performance they could achieve in their projects, 15% said they had to use another language instead of