Live data from Hacker News

The State of Go

talks.golang.org

111–120 of 172 posts

Re: The State of Go

#111
post #52

I always have this question: Since a large project like Golang has so many auto-build tools and test OSes, how hard is it to provide a binary download for e.g. Ubuntu 14.04 LTS? You know, not tarballs, but actual static binaries as deb packages installable via apt-get. Good examples: http://wiki.nginx.org/Install https://www.percona.com/doc/percona-server/5.6/installation/... I root for open source movement, but to i…

For debian-esque, I use https://github.com/niemeyer/godeb .

Re: The State of Go

#112
post #76

Oh man, dynamic loading of Go libraries is going to be awesome. I'm in the process of developing an http API framework/server (yes, yet another one, but why is a different topic). This will allow me to compile the actual APIs running on the server (multiple APIs can run on one server) as shared libraries and have the server automatically start them.

As far as I know there is still no easy facility to dynamically load libraries at runtime (like the analogous 'dlopen' in C). There are shared libraries and they can be linked at compile time so it's a step in the right direction.

Re: The State of Go

#114

Earlier quoted context omitted.

Doesn't it? Why do people seem to compare them all the time...

Rust is a systems-level programming language. Go isn't: it's garbage-collected.

Besides the sibling post.

Xomb, Mesa/Cedar, Oberon, SPIN, Singularity were all written in GC enabled system programming languages.

Re: The State of Go

#115
post #76

Oh man, dynamic loading of Go libraries is going to be awesome. I'm in the process of developing an http API framework/server (yes, yet another one, but why is a different topic). This will allow me to compile the actual APIs running on the server (multiple APIs can run on one server) as shared libraries and have the server automatically start them.

As far as I know there is still no easy facility to dynamically load libraries at runtime (like the analogous 'dlopen' in C). There are shared libraries and they can be linked at compile time so it's a step in the right direction.

The spec that's linked from the presentation says that it should be possible (and has an example API usage). Unless they didn't implement it fully, of course, or it's due for a later Go version.

> to support Go packages that want to use plugins, a new package will be added to the standard library: plugin. It will define a function and a type.

https://docs.google.com/document/d/1nr-TQHw_er6GOQRsF6T43GGh...

[EDIT] I looked at the commits and it looks like it's not in the works, at least on the main repo.

Re: The State of Go

#116
post #37

Earlier quoted context omitted.

There was a big push from the linux distros as the maintainers had anneurisms thinking they'll need to rebuild hundreds of Go applications when/if a big bug is found in the Go standard library. They also don't like the idea of having N copies of the code for the standard library in N Go applications. Personally, I find that kind of thinking to be a relic of the past when memory and disk space were expensive and compi…

> Personally, I find that kind of thinking to be a relic of the past when memory and disk space were expensive and compilation took a long time. OTOH, it does well with the culture of making a lot of small, specialized executables rather than a single, monolithic application.

Not really? That doesn't seem like it has anything to do with static linking vs. shared libraries.

My point was rather that a 3MB executable used to be "large" and now it's not, even if you have 100 of them.

Re: The State of Go

#117
post #113
post #98

Earlier quoted context omitted.

Yet Limbo is used nowhere. Now that's a paradox ! ;)

Didn't you get the memo? It got revamped into Go after a conversation with Oberon-2. :)

Robert Griesemer is the Oberon guy in the Go team. He worked for Wirth on Oberon at ETH Zürich.

Re: The State of Go

#118

Earlier quoted context omitted.

Why Rust? It doesn't really compete with Go anywhere. I guess people compare Rust and Go because they were released in similar timeframes and people like to view things in competition. Rust is especially attractive when you can't afford a garbage collector, need deterministic destruction, and full compatibility with C. It's what C++ would be if it could start from scratch. I think your point needs to be re-iterated m…

> similar timeframes I hope you understand first stable release of Rust happened less than 2 weeks ago (15 May 2015), vs. Go's Go 1 in March 2012. 3 years is pretty big difference.

Go was first publicly announced in November 2009, Rust in July 2010.

Re: The State of Go

#119
post #39
post #23

Earlier quoted context omitted.

It might also make it possible to write Node/PHP/Ruby/Python libraries in Go instead of C++. I've been looking at Rust for that use but the ability to compile Go to a C archive throws in back in the running.

I don't think you can compile go to a C archive that runs without the runtime.

Presumably the necessary parts of the go runtime would be embedded in the C archive (or a DLL'd libgo.a file); how else would you be able to use the C archive in a C application?

Re: The State of Go

#120
post #14

Earlier quoted context omitted.

You created a burn account just to complain about this? As you know, generics won't appear before 2.0, if ever. It's fine if that's a nonstarter for you. Perhaps you'll like Rust instead. It needs a big community too.

Why Rust? It doesn't really compete with Go anywhere. Haskell is a much stronger player in the space of high-level, garbage-collected languages. The only thing Rust and Haskell really have in common is not willfully ignoring the last 50 years of programming language design research.

Actually, I read an interview with one of the Rust devs recently where he said that one of the meanings behind the name "Rust" is that they purposely chose not to use any ideas from programming language research within the past 10 years. IIRC it was because they wanted to use only ideas that had had some time to mature and be used in practice. So yes, Rust chose to willfully ignore at least some of the past 50 years of PL design research. :)
Post reply on HN