1. 8

    I’m still unconvinced contracts need to be strictly separate from interfaces. The argument that enforcing operators would be repetitive maybe falls flat on me because it seems trivial to ship the stdlib with some basic Operatable interfaces you can reach for, but also that doing a bit of extra typing for clarity I’ve generally seen as part of the golang ethos.

    Similarly, the idea that you can never have discrete instances of contracts (versus interfaces) runs counter to how I’ve used generics in the past where generic constraints are just interfaces and you can reference the type constraint interface when declaring values later.

    1. 6

      Agreed on interface reuse. My guess is adding new semantics to interface is hard to back out of, where as “contracts” can just ultimately be deprecated when the dictators decide that the experiment “failed.”

      OK, maybe that’s not fair. But, I agree that there’s a weird resistance to extend something that seems to really make sense, in favor of adding something completely new. Either way, 3rd party tooling will be broken until updated…

      1. 2

        They extended functions and types to accept type parameters, but then they neglected to do the obvious thing which is extend interfaces with type parameters. Do that, then allow interfaces to be the specifiers in the type parameters list - done. They dedicated a whole section to this but every argument is unconvincing and evinces a lack of imagination. Just read this:

        Contracts, unlike interfaces, support multiple types, including describing ways that the types refer to each other.

        Then add type parameters to the interfaces.

        It is unclear how to represent operators using interface methods.

        Other languages either map operators to a special name or provide a syntax for the overloading. Most design documents have a prior art section - do your homework!

        An interface is a type, not a relationship between function definitions and callers. A program can have a value of an interface type, but it makes no sense to speak of a value of a contract type.

        Again, there is no creativity here or an attempt to see what other people have done. Expand the definition of interface. I would solve the problem like this: if an interface appears in a type parameter list, the type is unboxed and preserves its type, whereas if it occurs in a parameter list as a type, then it is the usual boxed interface. It is really that simple. This also happens to be nearly exactly what Rust did for a long time.

        In other words, contracts are not extensions of interface types.

        This is wrong. It’s wrong, it’s wrong, it’s wrong.

        I will end this comment with just a little bit of polemic, which by now is par for most comments about Go but totally deserved: I do not trust the language designers. There is too much NIH syndrome, too much anti-intellectualism, too much reinvention of solved problems. It is a waste of a great runtime. Use something else.

        1. 7

          do your homework!

          It seems manifestly obvious that they did, considering the design document cites numerous languages and how their design improves on past mistakes. Consider cutting back on your hyperbolic ranting and snobbery; it undermines your commentary.

          1. 2

            That comment was specifically about the preceding quotation.

            1. -1

              His comment is fine.

              Just because he criticizes your language doesn’t mean you get to insult him.

              1. 3

                He is on the Rust team…

                1. 0

                  That’s an appeal to authority and you know that.

                  Also, being an authority doesn’t stop you from being an ass because you misinterpreted someone else’s comment as being “I am very smart” to utterly dismiss their content.

                  1. 6

                    no, i mean @soc said that @kristof was criticizing @burntsushi’s language.

                    but thats not the case. the language being criticized is Go, and AFAIK @burntsushi has nothing to do with Go, other than maybe being a user. He is on the Rust team, hence my comment. Sorry that was not clear. i mean just look at this bio:

                    https://github.com/BurntSushi

                    1. -1

                      I know who the BurntSushi is. Thanks for the link. Perhaps you can send me a link to his profile because I am blind and deaf as well.

            2. 2

              They extended functions and types to accept type parameters, but then they neglected to . . . extend interfaces with type parameters.

              Although the draft doesn’t explicitly mention interfaces as a possible parameterized type, I don’t see anything that would imply they aren’t supported.

              1. -1

                I do not trust the language designers. There is too much NIH syndrome, too much anti-intellectualism, too much reinvention of solved problems.

                I don’t think this is polemic, it’s spot-on.

            1. 2

              UPDATE

              They’re removing this tracking according to the CEO:

              https://twitter.com/rahulvohra/status/1146539948276740096

              1. 17

                It’s nice to read the Etsy story from the author. Also, his point is something I also agree with, having gone through similar product lifecycles (from creating something new and fun to maintaining and iterating on it). The main takeaway from these slides for me is this:

                Software that’s been around longer tends to need less care and feeding than software that just came out.

                This, a thousand times. Once you worked with a mature piece of technology in a domain, you get to relate and compare to it. A great example at my recent company is Go. We have two camps of engineers: ones who want to use Go and those who vote for Java. The main argument for the Java folks was the maturity of the tooling and environment.

                Some teams chose Go. Some did Java. A few years down the road with services in production, the Go teams started to realise the gap they had in tooling, standard libraries and the lot compared to teams working in Java. Some teams migrated to Java, but most of them are just spending a bunch of time building these tools from scratch or contributing to existing solutions, to add the support.

                There’s nothing good or bad, choosing new and different technologies. But it’s good to take the additional effort and additional learning into consideration when doing so - and in many cases, this might actually be a reason to choose a new technology over an existing one!

                1. 12

                  What gaps did the teams run into with Go?

                  1. 7

                    The biggest limitations we have found were maturity of toolchains and the availability of high-quality libraries in Java that were not there with Go a few years ago. Both have nothing to do with the language and everything to do with the maturity of the ecosystem.

                    For example, Java has excellent tooling for IDE integration, refactoring, static analysis, garbage collection analysis. Debugging I’m production has strong tooling support. Go is catching up in these areas.

                    Stream packages like RxJava, high-performance networking libraries like Netty, inter-threading libraries like Disruptor were readily available and important to some services that decided to go with Java. Again, a lot of teams/services either did not need these or considered the lack of them no dealbreaker when going with Go, considering some of the other upsides, like the canonical style and the strong community and growth around it.

                    Most of my points were for Go 2-3 years ago. The ecosystem is growing fast, libraries and tools becoming more mature. But this approach will be true for the next “new” language or framework a team picks - which may not even exist today!

                    1. 6

                      We’ve run into situations with inconsistent quality with ecosystem libraries (lots of breaking changes requiring aggressive vendoring / forking), or just not having an equivalent library.

                      One example until recently was a MongoDB driver (this is, itself, probably worth scrutiny in the first place), also libraries for working with PDFs. Some tooling for AWS Kinesis is kludgy on their go-sdk or just missing features.

                      For the vast majority of what you need to do we haven’t had too much we needed to roll custom compared to java though.

                    2. 2

                      Completely agree. I include this right in the interview screen and job descriptions. Doing so has helped both our organization and the prospective applicants, because some people want to work on the bleeding edge. They’re not going to be thrilled working in our team, where we try to stick with “boring” tech choices.

                    1. 11

                      I too was once an awesomewm user (on Arch Linux) for a while, but I stopped around 7 years ago because even after investing tens to hundreds of hours in setting up my fully featured environment, it wasn’t stable. It was hard to keep the system up to date and working.

                      These days on macOS I can simulate my awesomewm days with Chunkwm and ubersicht and on top of that WiFi works, sleep works, my battery life is great! I can still work with a non broken package manager because of the nix package system and it’s reproducible. Having said that, of course I wish I were using Linux (these days I’d go for Nixos), but I value not having to deal with the sysadmin stuff unexpectedly.

                      1. 3

                        Similarly, but not quite, I use a windows PC I built at home with vmware which manages an ubuntu install with i3. You get (some) of the benefits of a real development environment (and the operational stability of windows) and i3 for tiling, but the downsides are some mystery key combinations get captured by windows and it never really feels fully operational.

                        Plus side is you can just create a new vm when things break or you want to try out something else like elementary or arch.

                        1. 1

                          I was just thinking about this in the morning and I realized that my troubleshooting incident rate isn’t really higher on Linux than it is on Windows or OS X. What I actually want to say is: it is always implied that on Linux something will break and you’ll spend a good chunk of time fixing it, but I have the same issues on Windows and OS X at more or less the same frequency and the time spend on it.

                        1. 1

                          Go has pretty good built in facilities for documentation, we just point godoc.org at our repos.

                          1. 39

                            We need a name for this pattern around network protocols: “Embrace, Capture, Break away, Lock-in”

                            • Embrace a communication standard
                            • Capture: attract a large user base
                            • Break away: break backward compatibility and/or provide a worse UX for those outside of your walled garden
                            • Lock-in: corner in the userbase

                            Google did this with Google Talk vs XMMP, email (try running your own mailserver), AMP, RSS…

                            1. 14

                              Email is still mostly unmolested if you understand the security and spam context; it’s not that google made it impossible to run your own smtp server, but in order to do so and not get flagged as spam, there are a lot of hoops to jump through. IMHO this is a net benefit, you still have small email providers competing against gmail, but much less spam.

                              1. 15

                                Email is mostly unmolested because it’s decentralized and federated, and a huge amount of communication crosses between the major players in the space. If Google decided they wanted to take their ball and go home, they would be cutting of all of Gmail, Yahoo mail, all corporate mail servers, and many other small domains.

                                If we want to make other protocols behave similarly, we need to make sure that federation isn’t just an option, but a feature that’s seamless and actively used, and we need a diverse ecosystem around the protocols.

                                To foster a diverse ecosystem, we need protocols that are simple and easy to implement, so that anyone can sit down for a week in front of a computer and produce a compatible version of the protocol from first-enough principles, and build a cooperating tool, to diffuse the power of big players.

                                1. 9

                                  So how do you not get flagged for spam? I want to join you. I run my own e-mail server and have documented the spam issue here:

                                  https://penguindreams.org/blog/how-google-and-microsoft-made-email-unreliable/

                                  The only way to combat Google and Microsoft’s spam filters is sending my e-mail, texting my friend say, “Hey I sent you an e-mail. Make sure it’s not in your spam folder.” Usually if they reply, my e-mail will now get through .. usually. Sometimes it gets dropped again.

                                  I have DKIM, DMARC and SPF all set up correctly. Fuck Gmail and fuck outlook and fuck all the god damn spammers that are making it more difficult for e-mail to just fucking work.

                                  1. 3

                                    Forgive the basic question: do you have an rDNS entry set for your IP address so a forward-confirmed reverse DNS test passes? I don’t see that mentioned by you in your blog post, though it is mentioned in a quote not specifically referring to your system.

                                    It’s not clear who your hosting provider (ISP) is, though the question you asked them about subnet-level blocking is one you could answer yourself via third-party blacklist provider (SpamCop, Spamhaus, or many others of varying quality) and as a consequence work with them on demonstrable (empirical) sender reputation issues.

                                    1. 8

                                      Yes I’ve been asked that before and haven’t updated the blog post in a while. I do have reverse DNS records for the single IPv4 and 2 IPv6 addresses attached to the mail server. I didn’t originally, although I don’t think it’s made that big a difference.

                                      I’ve also moved to Vultr, which blocks port 25 by default and requires customers explicitly request to get it unblocked; so hopefully that will avoid the noisy subnet problem so often seen on places like my previous host, Linode.

                                      I think a big factor is mail volume. Google and Microsoft seem to trust servers that produce large volumes of HAM and I know people at MailChimp that tell me how they gradually spin up newer IP blocks by slowly adding traffic to them. My volume is very small. My mastodon instance and confluence install occasionally send out notifications, but for the most part my output volume is pretty small.

                                      1. 8

                                        Email is inherently hard, especially spam filtering; Google and Microsoft just happen to be the largest email providers, so it appears to be a Google or Microsoft problem, but I don’t think it is.

                                        E-mail was once the pillar of the Internet as a truly distributed, standards-based and non-centralized means to communication with people across the planet.

                                        I think you’re looking through rose-tinted glasses a bit. Back in the day email was also commonly used to send out spam from hijacked computers, which is why many ISPs now block outgoing port 25, and many email servers disallow emails from residential IPs. Clearly that was suboptimal, too.

                                        Distributed and non-centralized systems are an exercise in trade-offs; you can’t just accept anything from anyone, because the assholes will abuse it.

                                        1. 4

                                          Cheap hosting is very hard to run a mailserver from because the IP you get is almost certainly tainted.

                                          Having valid rDNS, SPF & DMARC records helps.

                                    2. 13

                                      It’s also not really a Google issue; many non-Google servers are similarly strict these days, for good reasons. It’s just that Google/Gmail is now the largest provider so people blame them for not accepting their badly configured email server and/or widely invalid emails.

                                      I’ve worked a lot with email in the last few years, and I genuinely and deeply believe that at least half of the people working on email software should be legally forbidden from ever programming anything related to email whatsoever.

                                      1. 2

                                        In other words, Google didn’t have to break email because email has been fundamentally broken since before they launched GMail.

                                        Worse, newer protocols like Matrix and the various relatives of ActivityPub and OStatus don’t fix this problem.

                                        1. 7

                                          Matrix, ActivityPub and OStatus don’t fix Email? Well it’s almost as if they are trying to solve other problems than internet mail.

                                          1. 3

                                            You completely and utterly missed the point.

                                            Mastodon, Synapse, and GNU Social all implement a mixture of blacklists, CAPTCHAs, and heuristics to lock out spambots and shitposters. The more popular they get, the more complex their anti-spam measures will have to get. Even though they’re not identical to internet mail (obviously), they still have the same problem with spambots.

                                            1. 11

                                              Those problems are at least partly self-inflicted. There’s nothing about ActivityPub which requires you to rehost all the public content that shows up. You can host your own local public content, and you can send it to other instances so that their users can see it.

                                              Rehosting publicly gives spammers a very good way to see and measure their reach. They can tell exactly when they’ve been blocked and switch servers. Plus all the legal issues with hosting banned content, etc.

                                              1. 3

                                                You’re acting as if that ONE problem (abusive use) is THE only problem and the rule and guide with which we should judge protocols.

                                                While a perfectly reasonable technocratic worldview, I think things like usability are also important :)

                                                1. 9

                                                  In general, you’re right. A well-designed system needs to balance a lot of trade-offs. If we were having a different conversation, I’d be talking about usability, or performance, or having a well-chosen set of features that interact with each other well.

                                                  But this subthread is about email, and abusive use is the problem that either causes or exacerbates almost every other problem in email. The reason why deploying an email server is such a pain is anti-spam gatekeeping. The reason why email gets delayed and silently swallowed is anti-spam filtering. The reason why email systems are so complicated is that they have to be able to detect spam. Anti-backscatter measures are the reason why email servers are required to synchronously validate the existence of a mailbox for all incoming mail, and this means the sending SMTP server needs to hold open a connection to the recipient while it sifts through its database. The reason ISPs and routers block port 25 by default is an attempt to reduce spam. More than half of all SMTP traffic is spam.

                                                  If having lots of little servers is your goal, and you don’t want your new federated protocol to have control under a small number of giant servers, then you do need to solve this problem. Replicate email’s federation method, get emails emergent federation behavior.

                                          2. 5

                                            XMMP has a lot of legitimate issues. Try setting up a XMMP video chat between a Linux and macOS client. I’d rather lose my left arm than try doing that again.

                                            1. 7

                                              Desktop Jingle clients never really matured because it wasn’t a popular enough feature to get attention.

                                              These days I expect everyone just uses https://meet.jit.si because it works even with non-XMPP users and no client

                                              1. 0

                                                I just got jitsi working w/ docker-compose meet.dougandkathy.com – not headache free, but no way I could build it myself

                                              2. 1

                                                Audio, video and file transfer is still very unreliable on most IM platforms. Every time I want to make audio or video call with someone we had to try multiple applications/services and use the first one that works.

                                                1. 0

                                                  Microsoft Teams does this pretty well, across many platforms. Linux support is (obviously, I guess) still a bit hacky, but apparently is possible to get to work as well.

                                              1. 7
                                                awk 'BEGIN{
                                                    for(i=ARGV[1];i>0;--i)
                                                        {printf "\r%3d",i;system("sleep 1")}
                                                    printf "\r%3d\n",i}
                                                ' 25
                                                
                                                1. 1

                                                  AWK just needs a function to print awkward and unusably large text.

                                                  1. 4

                                                    On a UNIX with an SVR4-like banner you can just run that from awk! You could also use figlet if you have that on hand.

                                                1. 2

                                                  Couple suggestions:

                                                  • Have an interface the logger implements that allow it to be used in other packages; generally we try to keep external dependencies minimal, and having the logger expose a basic interface lets us model that interface so we can accept other loggers in our packages. Example would be the logger type would have Printf and Errorf, then we can require our package loggers have those functions too, then we can swap in and out loggers easily.
                                                  • Not a requirement, but this wouldn’t pass golint
                                                  • Use of the init() function for packages is generally unnecessary and if you can work around it you should.

                                                  If you want to see where we ended up with our logger: https://github.com/blend/go-sdk/tree/master/logger

                                                  A couple key considerations there; log messages are “events” that are strongly typed, and get sent through an event bus so you can attach listeners to them; this is useful for collecting errors and writing request stats etc. by hooking into existing logging.

                                                  1. 2

                                                    I keep a photoblog (https://charczuk.com), and use a static site generator I wrote for it (https://github.com/wcharczuk/blogctl), source for the blog is here (https://github.com/wcharczuk/charczuk.com).

                                                    One key thing, deploying to S3 and fronting with CloudFront lets you use free certs managed by AWS.

                                                    1. 2

                                                      npm is a company dedicated to making the management of JavaScript dependencies predictable and effortless, and they expect other ecosystems to have similar world-class dependency management tooling available.

                                                      Yeesh. And they picked rust? Sorry, rust, but having observed what happens when people use npm, I’m staying as far away from cargo as possible. I can’t handle that level of predictability. :)

                                                      1. 11

                                                        I’m still waiting for npm to burn through their Series A and take the Node community with them.

                                                        1. 4

                                                          Their series A was in 2015, so it’s safe to say they haven’t “burned through” anything by VC standards, whether or not they eventually succeed.

                                                          1. 6

                                                            The ultimate left-pad.

                                                          2. 4

                                                            I’m also curious what aspects of go mod (i.e. recent dependency management changes in go) they found unappealing.

                                                            1. 7

                                                              The project described predates go mod, hence the “at the time they performed this evaluation”. The Rust services at NPM are actually into production for quite some time now.

                                                              (I admit that could be made clearer, I was not involved in writing the paper)

                                                            2. 2

                                                              Could you please elaborate? Like, how could it be better, what they’re doing etc. Because I really really don’t understanding (and I’m willing to) all this hate towards npm.

                                                              1. 6

                                                                Seems like only yesterday we were discussing how worldwide productivity ground to a halt because somebody pushed a bad package to npm and nobody was capable of simply going back to a previous working version.

                                                                https://lobste.rs/s/ztev4w/misconception_about_oss_support

                                                                I mean, I suppose it’s possible for some other package manager or some other ecosystem to have problems too, but literally every story about left pad or backdoored packages stealing crypt wallets or whatever always involves npm front and center.

                                                                1. 3

                                                                  I see what you mean, and yes the NPM ecosystem has problems. I don’t think they’re related to the desired features of NPM itself, though, but rather the anemic state of the Javascript standard lib, particularly in ES2015, which creates the desire to publish and use lots of packages for doing common things of trivial complexity that are included in the StdLib of most languages. For whatever faults Rust and Cargo have, they seem to have avoided the issue of having tons of tiny crates/libs, creating huge dependency chains in most significant crates/libs, due to lack of common simple methods in the StdLib.

                                                                  I think that this instead calls out how much better the basics of dependency management are in these languages compared to almost all other common languages. How many other compiled languages have a standard dependency management system that supports having a lockfile that ensures that all builds of the application are using the same library code, no matter who or where they are built?

                                                                  1. 1

                                                                    There are complications because javascript is minimal, but there are major problems with tooling and how npm administers the repo that have nothing to do with that.

                                                                    How many other compiled languages have a standard dependency management system that supports having a lockfile that ensures that all builds of the application are using the same library code, no matter who or where they are built?

                                                                    Are you talking about npm? Because npm doesn’t do that.

                                                                    1. 2

                                                                      There may be problems with how NPM administers things, but it sounds like we’re talking about whether Cargo is good or bad. Do you know of Cargo sharing some of the same issues from an organizational/policy perspective that NPM has?

                                                                      Are you talking about npm? Because npm doesn’t do that.

                                                                      Well I was talking about compiled languages specifically, but AFAICT NPM does do that

                                                                      1. 1

                                                                        Perhaps I am wrong, but I took @tedu’s comment as a bit tongue-in-cheek. Cargo being better designed than npm, but npm potentially infecting cargo. Maybe that’s how I wanted to read it—I have no allegiance to either community, though.

                                                            1. 4

                                                              The bit about how it’s hard to tell what will close a Reader/WriterCloser underneath you is super valid. I’m not sure how you’d manage that without some kind of “reference count” or similar (i.e. only actually close until the count hits zero).

                                                              Another awkward use case is how to write http middleware that hash-sums a post body (i.e. for slack webhook validation) and then also lets inner actions read from the request post body.

                                                              1. 6

                                                                It’s simple. If you pass a *Closer to something, you should assume that something is going to close it. Otherwise you’d just pass it a Reader or a Writer.

                                                                1. 2

                                                                  Not everyone gets the memo that this is the way it’s supposed to work. Very often, folks will create large interfaces and pass them around, with no intent on using everything defined.

                                                                  1. 2

                                                                    Sure, but at a certain point, what can you do about people ignoring the docs and even the sort of high level guidance of the language? I mean, deep reading docs is hard, reading the go proverbs isn’t https://go-proverbs.github.io/ – and you only have to get to the 4th one to get to “The bigger the interface, the weaker the abstraction.”

                                                                    1. 5

                                                                      “The bigger the interface, the weaker the abstraction.” says very little to someone not engaged in deeply understanding it.

                                                                      Obviously, we can’t throw our hands up and say, “what can you do? People will be people!!!” What we can do is ensure that code we write and review takes these principles to heart, and shows the value of it.

                                                                      1. 2

                                                                        Absolutely, and after doing all that – people are still going to write terrible code that directly goes against all the norms and recommendations. I am all for doing our level best to try to guide people – but leading a horse to water and all that.

                                                                  2. 1

                                                                    I think this is true, but it basically means you should never pass a *Closer unless you really really have to. The callee should manage the IO lifecycle.

                                                                    I would even go so far as to say one of the heavily opinionated Go linters should warn (maybe they do, I have never checked because I don’t think highly opinionated linters are a good idea for anything but beginners).

                                                                    1. 1

                                                                      This makes sense, but two difficulties.

                                                                      1. Still requires careful analysis of docs. It’s very easy to pass a closereader off to a function taking a reader.

                                                                      2. You can’t just pass something like a gzip.reader to another layer. Even if that layer closes, it doesn’t close the bottom.

                                                                      1. 1

                                                                        When I read stuff like this I change my mind about go being a language that can be learned in a weekend.

                                                                        1. 1

                                                                          You can certainly pick it up and use it effectively in a weekend, but surely you couldn’t learn the ins and outs of anything substantial in just a weekend.

                                                                      2. 4

                                                                        Between io.TeeReader and io.Pipe I think you can probably wire something up. There’s a decent amount of “plumbing” included, although it took me a few passes through the docs to find it all.

                                                                        1. 4

                                                                          Yeah, its quite worth it to read through the whole std library docs, I seem to find a new thing each time I skim it again.

                                                                        2. 1

                                                                          how to write http middleware that hash-sums a post body (i.e. for slack webhook validation) and then also lets inner actions read from the request post body.

                                                                          I’ve had to do something like that and I ended up writing a small TeeReadCloser struct that wraps TeeReader but also has a Close method that closes both the reader and the writer. You can probably get by with a version that takes a WriteCloser like mine and one that just takes a Writer and combine them as needed, though I wonder why they couldn’t just put these in the standard library.

                                                                        1. 9

                                                                          In the age of languages like Elm and Go, which jeopardize sophistication to appeal to the newcomers,

                                                                          I have a bone to pick with this. Go isn’t approachable because it wants to be popular, it’s approachable (a.k.a. simple) because that’s what the designers wanted out of a language they themselves would have to use. The simplicity is a feature. It is also very sophisticated, just a lot of that sophistication is hidden under a single keyword like go.

                                                                          1. 10

                                                                            The author of the post Notes on structured concurrency, or: Go statement considered harmful argues that the go keyword in golang enables a kind of spaghetti code similar to the goto famously critiqued by Dijkstra in the 60s. I work full time with golang, and in practice folks are conservative with their use of the go keyword, but I tend to agree with Nathaniel about its potential for abuse. The go keyword makes concurrency easy but it doesn’t make it simple. I take the stance that the go keyword is not a mark of sophistication in the golang language.

                                                                            [Edit: I realize this is off topic.]

                                                                            [Edit again: A more on-topic response follows.]

                                                                            In the age of languages like Elm and Go, which jeopardize sophistication to appeal to the newcomers,

                                                                            Thinking about it some more, this is kind of a cheap-shot.

                                                                            Golang’s sophistication is in its efficient GC, multiple profiling tools, ability to profile at runtime, speedy runtime, fast compile times, and its ease-of-use. @bigdubs has a point. The language was designed to improve development practices at a large company and allocated its sophistication budget to support features which address that goal.

                                                                            Elm’s sophistication isn’t reduced by its ultimate farewell to FRP. FRP itself has become a nexus of difficult to differentiate ideas. Having met Evan Czaplicki a couple times and discussed his goals with Elm, it’s clear to me that his desire to help people learn Elm outweighed his desire to make it fit the FRP label. That isn’t a rejection of sophistication.

                                                                            As somebody who spends most of their free time in Haskell, I’m familiar with the “sophistication” that doesn’t “appeal to the newcomers”, in @steinuil’s words. It’s a sophistication that sometimes bites me after working with Haskell for several years, and I still question its value while continuing to do new projects with Haskell. This cusp between complex and difficult but sophisticated tools and seemingly simple or easy tools which belie their own sophistication is a difficult point and I don’t think either side of the argument has a winning set of ideas.

                                                                            That said, thanks @steinuil for introducing me to Ur/Web. I’d never heard of it. It sounds a bit like yesod, servant, dart, and reform (digestive functors) all rolled into one. I’m looking forward to your next post.

                                                                            1. 4

                                                                              I admit it was a cheap shot, I probably wouldn’t word it like this today. I did have a lot of problems handling and scaling some medium-sized Elm applications though; nothing in the documentation suggested how to structure big applications in a nice way and even though I can think of some ways to do that now it still involves a lot of boilerplate.

                                                                              My animosity towards Go might’ve been more of a knee-jerk reaction; I know it has a lot merits in its tooling but I still disagree with many of the tradeoffs it makes in its design. But I’m sure I’ll have nicer things to say about it if I ever use it for something bigger.

                                                                              1. 1

                                                                                Golang’s sophistication is in its efficient GC, multiple profiling tools, ability to profile at runtime, speedy runtime, fast compile times, and its ease-of-use.

                                                                                Only one of those things you listed could possibly apply to the language; the rest are properties of the runtime/ecosystem. I’m not sure if that was the point you were trying to make, but it seems to indicate that the Go language is rather simplistic.

                                                                                1. 2

                                                                                  Ah, not exactly. I was attempting to make the point that there’s sophistication in “golang” without distinguishing between the “golang language/syntax/semantics” and the “golang runtime”.

                                                                                  Are there other languages which run natively against the golang runtime and are able to leverage its benefits? If not, then for the time being it seems reasonable to regard the benefits (or sophistication) of the runtime as benefits of the language. Those benefits are obtained based on the choice of whether to use the language or not, since you can’t get the runtime without the language at current.


                                                                                  Reading a bit about golang’s runtime it seems like a poor name, to be honest. It’s a library runtime. There’s no VM. If you wanted to leverage the benefits of the runtime I suppose you could link against it from another surface-level compiler, but the API is likely unstable. It’s probably easier to write a language which compiles to golang. I still think it’s fine to regard the two as one artifact.

                                                                                  1. 4

                                                                                    I still think it’s fine to regard the two as one artifact.

                                                                                    I guess I feel it’s helpful to consider them separately because it’s clear to me that the golang creators are not very good at language design and have made a significant number of obvious mistakes on that front, pretending that the state of the art in programming language design hasn’t moved forwards since the 1970s, but at the same time they actually seem to do a decent job at tooling, compiler implementation, and non-language-level ergonomics.

                                                                                    1. 1

                                                                                      Is the go runtime any different than the ada runtime in this regard?

                                                                                    2. 2

                                                                                      The language was kept simplistic to enable building the runtime features, so it’s relevant if bot precisely correct.

                                                                                1. 4

                                                                                  The only thing we do differently is we have controllers (i.e. server types) for each functional area vs. a single server instance.

                                                                                  You can also chain middleware https://github.com/blend/go-sdk/blob/master/web/util.go#L24 vs. wrapping the functions (makes it easier to have a standard array of middleware that you pass around).

                                                                                  1. 1

                                                                                    Thank you for the example! It’s useful as I embark on my first http service in golang.

                                                                                  1. 19

                                                                                    Hi Kev. Welcome to Lobsters!

                                                                                    Your complaints about those mean old trolls are well founded enough, but I think they are not so much about “the Linux community” (whatever that might be) and more about Reddit. With that in mind, please take some time to acculturate. This place is very specifically not Reddit, nor HN.

                                                                                    1. 4

                                                                                      That was my read as well, and also my own experience with reddit (and /r/programming even, which is supposed to be one of the better subreddits).

                                                                                      Not sure what to conclude other than once a community gets a certain size, and once the long tail that ends up being very loud and caustic grows enough to be problematic do you start to see these kinds of things.

                                                                                      1. 2

                                                                                        I’d like to think it’s not all communities, but I’m yet to see evidence of a larger community that doesn’t conform to this pattern unfortunately.

                                                                                        1. 6

                                                                                          I think /r/rust shows that it’s possible to have a tech focussed community on Reddit without all the vitriol.

                                                                                          1. 3

                                                                                            It is, but there’s still a low background hum of snarky and mean comments, in spite of the overall excellent tone. Some very valued members of the community avoid Reddit in favor of other places, like the Discourse instance. I think it’s fair to say that /r/rust is the exception that proves the rule, and will be effectively shuttering /r/xi_editor (not that it was ever very active).

                                                                                            1. 2

                                                                                              /r/ProgrammingLanguages/ is also a pretty good one. But it has to be set up like that from the start, with strong moderation. It always depresses me when anything gender equality related takes a quick dive to the bottom on /r/programming/… :(

                                                                                        2. 3

                                                                                          Subreddits have their own culture. Some are the worst, some the best. It all boils down to how the communities are managed.

                                                                                          1. 2

                                                                                            You’re absolutely right, I could have been more specific as my issue is/was with Reddit, not the Linux “community”. I’ve edited the title with that in mind.

                                                                                            1. 4

                                                                                              It occurs outside Reddit [1], Reddit is just one of the worst exponents of it. There is a subset of the Linux community who feel like they on a crusade against Microsoft, Apple, proprietary software, or whatever. I think Linux is attractive to some of these groups because of strong some ideological tendencies in Linux (GNU, ‘the true UNIX philosophy’, etc.). There is nothing wrong with these ideologies — most people are emphatic towards others and understand that Unix is not practical for everyone, nor that running a fully free system is not practical for everyone. But once you take away the empathy, you get pointless ideological and/or turf wars.

                                                                                              It is not productive to engage in these discussions. What is a point of a discussion where no one wants to be convinced or is interested in the other person’s perspective?

                                                                                              [1] I have been yelled at on some Linux forums because I also use a Mac, by people who never contributed a single line of code or documentation to a FLOSS project.

                                                                                            2. 1

                                                                                              @minimax wrote

                                                                                              but I think they are not so much about “the Linux community” and more about Reddit.

                                                                                              @kev wrote

                                                                                              As far as I’m concerned, these people are not part of the Linux community and they’re not wanted. If you feel it is appropriate to belittle someone, or tell someone to “go kill themselves” for their choice of software, operating system, or their opinions, do us all a favour and f**k off.

                                                                                              1. 1

                                                                                                When you quoted me there, you left out the point I was trying to make. To clarify, I do not believe there is such a thing as “the Linux community”, any more than there is a “community” of Toyota drivers or people with colorful tatoos. Sure, the Linux kernel developers are a community of sorts: they have to work together. Distro maintainers have communities; maybe even the user base could be included, for some smaller and quirkier distros. But mere consumer choice does not grant anyone community membership status, under any sane definition of the word.

                                                                                                Another thing: if you wander into any collection of people and start mocking their shared values, you can reasonably expect some hostility. Some will express it in a professional and mature fashion, others not so much. This age-old fact tells you nothing about Linux, Reddit, or even the Internet.

                                                                                            1. 2

                                                                                              Obviously this is a datapoint of one, but we are not switching to Vue from React.

                                                                                              Angular 1’s deprecation created a lot of opportunity for companies to refactor, React it seems had a lot of inbound interest as a result.

                                                                                              I don’t see this repeating with Vue unless React is deprecated (and shoots itself in the face like Angular 1)

                                                                                              1. 1

                                                                                                FWIW the reason we started using Vue is because it is easy enough to start using Vue here and there while other parts of the website remain more “antiquated”. React is a lot harder to gradually integrate.

                                                                                              1. 3

                                                                                                The 2018 Macbook Pro with 32gb of ram and 6 cores.

                                                                                                It’s awesome, except the touch bar is a poor UX and a “force touch” like detection of erroneous touches away from being great.

                                                                                                1. 10

                                                                                                  Kubernetes has the ability to run jobs on a cron schedule, and you can launch one off run to completion pods as tasks.

                                                                                                  1. 2

                                                                                                    This is what we do too.

                                                                                                  1. 12

                                                                                                    I built a company on a .net stack a long time ago; it was fine. The biggest problem is SQL Server used to cost a lot of money and was kind of a waste in the face of postgres. As far as the programming ecosystem; C# as a language is great, but so much of the standard library and 3rd party libraries are old and crusty. Some were legitimately great though, like Dapper for talking to the DB, and ASP.net MVC was a decent web framework.

                                                                                                    1. 8

                                                                                                      Yup. Licensing cost is the elephant in the room here. SQL Server, Windows Server itself, IIS, it all adds up pretty quick, and if you’re running a startup, paying for such licenses at scale is maybe not so attractive.

                                                                                                      1. 10

                                                                                                        Exactly. Its unclear why you’d pay for SQLServer and IIS when postgresql and apache or nginix cost nothing to license. Many people would argue that the latter are superior anyway. There are plenty of companies that will provide paid support for those products too.

                                                                                                    1. 1

                                                                                                      WASD 87 key with Cherry MX Blues. Not really ideal in an office environment but most people use headphones and it hasn’t been too bothersome to my neighbors afaik.

                                                                                                      1. 3

                                                                                                        The nodes gossip periodically to ensure the leader is still there. If the leader ever dies, a new leader will be elected through a simple protocol that uses random sleeps and leader declarations. While this is simple and unsophisticated, it is easy to reason about and understand, and it works effectively at scale.

                                                                                                        The sound of three Byzantine generals cackling in the distance was heard right before the point of sale systems mysteriously crashed.

                                                                                                        1. 1

                                                                                                          It reads like a trimmed down version of how Raft elections work less the log shipping.

                                                                                                          1. 1

                                                                                                            Kubernetes uses etcd that implements raft IIRC