What you are asking (to store 18,446,744,073,709,551,615 as an int64 value) is impossible.

A unit64 stores positive integers and has 64 bits available to hold information. It can therefore store any positive integer between 0 and 18,446,744,073,709,551,615 (2^64-1).

An int64 uses one bit to hold the sign, leaving 63 bits to hold information about the number. It can store any value between -9,223,372,036,854,775,808 and +9,223,372,036,854,775,807 (-2^63 and 2^63-1).

Both types can hold 18,446,744,073,709,551,616 unique integers, it is just that the uint64 range starts at zero, where as the int64 values straddle zero.

To hold 18,446,744,073,709,551,615 as a signed integer would require 65 bits.

In your conversion, no information from the underlying bytes is lost. The difference in the integer values returned is due to how the the two types interpret and display the values.

uint64 will display a raw integer value, whereas int64 will use two's complement.

var x uint64 = 18446744073709551615
var y int64 = int64(x)

fmt.Printf("uint64: %v = %#[1]x, int64: %v = %#x\n", x, y, uint64(y))
// uint64: 18446744073709551615 = 0xffffffffffffffff
// int64:                    -1 = 0xffffffffffffffff


x -= 100
y -= 100
fmt.Printf("uint64: %v = %#[1]x, int64: %v = %#x\n", x, y, uint64(y))
// uint64: 18446744073709551515 = 0xffffffffffffff9b
// int64:                  -101 = 0xffffffffffffff9b 

https://play.golang.com/p/hlWqhnC9Dh

You convert them with a type "conversion"

var a int
var b int64
int64(a) < b

When comparing values, you always want to convert the smaller type to the larger. Converting the other way will possibly truncate the value:

var x int32 = 0
var y int64 = math.MaxInt32 + 1 // y == 2147483648
if x < int32(y) {
// this evaluates to false, because int32(y) is -2147483648

Or in your case to convert the maxInt int64 value to an int, you could use

for a := 2; a < int(maxInt); a++ {

which would fail to execute correctly if maxInt overflows the max value of the int type on your system.

Converting a signed number to an unsigned number will not remain negative, it can't, as the valid range of unsigned types doesn't include negative numbers. If you print uint(interval), you will certainly see a positive number printed.

What you experience is deterministic and you can rely on it (but it doesn't mean you should). It is the result of Go (and most other programming languages) storing signed integer types using the 2's completement representation.

What this means is that in case of negative numbers, using n bit, the value -x (where x is positive) is stored as the binary representation of the positive value 2^n - x. This has the advantage that numbers can be added bitwise, and the result will be correct regardless of whether they are negative or positive.

So when you have a signed negative number, it is basically stored in memory like if you would subtract its absolute value from 0. Which means that if you convert a negative, signed value to unsigned, and you add that to an unsigned value, the result will be correct because overflow will happen, in a useful way.

Converting a value of type int64 to uint64 does not change the memory layout, only the type. So what 8 bytes the int64 had, the converted uint64 will have those same 8 bytes. And as mentioned above, the representation stored in those 8 bytes is the bit pattern identical to the bit pattern of value 0 - abs(x). So the result of the conversion will be a number that you would get if you would subtract abs(x) from 0, in the unsigned world. Yes, this won't be negative (as the type is unsigned), instead it will be a "big" number, counting down from the max value of the uint64 type. But if you add an y number bigger than abs(x) to this "big" number, overflow will happen, and the result will be like y - abs(x).

See this simple example demonstrating what's happening (try it on the Go Playground):

a := uint8(100)
b := int8(-10)
fmt.Println(uint8(b)) // Prints 226 which is: 0 - 10 = 256 - 10
a = a + uint8(b)
fmt.Println(a)        // Prints 90 which is: 100 + 226 = 326 = 90
                      //           after overflow: 326 - 256 = 90

As mentioned above, you should not rely on this, as this may cause confusion. If you intend to work with negative numbers, then use signed types.

And if you work with a code base that already uses uint64 values, then do a subtraction instead of addition, using uint64 values:

interval := uint64(3600)
endTime -= interval

Also note that if you have time.Time values, you should take advantage of its Time.Add() method:

func (t Time) Add(d Duration) Time

You may specify a time.Duration to add to the time, which may be negative if you want to go back in time, like this:

t := time.Now()
t = t.Add(-3600 * time.Second)

time.Duration is more expressive: we see the value we specified above uses seconds explicitly.

This is called type conversion :

Copyi := 23
var i64 int64
i64 = int64(i)

No need to use any of the strconv functions; just do a type conversion to uint:

h64, err := strconv.ParseUint(height, 10, 32)
if err != nil {
    // TODO: handle error
}
w64, err := strconv.ParseUint(width, 10, 32)
if err != nil {
    // TODO: handle error
}
h := uint(h64)
w := uint(w64)

math.MaxUint64 is a constant, not an int64. Try instead:

fmt.Printf("%d", uint64(num))

The issue here is that the constant is untyped. The constant will assume a type depending on the context in which it is used. In this case, it is being used as an interface{} so the compiler has no way of knowing what concrete type you want to use. For integer constants, it defaults to int. Since your constant overflows an int, this is a compile time error. By passing uint64(num), you are informing the compiler you want the value treated as a uint64.

Note that this particular constant will only fit in a uint64 and sometimes a uint. The value is even larger than a standard int64 can hold.

Parsing string into int64 example:

// Use the max value for signed 64 integer. http://golang.org/pkg/builtin/#int64
var s string = "9223372036854775807"
i, err := strconv.ParseInt(s, 10, 64)
if err != nil {
    panic(err)
}
fmt.Printf("Hello, %v with type %s!\n", i, reflect.TypeOf(i))

output:

Hello, 9223372036854775807 with type int64!

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