
Go 1.14 release notes - mapl
https://tip.golang.org/doc/go1.14
======
Scaevolus
Maybe link the changelog instead?
[https://tip.golang.org/doc/go1.14](https://tip.golang.org/doc/go1.14)

Selected changes:

\- This release improves the performance of most uses of defer to incur almost
zero overhead compared to calling the deferred function directly. As a result,
defer can now be used in performance-critical code without overhead concerns.

\- Goroutines are now asynchronously preemptible. As a result, loops without
function calls no longer potentially deadlock the scheduler or significantly
delay garbage collection.

\- Per the overlapping interfaces proposal, Go 1.14 now permits embedding of
interfaces with overlapping method sets: methods from an embedded interface
may have the same names and identical signatures as methods already present in
the (embedding) interface. This solves problems that typically (but not
exclusively) occur with diamond-shaped embedding graphs. Explicitly declared
methods in an interface must remain unique, as before.

~~~
jhoechtl
> Goroutines are now asynchronously preemptible. As a result, loops without
> function calls no longer potentially deadlock the scheduler or significantly
> delay garbage collection.

What does that mean in practice? Can I perform expensive calculations in
parallel exhausting all cores?

~~~
diegobernardes
This means that the threads can't be blocked forever. The way Go scheduler
work is to check during function calls if the current goroutine has executed
for some period of time, after that the scheduler will remove the goroutine
from the thread and open space for other goroutines to execute. But if you're
doing a loop without function calls, imagine a for {}, in this case, the
thread will be locked forever. Now with 1.14, this don't happen anymore. In my
opinion the expected result will be better tail latencies.

------
_ph_
Thanks to the Go team for the great work!

The more I use it, the more I enjoy Go. Having grown up with the healthy dose
of Pascal and later Modula 2, I appreciate many traits of Go which let me just
focus on the tasks at hand. With very little "magic" going on, some parts of
the code might be a bit tedious, but you also always have the feeling of being
in control, as everything is very explicit. Add to that a few underapreciated
dynamic features. I am first of all a professional Lisp/Scheme programmer and
a lot of Scheme concepts translate surprisingly well into Go due to having
first class functions and a garbage collector.

It is very nice to see how the Go releases are very careful to add new
features while continuosly improve on the "quality" side. Enhancing the
performance of "defer" is a great example. Like unwind-protect in Lisp, it is
a very elegant way to ensure that cleanup code is run under any circumstance.
Removing its overhead is a big thing.

------
teeray
Buried in the notes is a small, but useful addition to the testing package
that allows your test helpers to register their own cleanup functions
(testing.(*T).Cleanup). I wrote a blog post discussing it in depth here:
[https://www.gopherguides.com/articles/test-cleanup-in-
go-1-1...](https://www.gopherguides.com/articles/test-cleanup-in-go-1-14/)

~~~
mleonard
Hey. Interesting blog post! Quick bit of feedback for you... I find the code
snippets quite hard to read on mobile as the lines wrap. Could you enable
horizontal overflow scrolling do you think? overflow-x:scroll

------
kstenerud
Go with warning flag patch also upgraded to 1.14:
[https://github.com/kstenerud/go#the-go-programming-
language](https://github.com/kstenerud/go#the-go-programming-language)

The warning flag patch allows you to do:

    
    
        go build -gcflags=-warnunused
        go test -gcflags=-warnunused
    

which causes the compiler to only warn about unused things instead of stopping
the build:

    
    
        $ go test -gcflags=-warnunused
        # github.com/kstenerud/go-describe
        ./describe_unsafe.go:8:2: Warning: imported and not used: "fmt"
        ./describe.go:329:2: Warning: isInUnsignedArray declared but not used
    
        ...
    
        PASS
        ok   github.com/kstenerud/go-describe 0.002s
    

I use this when debugging or for exploratory coding.

------
sethammons
> When the main module contains a top-level vendor directory and its go.mod
> file specifies go 1.14 or higher, the go command now defaults to -mod=vendor
> for operations that accept that flag.

Thank you! Modules and vendoring has been a royal pain. This should help a
lot.

------
LogicX
Anyone run any real-world performance comparisons on what this defer change
did to the performance of their application?

~~~
kristianp
There was the tweet referred to in the sibling, from Mr "Chiney":

[https://twitter.com/davecheney/status/1232206326895280128](https://twitter.com/davecheney/status/1232206326895280128)

------
jpdb
Wish the json.Register funcion had been in 1.14. Desperately need it for a
project I'm working on. If anyone has any ideas for overriding structs in a
pkg I'd love to hear them!

~~~
mappu
For others following along - this is
[https://github.com/golang/go/issues/5901](https://github.com/golang/go/issues/5901)
to register custom marshallers on an existing `json.Encoder` instance.

I feel like it's generally possible to work around this by creating a wrapper
struct with an overridden MarshalJSON method? But maybe that's infeasible for
deeply nested structs.

~~~
jpdb
> But maybe that's infeasible for deeply nested structs.

That's the crux of my issue. If it was only for a single, un-nested field then
it would be trivial.

I am currently solving it by walking through the whole struct, but that is
not-ideal.

------
mfer
It just struck me that the Go team does not provide PGP or other cryptographic
signing/verification of releases.

~~~
shawabawa3
What assurances does that give you beyond the https certificate on their
official website which contains the binary downloads and hashes?

~~~
Groxx
Defense in depth, essentially. But yes, checking site X to see if site X gave
you Y correctly is rather weak confidence.

To argue in its favor tho, file-hosting and site-serving may be handled by
different systems with different security characteristics, and potentially
even different datacenters (e.g. a CDN). If you only have to compromise one
system, it's generally easier to do so than when you have to compromise N and
make them all agree with each other.

~~~
Thaxll
The hash and file are not hosted on the same place so it's good enough.

------
eberkund
>Go 1.14 is the last release that will run on macOS 10.11 El Capitan. Go 1.15
will require macOS 10.12 Sierra or later.

That's pretty aggressive. Dropping support for a major OS that is only 1 year
old.

~~~
eberkund
Whoops, my mistake

~~~
AnimalMuppet
Time flies when you're having fun ;-)

