dcu

tailwind is like Go, at first it seems like a bad idea but it works really well in practice

have you looked at zapsign.co? it's a good UX and it's not too expensive

wouldn't that lead to analysis paralysis? it seems you're avoiding the decision which many people consider the worst decision

OOP is still here and microservices(especially since aws lambda) is just getting stronger and stronger every year

Clean Code is not bad in itself. The problem is that some people made it a bible, like the absolute truth (I guess it is written in that way), and that's where it fails.

yes, it's awesome. I also asked about this here: https://news.ycombinator.com/item?id=25267921

hopefully we'll see ML chips on Lambda soon too

let's hope generics doesn't become a over(ab)used feature, that'd make the code harder to read and my experience harder to maintain, especially because when you need to fix something it takes a lot of time getting in context so you can actually write the code for the fix.

I mostly write Go these days and haven't found many use cases where generics are needed but there are definitely cases where they would make the code nicer.

they mean safety, because using `interface{}` is like using dynamic languages (python, js, ruby, ...)

We use it for inference and it works fine. Now with EFS support it's even better.

We have used it successfully with both Tensorflow and Gorgonia

hi Chris, maybe slightly off-topic but is there a chance to see gravitons and/or ML chips on Lambda? :)

parser look ahead makes the compiler complex and slower and that goes against the Go goals

the HTTP benchmark is not fair since the crystal implementation is setting the content type explicitly while the Go implementation is auto detecting it.

I think Go is popular because of its simplicity and fantastic standard library.

It can also feel sometimes like a dynamic language which has attracted people from ruby, python, JS, etc... communities.

You say there's no place for it in the 21st century, yet it already has a place and it doesn't really need generics to continue living.

The Twilio API includes a X-Shenanigans header on every request, always set to "none", of course :)

> $ curl -I https://api.twilio.com

these microbenchmarks doesn't say anything about real world use cases... but anyway, here are the latest results:

https://www.techempower.com/benchmarks/#section=data-r17&hw=...

c#, rust, go, c++, java, c, nim.. all tied at 7M.

again, this doesn't mean anything useful.

Blast is a server on top of it: https://github.com/mosuka/blast

have your tried using apps like nomorobo or trucaller?

here's the code: https://github.com/therecipe/widgets_playground

I just found this link https://labs.ig.com/static-typing-promise Clojure seems to be the best followed by Go, both designed to be simple

can you link the studies? I'm genuinely interested

that's called a memory leak: https://en.wikipedia.org/wiki/Memory_leak

I've seen happening in Go multiple times when people forget to close the response body after making a http request.

I meant go's compatibility promise https://golang.org/doc/go1compat which is totally different, and no they are not ignoring the "community" they are just keeping that promise which I and many Go users appreciate.

These kind of stories make me value Go's approach a lot more. You just have to worry about making your product better.

no, you and your team have to worry about not making a change that could render your whole stack useless

additionally you can run it from a single management host (or Jenkins), for example, so the state is always up to date

there are blogposts here detailing some use cases and experiences: https://github.com/golang/go/wiki/GoUsers#united-states

This beta includes experimental support for modules (also known as vgo)

if you're interested, there's a series of articles explaining how modules work here: https://research.swtch.com/vgo

Ruby's GIL will get in your way when working with real world apps. Also in this recent run gin doubles Sinatra's performance

https://www.techempower.com/benchmarks/#section=test&runid=a...

I've been using `glide` for a few years now, no issues at all. It's the same as cargo(rust), bundler(ruby), npm(js). Thanks to Go it's probably better since deploying dependencies in those languages is really painful.

And not mentioning the security issues associated with having a central repository for packages.