News for hackers. Stuff that matters.
Re:Swift Algorithms by coldtea on Wednesday October 07, 2020 @10:12PM (#24714936)
One issue with Go's lack of generics is exactly that it can't have such a package (and have it be type safe, fast, and work across all relevant types), except with repeated code.
Re:Swift Algorithms by benhoyt on Wednesday October 07, 2020 @11:02PM (#24715233)
Yeah, though a solution is in the works, and looking pretty likely to happen. Here's the official draft design for generics or "type parameters" in Go: https://go.googlesource.com/proposal/+/refs/heads/master/des...
Re:Swift Algorithms by wlib on Wednesday October 07, 2020 @11:14PM (#24715316)
Dependently typed Golang when??

In all seriousness, it feels like go's reputation of simplicity is at odds with its design. Instead of making a simple and highly generalized core from which anything can be composed, it has a specialized, familiar core that engineers are comfortable with.

When I take this question further, I begin to wonder why we even use text syntax for programming. What if we just had a graph structured programming "language" that is edited indirectly through different projected syntaxes that aren't necessarily monospaced text. Almost like lisp, but translated into different frontend languages, potentially graphical. (Maybe off topic but whatever)

Re:Swift Algorithms by ironmagma on Thursday October 08, 2020 @02:09AM (#24716363)
You can do that but the cognitive overhead of understanding what code is represented becomes more of a burden than the burden of producing logic that is correct and fulfills requirements. You can see part of this in lisps where the arguments of many functions form their own de-facto languages. Then you are not only writing code, but writing it in a variety of different languages that share only a common syntax.
Re:Swift Algorithms by fiddlerwoaroof on Thursday October 08, 2020 @02:18AM (#24716400)
The thing is, I've never found this to be a huge issues in lisps: partly because plenty of languages have libraries that are essentially the same sort of thing, but less ergonomic: Spring/Hibernate in Java, Spark and the various FP stuff in Scala, Ruby on Rails, React. Any sufficiently complex library is essentially an embedded language that must be learned in addition to the base language: the cost of learning a language made out of macros isn't much different from learning a library with a large API surface area.

In fact, since macros reduce the noise in the "language" a library implements, I've generally found that macro-based libraries are somewhat easier to learn than libraries in other languages.

Re:Swift Algorithms by fauigerzigerk on Thursday October 08, 2020 @04:54AM (#24717241)
Here's the dilemma as I see it:

A carefully designed library that introduces a small set of coherent concepts can make good use of powerful syntactic abstractions and result in readable and succinct code.

But application code that implements a large number of one-off requirements is far harder to read if you cannot rely on fixed semantics of basic syntactical elements.

The usual response to that is to say that we shouldn't restrict the features available to good developers just because bad developers might abuse them.

But this argument is flawed. If you read syntax that can be overloaded then you have to account for the possibility that it actually is. It's the possibility that creates the mental burden, not the fact.

I think the solution is for languages to provide a basic set of syntactical elements that cannot be overloaded and are sufficient to write all code. Additionally, there should be optional syntactical elements that can be overloaded even to the point of creating DSLs.

The important point is, there has to be a local cue that tells you whether or not you have to watch out for redefined semantics.

Re:Swift Algorithms by eecc on Thursday October 08, 2020 @02:42AM (#24716509)
Re:Swift Algorithms by saagarjha on Thursday October 08, 2020 @03:47AM (#24716873)
Text is readily manipulated using a variety of tools.
Re:Swift Algorithms by pmiller2 on Wednesday October 07, 2020 @10:23PM (#24714998)
Sounds to me like a job for a DSL that compiles down to Golang for the final output. That way, the repeated code only exists in the Golang output and not in the code that humans actually write.
Re:Swift Algorithms by setr on Wednesday October 07, 2020 @10:31PM (#24715034)
the solution is... to not use Golang!

more specifically, fairly basic operations on a list of data does not seem like it should call for the complexity of a DSL. IMO unless you need to do this quite a bit on random datatypes, copy & paste would probably be the better alternative. Unless you're referring to a DSL that looks exactly like Golang but with generics & monomorphism.... in which case ok I guess

Re:Swift Algorithms by pjmlp on Thursday October 08, 2020 @02:37AM (#24716474)
When that solution is possible, sometimes project requirements make us use tools that we rather not, but have to.
Re:Swift Algorithms by bee_rider on Wednesday October 07, 2020 @10:55PM (#24715189)
Googling about this (I assumed the actual 'solution' would be a to use C-style awful macro kludges) eventually lead me to:

https://blog.golang.org/generate

Now I'm wondering if you joke was not actually a joke.

Re:Swift Algorithms by pjmlp on Thursday October 08, 2020 @02:34AM (#24716465)
This is how C++ compilers used to work before templates came into the picture.

For example Borland's BIDS 1.0 in Borland C++ for MS-DOS, it was based on the C pre-processor, as you would define a set of macros and then include the desired type, something like

    #define LIST_T int
    #include <bids/list.h>

    #define LIST_T float
    #include <bids/list.h>

and so on, however when BIDS 2.0 was released, there was already primitive support for the ongoing ISO discussions and it was rewritten to use templates.

To be fair, Go generics seem to be finally on their way to be adopted into the language.

Re:Swift Algorithms by xmprt on Thursday October 08, 2020 @02:37AM (#24716473)
We have a lot of codegen in our codebase right now and I can't wait for the day that generics are finally added.
Re:Swift Algorithms by pjmlp on Thursday October 08, 2020 @08:08AM (#24718341)
As heavy critic, but also fan, I have been following up on it, and the last update on the document is from September, so I am positive they might make it, it just appears the proper implementation still has some engineering challenges.

https://go.googlesource.com/proposal/+/refs/heads/master/des...

Re:Swift Algorithms by Joker_vD on Thursday October 08, 2020 @09:05AM (#24718738)
Well, and there is also kinda sorta support foir generics on top of it:

https://github.com/vasilevp/aboriginal

There is no engineering challenge that can't be overcome by ingenious thought!

Re:Swift Algorithms by dmitriid on Thursday October 08, 2020 @02:04AM (#24716336)
> Sounds to me like a job for a DSL that compiles down to Golang for the final output.

So, you mean it's the job for generics. Which is a DSL for, well, generic types that compiles to final output. That way, the repeated code doesn't even exist, especially not in the code that humans actually write.

Re:Swift Algorithms by vips7L on Wednesday October 07, 2020 @11:31PM (#24715424)
Instead of just using an actual good language?! Go is the problem!
Re:Swift Algorithms by hazz99 on Thursday October 08, 2020 @12:30AM (#24715812)
"Good" is meaningless – there is no absolute measure of the relative value of one programming language over another. C is not "better" than Python, or vice versa, just different tradeoffs for different problems and programming styles. The same is for Go.
Re:Swift Algorithms by vips7L on Thursday October 08, 2020 @05:03AM (#24717278)
I think there is some measure of value to not having to use a whole different language to generate go because it's incapable of making maintainable code without it.

This is stockholm syndrome.

Re:Swift Algorithms by hazz99 on Thursday October 08, 2020 @06:01AM (#24717622)
Part of Go’s tradeoff is managing that extra effort (or delay in waiting for the features to hit the main branch) in return for an extremely stable, simple language.

You might find that to be a terrible idea, but others ostensibly think differently (Go is quite popular)

Personally, I prefer more advanced type systems. But I understand Go can be a good choice in other situations.

Re:Swift Algorithms by nicoburns on Thursday October 08, 2020 @07:57AM (#24718271)
> Go is quite popular

Well sure, but inheritance and enterprise-style Java were all the rage in the 90s, but they largely haven't stood the test of time. I rather suspect Go will be similar. It has some good ideas, and it's compiler toolchain is top-quality. But I'd be willing to bet that the languages we're using in 20 years time look a lot more like Rust/Swift/Kotlin and TypeScript/Julia than Go.

Re:Swift Algorithms by pjmlp on Thursday October 08, 2020 @08:15AM (#24718394)
Go will eventually grew up to be like Java and Cä# in 2020.

Java was released in 1996, and only got enterprise-style C++ adoption around 2000.

Until then, the inheritance and enterprise-style programming was done in a mix of Smalltalk, Eiffel, C++ and C based OOP.

Julia is basically Dylan/Common Lisp at its kernel, Java and C# are getting all the ML like goodies to stay relevant, see C# vs F#.

Re:Swift Algorithms by ironmagma on Thursday October 08, 2020 @03:00AM (#24716611)
Kind of, but C and Python have undergone many iterations to try to become as good as they can be, while Go has lagged behind and almost prides itself on how uncomplex it is which is unfortunate only because people crave for it to be more complex. With languages like C and Python, the complexity and capability is there; it’s on you to decide when to use it. With Golang, you are just SOL.
Re:Swift Algorithms by Philip-J-Fry on Thursday October 08, 2020 @03:26AM (#24716756)
The thing is, do you want so many iterations to get something close to being good. Or do you want people to work with the community and decide together what a feature should look like and then get it in a good shape at day 1.

Like, ask any python dev what dependency management is like. That's what iteration gets you. Take your time and you get in a much better shape.

Re:Swift Algorithms by ironmagma on Thursday October 08, 2020 @02:44PM (#24722324)
Thing is, I’m not convinced Go is actually “taking their time,” it’s just intentionally crap and there won’t be any significant improvements. Generics have been “coming” since the language became popular ~10 years ago.
Re:Swift Algorithms by mhh__ on Wednesday October 07, 2020 @10:43PM (#24715113)
If you do that you have no soul. Why complicate it when you can just have generics that work from the get go
Re:Swift Algorithms by Cthulhu_ on Thursday October 08, 2020 @03:39AM (#24716827)
Because generics is a nontrivial problem to solve in languages and compilers; a really great comment that I bookmarked is here: https://news.ycombinator.com/item?id=9622417. I read elsewhere (can't find it now) just how much lines of code and language spec is dedicated to generics in Java.

Right now, the Go spec + compiler chain are a lot simpler; adding generics would have made things a ton more complicated. Second, by first spending a lot of time perfecting the core language, understanding it, and resolving early issues, they have a much more stable base now to build generics on top of it. As the comment also implies, they take things slow and steady when it comes to Go; it's a language made to run core systems (e.g. at Google) for the next 30-50 years.

Re:Swift Algorithms by mhh__ on Thursday October 08, 2020 @02:09PM (#24721966)
All I can say to that is: Taking Java and C++ to be generics as god intended is not a particularly good thing to plan around. D's generics are concise, strict, relatively simple, and mostly understandable by mere mortals (in the compiler) - this is a totally solved problem for a language like D, if Go can't do it then it's their own fault.
Re:Swift Algorithms by spullara on Thursday October 08, 2020 @02:01AM (#24716321)
Ah the original templates from C++.