Thank you for raising this issue. Before we can investigate could you please update your sample code to check all errors and verify that the issues is still present.

I updated the sample code with error checks and better output. The problem still occurs.

0001 ad is not within the range that time.Time supports, please try https://play.golang.org/p/7JicBQHKeeq

Please point me to the documentation that states what is the minimum supported value.

According to the documentation for time.Parse: The year value must be between 0000 and 9999. And non specified values are interpreted as 0 values.

So for this example using time.Kitchen format:
https://play.golang.org/p/M55U4VgvuNI
You can still end up with an invalid time:

Kitchen UTC: 0000-01-01 12:00:00 +0000 UTC
Kitchen Eastern: 0000-01-01 07:03:58 -0456 LMT

The cut off between invalid and valid times seems to be at: 1883-11-18T16:59:59Z
https://play.golang.org/p/Fe44XV7yIMs

Thank you for correcting me. I agree that parse suggests it accepts a 10000 year range. The closest I can find to the range of values that parse can return comes from https://golang.org/pkg/time/#Time.UnixNano. I cannot seem to find any documentation other than this.

I’m having trouble understanding your original question. This is my fault, I’m just not understanding what you are saying. Is it possible for you to restate your problem in the form of a goal “I need to x, do to x I tried to y”?

Sure. No problem.

I have 2 use cases:

1. I need to convert a UTC timestamp from a database to Local time and encode the value using gob. I tried using utcValue.In(localLocation)
2. I need to localize a UTC time in the Kitchen format and encode the value using gob. I tried utcValue.In(localLocation)

For both cases local timezone is US/Eastern

If I'm reading this right, the basic problem is that MarshalBinary is failing when it shouldn't. Here is a simpler example that doesn't rely on the zero time.

https://play.golang.org/p/JcLg4diDncx

package main

import (
	"fmt"
	"time"
)

func main() {
	t, err := time.Parse(time.RFC3339, "1880-01-01T00:00:00Z")
	if err != nil {
		fmt.Println("Failed to parse time", err)
	}
	loc, err := time.LoadLocation("US/Eastern")
	if err != nil {
		fmt.Println("Failed to load location", err)
	}
	t2 := t.In(loc)
	fmt.Println("Zero Eastern:", t2)
	b, err := t2.MarshalBinary()
	if err != nil {
		fmt.Println("Failed to marshal", err)
	} else {
		fmt.Println("Got bytes", b)
	}
}

Yes, the main crux is MarshalBinary doesn't support local mean time at the moment.

Some Info:

Part of the problem is with changing the time zone for values before time zones existed.
If you look at the output of t2 you will see the minutes and seconds are no longer 0 and the timezone becomes some fractional local mean time.

Which looks to be based on when US railways adopted time zones: https://en.wikipedia.org/wiki/Time_zone#cite_ref-8

(Adding the above to the documentation for In would help reduce confusion especially for people not versed in US railway history 😄 )

I guess the question of: Should we maintain historic accuracy or expected behavior?
If the user asks for US/Eastern then returning LMT is confusing without any error.

We return LMT because that is what the timezone database tells us to do.

Makes sense - that's what I expected is the case.

So should I implement LMT in MarshalBinary to solve this problem?

That would fix my use case.

I am currently working on this issue. As what I asked, I was refactoring MarshalBinary() to support LMT.
However, I met a problem that LMT may have fractional minute. To support the current binary format of the output of MarshalBinary() the fractional minute part would be ignored. Or should we modify the format of the output of MarshalBinary() and add two more bytes to support LMT?
@ianlancetaylor any suggestion?

I would be OK with using timeBinaryVerison 2 to represent timezone seconds when required. We should still use version in the normal case.
Thanks.

Change https://golang.org/cl/243402 mentions this issue: src/time: Support LMT in MarshalBinary, UnmarshalBinary