filter VS go

Here’s Rob Pike’s (one of the original Go designers) attempt to “see what the hubbub is all about”: https://github.com/robpike/filter

I find the language really solid but asking on r/golang is quite an adventure. It's extremely distant from go's spirit, the grammar is even more rich than Rust. Typical example: let, run, with, apply, and also - they all practically do the same but with a different scope of this and return value. Just looking at the flow API can get your head spinning. To illustrate how much it's completely the opposite of Go, see how Rob Pike pokes fun at map/filter and tells people they should not use it . I guess you can't force all developers to adhere to this mental model, but that's about it, but that's about it, technical arguments are irrelevant except for extremely niche concerns about memory and startup time

I mean sure, let's praise the ergonomics of channels and the reliability of maps. As for datastructures, we already have datastructures at home . They just work fine. Nobody needs more than that because rob pike told us so

Go will never have a map/filter syntax, to the point rob pike even makes fun of it , do you really want to use it for that kind of domain ?

Also since generators are mentioned I recently came across this rob pike moment, he implemented a reduce function that takes and returns all interface{} types and uses reflection to check if the call is valid at runtime - that's the most typical Go that can ever be written in 40 lines - all that to make the point that it's useless. Such a great spirit. https://github.com/robpike/filter

A few points that stood out to me: error handling in Go is generally pretty good. It's much more performant compared to throwing exceptions and the high frequency of error handling helps a lot with debugging and avoiding unexpected errors. What you've described as "poor OOP'ish" is partly true, yes Go does poor OOP, because it doesn't try to do OOP. The language favours composition over inheritance. Strongly applying OOP concepts in Go is simply not using the language in its intended way. For implicit interfaces, it's completely fair that you don't like them, but it's not a disadvantage of the language. I for one find implicit interfaces very intuitive and feel it's the right way for it to be done. No function overloading and lack of ternary operations is absolutely intentional, both of these are overcome by writing more expressive code, which is not a bad thing. Similarly with no built in map/filter/find, these can be achieved using for-loops. Reference https://github.com/robpike/filter for Rob Pike's implementation of filter, stating in the readme that there's not much use for it and to just use for-loops instead. Last thing, enums are expressed using iota: https://go.dev/ref/spec#Iota

> I didn't get that desire for purity that you gleaned from it.

'Folks who develop an allergic reaction to "big balls of mutable state without sum types" tend to gravitate towards languages that gives them control over mutability, lifetimes, and lets them build abstractions.'

This mutability argument is present throughout the article. Seems like nothing sans Rust or niche functional languages is enough.

> Nil pointer exceptions, for example, don't have to exist anymore..

The language most notorious for those is Java due to almost everything being passed via a nullable reference. When everything can be nullable, how can you know where to check for it? Go addresses this to an extent by explicitly separating pointers from values. Values are the default and cannot be nil, so the opportunity for null dereferences is greatly diminished. It's not a perfect solution, but it's not nothing either.

> and yet they do in Go because they couldn't be bothered to add sum types.

Damn those lazy Go devs!

> Its type system is barely a step above a dynamic language.

Turns out even a basic type system is a huge improvement over none. Just being able to restrict values to concrete types goes a long way.

> You have to write the same imperative looping code over and over because Rob Pike would rather just use a for loop than something mildly expressive like map or filter (https://github.com/robpike/filter).

There are arguments to be made either way, but I definitely agree generics (along with iterators) should have been there since day 1.

> Every function that does meaningful work is littered with if err != nil { return err }.

One big positive of this that I don't see in other languages is every `return` in a function must be on the start of a line. That is, every single exit path of a function is easily findable by visually scanning

A Discussion about including this package in Go as encoding/json/v2 has been started on the Go Github project on 2023-10-05. Please provide your feedback there.

I like the Principles section. Very measured and practical approach to releasing new stdlib packages. https://go.dev/blog/randv2#principles

The end of the post they mention that an encoding/json/v2 package is in the works: https://github.com/golang/go/discussions/63397

There used to be the GO FIPS branch :

https://github.com/golang/go/tree/dev.boringcrypto/misc/bori...

But it looks dead.

And it looks like https://github.com/golang-fips/go as well.

I'm not sure what exactly you mean by acknowledgement, but here are some counterexamples:

- A proposal for sum types by a Go team member: https://github.com/golang/go/issues/57644

- The community proposal with some comments from the Go team: https://github.com/golang/go/issues/19412

Here are some excerpts from the latest Go survey [1]:

- "The top responses in the closed-form were learning how to write Go effectively (15%) and the verbosity of error handling (13%)."

- "The most common response mentioned Go’s type system, and often asked specifically for enums, option types, or sum types in Go."

I think the problem is not the lack of will on the part of the Go team, but rather that these issues are not easy to fix in a way that fits the language and doesn't cause too many issues with backwards compatibility.

[1]: https://go.dev/blog/survey2024-h1-results

Now, I’m not going to use C++ again; I left that chapter years ago, and it’s not going to happen. C++ isn’t memory safe and easy to use and would require extended time for developers to adapt. Rust is the new kid on the block, but I’ve heard mixed opinions about its developer experience, and there aren’t many libraries around it yet. LLRD is too new for my taste, but **Go** caught my attention.

Generative AI development has been democratised, thanks to powerful Machine Learning models (specifically Large Language Models such as Claude, Meta's LLama 2, etc.) being exposed by managed platforms/services as API calls. This frees developers from the infrastructure concerns and lets them focus on the core business problems. This also means that developers are free to use the programming language best suited for their solution. Python has typically been the go-to language when it comes to AI/ML solutions, but there is more flexibility in this area. In this post you will see how to leverage the Go programming language to use Vector Databases and techniques such as Retrieval Augmented Generation (RAG) with langchaingo. If you are a Go developer who wants to how to build learn generative AI applications, you are in the right place!

net/http: add methods and path variables to ServeMux patterns Discussion about ServeMux enhancements

Make sure you have Go installed https://go.dev/.