Golang 1.19 New Features and Performance Updates

Golang 1.19 has introduced several new features that aim to improve performance and efficiency. The new language specification for Go 1.19 includes a change to the way the compiler handles the "go build" command.

This change allows for faster build times, especially for large projects. The compiler now uses a more efficient algorithm to determine the dependencies of a package.

One of the most notable new features in Go 1.19 is the introduction of the "go1.19" build constraint. This constraint allows developers to specify the Go version required to build their packages.

This new feature is particularly useful for projects that need to maintain compatibility with older versions of Go.

See what others are reading: Golang Go

Today, the Go team is thrilled to release Go 1.19, which you can get by visiting the download page.

This release refines and improves Go 1.18, focusing on addressing subtle issues and corner cases reported by the community.

Go 1.19's generics development has improved performance by up to 20% for some generic programs.

Discover more: Go vs Golang

The new release also includes a wide variety of performance and implementation improvements, including dynamic sizing of initial goroutine stacks to reduce stack copying.

Go's memory model now explicitly defines the behavior of the sync/atomic package, with new types such as atomic.Int64 and atomic.Pointer[T] to make it easier to use atomic values.

The garbage collector has added support for a soft memory limit, which can be particularly helpful for optimizing Go programs to run as efficiently as possible in containers with dedicated amounts of memory.

You can now use the new build constraint unix, which is satisfied when the target operating system (GOOS) is any Unix-like system.

The os/exec package no longer respects relative paths in PATH lookups, so existing uses of golang.org/x/sys/execabs can be moved back to os/exec in programs that only build using Go 1.19 or later.

Doc comments now support links, lists, and clearer heading syntax, which helps users write clearer, more navigable doc comments, especially in packages with large APIs.

Suggestion: Golang Use Cases

In Go 1.19, the language features have been improved with the introduction of the "text/template" package, which provides a way to generate text templates.

The new "text/template" package allows for more flexibility and control over template generation, making it easier to create complex templates.

One of the key features of this package is the ability to use "actions" to perform actions during template generation, such as printing to the console.

This feature is particularly useful for tasks such as logging or debugging, where you need to print information during template generation.

Discover more: Install Golang Package

Go's standard library has finally caught up with the times, introducing its first use of generics with atomic.Pointer[T]. This new API is a more convenient way to use atomic operations compared to its predecessors.

The feature was made possible by Russ Cox's work on revising Go's memory model, which has been warning programmers to not overthink things. If you must read the rest of the document to understand the behavior of your program, you're being too clever.

The memory model changes guarantee that Go's behavior is similar to other languages, but nothing should change in code that the average programmer writes.

Go 1.19 has clarified the formatting expected by go doc, making it easier to create high-quality documentation for your packages.

This change means you no longer have to dig through a GitHub repo to figure out how to format your doc comments. Go fmt now reformats doc comments to make their rendered meaning clearer.

With Go 1.19, you can include links in your doc comments, and they should display properly on pkg.go.dev. This is a big improvement for package documentation.

The new package go/doc/comment provides parsing and reformatting of doc comments, as well as support for rendering them to HTML, Markdown, and text. This makes it easier to work with doc comments and integrate them into your workflow.

Go fmt will even clean up certain formatting issues with doc comments, making it a one-stop-shop for formatting and cleaning up your code.

A different take: Create a Package in Golang

Go 1.19 introduces a soft memory limit that can be controlled by the environment variable GOMEMLIMIT or runtime/debug.SetMemoryLimit. This feature makes it easier to use Go in devices with a lot of RAM but a hard ceiling.

The soft memory limit includes the Go heap and all other memory managed by the runtime, excluding external memory sources. It works in conjunction with runtime/debug.SetGCPercent and will be respected even if GOGC=off.

The runtime now schedules many fewer GC worker goroutines on idle operating system threads when the application is idle enough to force a periodic GC cycle, reducing latency.

The soft memory limit is a new feature in Go 1.19 that allows you to control the amount of memory your Go program can use.

You can set the soft memory limit using the environment variable GOMEMLIMIT or the runtime/debug.SetMemoryLimit function. This limit includes the Go heap and all other memory managed by the runtime, but excludes external memory sources.

The soft memory limit will trigger increasingly aggressive garbage collection as the amount of memory used gets closer to the target. This is designed to make it easier to use Go in devices with a lot of RAM but a hard ceiling.

The limit works in conjunction with runtime/debug.SetGCPercent and will be respected even if GOGC=off. This allows Go programs to always make maximal use of their memory limit, improving resource efficiency.

Larger memory limits, on the order of hundreds of megabytes or more, are stable and production-ready. However, small memory limits, on the order of tens of megabytes or less, are less likely to be respected due to external latency factors.

The Go runtime also attempts to limit total GC CPU utilization to 50%, excluding idle time, to prevent GC thrashing when the program's live heap size approaches the soft memory limit.

Runtime metrics can be a valuable tool for optimizing memory and performance. The /sched/gomaxprocs:threadsmetric reports the current runtime.GOMAXPROCS value, which is the number of threads that can run concurrently.

This metric can help you understand how your Go program is utilizing system resources. The /cgo/go-to-c-calls:callsmetric reports the total number of calls made from Go to C, which is identical to the runtime.NumCgoCall function.

Understanding these metrics can help you identify potential bottlenecks in your code. The /gc/limiter/last-enabled:gc-cyclemetric reports the last GC cycle when the GC CPU limiter was enabled, which can provide insights into how your program is handling garbage collection.

Runtime Trace has gotten a boost with the ability to include CPU profile samples as instantaneous events when tracing and the CPU profiler are enabled simultaneously. This allows for a more comprehensive view of your application's performance.

Collecting goroutine profiles now takes less time, reducing the overall latency impact to your application. This is a significant improvement for developers who rely on these profiles to identify performance bottlenecks.

The Find function is a new addition to the runtime/pprof package, similar to Search but often easier to use. It returns a boolean indicating whether an equal value was found, making it a convenient option for certain use cases.

MaxRSS is now reported in heap profiles for all Unix operating systems, providing a more complete picture of memory usage. This change brings consistency to the reporting of memory usage across different platforms.

For another approach, see: Golang Applications

The Go memory model has been revised to align with other popular languages like C, C++, Java, JavaScript, Rust, and Swift. This change ensures that Go's memory model is more consistent and predictable.

Go only provides sequentially consistent atomics, which means you don't have to worry about the more relaxed forms found in other languages. This ensures that your code behaves as expected, even in concurrent environments.

The sync/atomic package has been updated with new types that make it easier to use atomic values. These types include atomic.Int64 and atomic.Pointer[T], which provide a convenient way to work with atomic integers and pointers.

The new atomic types in the sync/atomic package, such as Bool, Int32, Int64, and Uint64, hide the underlying values and force all accesses to use the atomic APIs. This ensures that your code is thread-safe and free from data races.

Int64 and Uint64 types are automatically aligned to 64-bit boundaries in structs and allocated data, even on 32-bit systems. This means you don't have to worry about manual alignment, which can be a pain to get right.

The new types in the sync/atomic package, such as Bool, Int32, Int64, Pointer, Uint32, Uint64, and Uintptr, provide a clean and efficient way to work with atomic values. These types are designed to improve the correctness of your program, making it easier to write concurrent code.

You might like: Watermill Golang Sync

The fmt package has a powerful feature that allows you to append formatted data to byte slices.

You can use the new functions Append, Appendf, and Appendln to achieve this. These functions are designed to append arbitrarily typed data to byte slices.

Append, Appendf, and Appendln are the key functions to remember here. They're the ones that make it easy to append formatted data to byte slices.

Using these functions is straightforward - just pass in the data you want to append and the fmt package will take care of the rest. The result is a byte slice that contains the appended data.

The fmt package is a reliable tool for working with byte slices. You can trust it to get the job done efficiently.

The race detector in Go has made significant improvements. With Go 1.19, the new thread sanitizer v3 is typically 1.5x to 2x faster than v2.

This means that running Go code with the -race flag is no longer a major performance hit. The new thread sanitizer uses only half as much memory as its predecessor.

As a result, developers can now run their code with the -race flag without worrying about a significant slowdown. This is especially useful for large-scale applications that require frequent testing for data races.

Explore further: Golang Source Code

The Go compiler has been improved with a jump table to implement large integer and string switch statements, resulting in performance improvements of up to 20% for switch statements on GOARCH=amd64 and GOARCH=arm64 platforms.

The compiler now requires the -p=importpath flag to build a linkable object file, which is already supplied by the go command and Bazel.

This flag is crucial for building linkable object files, and any other build systems that invoke the Go compiler directly will need to pass this flag as well.

A different take: Fallthrough Golang

The compiler has received some significant updates. The compiler now uses a jump table to implement large integer and string switch statements, which can result in performance improvements of up to 20% faster on certain architectures, like GOARCH=amd64 and GOARCH=arm64.

This change is a big deal for developers who work with switch statements. To build a linkable object file, the Go compiler now requires the -p=importpath flag, which is already automatically supplied by the go command and Bazel.

However, other build systems that invoke the Go compiler directly need to make sure to pass this flag as well. This is a change from the previous behavior, where the -importmap flag was accepted.

Developers who use the -importmap flag will need to switch to the -importcfg flag instead. This change affects build systems that invoke the Go compiler directly, so it's essential to update accordingly.

The assembler is a crucial tool in the development process, and it's essential to understand its requirements.

The assembler now requires the -p=importpath flag to build a linkable object file, which is already supplied by the go command.

This change means that any other build systems that invoke the Go assembler directly will need to pass this flag as well.

The GOROOT function has also been updated to return the empty string when the binary was built with the -trimpath flag set and the GOROOT variable is not set in the process environment.

LoongArch 64-bit is a supported architecture in Go 1.19, which adds a new dimension to cross-platform development.

Go 1.19 supports LoongArch 64-bit on Linux, specifically with the GOOS=linux and GOARCH=loong64 settings.

The implemented ABI is LP64D, which is an important detail for developers working with this architecture.

The minimum kernel version supported is 5.19, so make sure your system meets this requirement for seamless integration.

Existing commercial Linux distributions for LoongArch often come with older kernels, which is a historical incompatibility that can cause issues.

Compiled binaries may not work on these systems, even if they're statically linked, which is a limitation users on these systems face.

Users on unsupported systems are limited to the distribution-provided Go package, which is a workaround but not an ideal solution.

The crypto and security landscape in Go 1.19 has seen some significant changes.

The `CreateCertificate` function in `crypto/x509` no longer supports creating certificates with the MD5WithRSA signature algorithm. This is a good thing, as practical attacks against SHA-1 have been demonstrated since 2017 and publicly trusted Certificate Authorities have not issued SHA-1 certificates since 2015.

Applications using the `GODEBUG` option `x509sha1=1` should work on migrating to a future release, as it has been rescheduled.

The `ParseCertificate` and `ParseCertificateRequest` functions in `crypto/x509` now reject certificates and CSRs that contain duplicate extensions. This is a good practice to prevent errors and inconsistencies.

The `CertPool` type in `crypto/x509` has new methods `Clone` and `Equal`, which allow cloning a `CertPool` and checking the equivalence of two `CertPools` respectively.

The `ParseRevocationList` function in `crypto/x509` provides a faster and safer way to parse CRLs, returning a `RevocationList` with populated fields `RawIssuer`, `Signature`, `AuthorityKeyId`, and `Extensions`.

The `RevocationList` type has a new method `CheckSignatureFrom`, which checks that the signature on a CRL is a valid signature from a Certificate.

The `ParseCRL` and `ParseDERCRL` functions in `crypto/x509` are now deprecated in favor of `ParseRevocationList`. Similarly, the `Certificate.CheckCRLSignature` method is deprecated in favor of `RevocationList.CheckSignatureFrom`.

Certificate verification in Go 1.19 has seen improvements, with the path builder of `Certificate.Verify` overhauled to produce better chains and be more efficient in complicated scenarios.

Name constraints are now enforced on non-leaf certificates, which is an important security feature to prevent certificate misuse.

Related reading: Golang Tile Type

In Go 1.19, encoding and decoding just got a whole lot easier with some exciting new features.

The encoding/xml package now includes a new method called Decoder.InputPos, which reports the reader's current input position as a line and column, making it easier to track your code's progress.

This is a game-changer for developers who work with XML data, as it allows for more precise error handling and debugging.

The encoding/binary package has also been improved with the introduction of the AppendByteOrder interface, which provides efficient methods for appending uint16, uint32, or uint64 values to a byte slice, making it ideal for working with binary data.

BigEndian and LittleEndian now implement this interface, making it easy to work with different byte orders.

The Encoding/Binary section has some exciting updates that make working with binary data more efficient.

The new AppendByteOrder interface provides efficient methods for appending uint16, uint32, or uint64 values to a byte slice.

BigEndian and LittleEndian now implement this interface, making it easy to work with different byte order formats.

AppendByteOrder is a game-changer for anyone working with binary data, allowing for faster and more streamlined operations.

The new AppendUvarint and AppendVarint functions are efficient appending versions of PutUvarint and PutVarint, making it easier to work with variable-length integers.

These updates make it simpler to work with binary data in Go, and can be a big help when working on projects that involve encoding and decoding.

Encoding/Csv is a powerful tool for working with comma-separated values.

The encoding/csv method allows you to read and write CSV files.

This method is useful for importing and exporting data from various sources.

The new method Reader.InputOffset reports the reader's current input position as a byte offset, analogous to encoding/json's Decoder.InputOffset.

Encoding XML is a straightforward process that allows you to work with data in a structured format. The encoding format is specified by the string "encoding/xml".

The new method Decoder.InputPos reports the reader's current input position as a line and column, analogous to encoding/csv's Decoder.FieldPos. This is a useful feature for debugging and tracking the progress of the reader.

Take a look at this: Golang Format Time

The Go command has some exciting new features in Go 1.19. The -trimpath flag is now included in the build settings stamped into Go binaries by gobuild. This allows you to examine the build settings using goversion-m or debug.ReadBuildInfo.

gogenerate now sets the GOROOT environment variable explicitly, so generators can locate the correct GOROOT even if built with -trimpath. This ensures that tests and generators can resolve the go command to the same GOROOT.

Go 1.19 also improves the performance of golist invocations by caching information necessary to load some modules. This should result in a speed-up of some golist invocations.

The Go command is a powerful tool that offers a range of features to enhance your development experience. The -trimpath flag, if set, is now included in the build settings stamped into Go binaries by gobuild.

This means you can examine the build settings using goverson-m or debug.ReadBuildInfo. I've found this feature particularly useful when debugging complex builds.

gogenerate now sets the GOROOT environment variable explicitly in the generator's environment, so that generators can locate the correct GOROOT even if built with -trimpath.

gotest and gogenerate now place GOROOT/bin at the beginning of the PATH used for the subprocess, so tests and generators that execute the go command will resolve it to the same GOROOT.

Here are some key changes to the go command:

The Go programming language has a variety of architectures that it can be built for.

The Lunar build supports the following architectures: amd64, arm64, armhf, ppc64el, riscv64, and s390x.

To use the Lunar build, you can install the Go metapackage, which guarantees that a full Go development environment is installed.

This metapackage is a package that, when installed, ensures that a full Go development environment is available.

You can use the Lunar build by adding /usr/lib/go-1.19/bin/ to your PATH, or by invoking /usr/lib/go-1.19/bin/go directly.

This allows you to use the Go compiler and other tools without having to specify the full path to the binary.

Expand your knowledge: Golang App Development

The flag package in Go has just gotten even more powerful with the introduction of the TextVar function. This allows you to use any type that implements encoding.TextUnmarshaler directly as a flag.

You can now define custom command-line flag types using the flag package in Go 1.19. This is done by implementing the encoding.TextUnmarshaler interface.

For example, you can use a flag that is parsed into a custom struct type, or a flag for time.Time or netip.Addr types. The flag package has been improved to make it easier to work with custom types.

The flag.TextVar function and method let you use any type that implements encoding.TextUnmarshaler directly as a flag without needing to write an adapter.

For your interest: Golang Types

The Go 1 promise of compatibility has led to various minor changes and updates to the library, ensuring that your code remains reliable and efficient.

These changes are designed to improve performance, although they're not explicitly listed here.

To take advantage of the new features, simply update your PATH environment variable to include /usr/lib/go-1.19/bin/, or invoke the go command directly from this directory.

This will allow you to use the latest version of the Go programming language, which is an open source project aimed at making programmers more productive.

With Go, you can write programs that get the most out of multicore and networked machines, thanks to its concurrency mechanisms.

Go compiles quickly to machine code, yet still offers the convenience of garbage collection and the power of run-time reflection.

The net package in Go 1.19 has some exciting changes. The pure Go resolver now uses EDNS(0) to include a suggested maximum reply packet length, allowing for larger reply packets up to 1232 bytes.

This change is intended to make it easier for code to test for cases where a context cancellation or timeout causes a net package function or method to return an error. Errors returned by net package functions or methods now satisfy errors.Is(err, context.DeadlineExceeded) for "I/O timeout" errors.

The Resolver.PreferGo option is now implemented on Windows and Plan 9, making it possible to write portable programs and control all DNS name lookups when dialing. This is a big deal for cross-platform development.

The net package now has initial support for the netgo build tag on Windows, using the Go DNS client instead of asking Windows for DNS results. However, the upstream DNS server may not yet be correct with complex system network configurations.

The new JoinPath function and URL.JoinPath method create a new URL by joining a list of path elements. This is a useful addition for working with URLs in Go.

A unique perspective: Install Golang Windows

In Go 1.19, the NopCloser type's result now implements WriterTo whenever its input does. This improvement makes working with NopCloser more seamless.

With the new implementation, MultiReader's result now unconditionally implements WriterTo. This change ensures that MultiReader behaves consistently and predictably.

If any underlying reader in a MultiReader does not implement WriterTo, it's simulated appropriately to maintain functionality.

The unix build constraint is now recognized in //go:build lines, and it's satisfied if the target operating system is a Unix or Unix-like system.

For the 1.19 release, this constraint is satisfied if the GOOS is one of aix, android, darwin, dragonfly, freebsd, hurd, illumos, ios, linux, netbsd, openbsd, or solaris.

In the future, the unix constraint may match additional newly supported operating systems, but for now, these are the ones that satisfy it.

You can use this constraint to ensure your Go programs only run on Unix-like systems if that's what you want, and it's a useful feature to have.

Suggestion: Golang Time Unix

In the world of System and IO, there's a fascinating concept called Io. Here's how it works: NopCloser's result now implements WriterTo whenever its input does.

The implementation of WriterTo is unconditionally applied to MultiReader's result. This means that regardless of the underlying reader, it will always implement WriterTo.

If an underlying reader doesn't implement WriterTo, it's simulated appropriately. This ensures that the result of MultiReader still functions as expected.

Expand your knowledge: Golang Io

Syscall is a crucial function in system programming, and understanding its behavior is essential for developers. On PowerPC architectures, specifically GOARCH=ppc64 and ppc64le, Syscall, Syscall6, RawSyscall, and RawSyscall6 now return 0 for return value r2 instead of an undefined value.

This change is significant, as it provides a predictable outcome for developers working on these architectures. This means that developers can rely on these syscalls to return a consistent result, making their code more stable and reliable.

In addition to this change, syscalls like Getrusage are now defined on AIX and Solaris platforms. This is a welcome addition, as it allows developers to access more system information and make more informed decisions in their code.

A possibly breaking change has been introduced in Go, affecting PATH lookups. This change may break code that calls exec.Command() to run a command located in the current directory.

exec.LookPath() no longer searches for a command relative to the current directory. Instead, it returns that path along with an error.

If you have code that calls exec.Command("newsfilter") to run a command called newsfilter in the current directory, you may need to rewrite it. Specifically, you should use exec.Command("./newsfilter") on Unix-like systems, or ".

ewsfilter.exe" on Windows.

This change may cause issues if your code relies on the old behavior of exec.LookPath(). However, you can easily fix this by modifying your code to include the full path to the command.

Time and Date is a crucial aspect of any programming language, and Go 1.19 is no exception.

The Go time package has been updated to use the IANA time zone database, which provides more accurate and consistent time zone information.

This change affects how time zones are handled in Go programs, ensuring that dates and times are represented correctly across different regions.

The time.Now function now returns a Time object with a Zone string that reflects the local time zone.

This makes it easier to work with dates and times in Go, especially when dealing with international users or data.

The time.Parse function has also been updated to handle the new time zone database, making it easier to parse dates and times from strings.

Take a look at this: Time Parse Golang

The html/template package has undergone a change in Go 1.19.8 and later versions. The type FuncMap is now an alias for text/template's FuncMap instead of its own named type.

This change allows for more flexibility when working with FuncMaps, making it easier to write code that operates on them from either package.

If you're using ECMAScript 6 template literals, you'll notice a new restriction in Go 1.19.8 and later. Actions are no longer allowed in these template literals.

However, if you need to revert this behavior, you can use the GODEBUG=jstmpllitinterp=1 setting.

In Go 1.19, the image/draw package has a new feature that preserves non-premultiplied-alpha colors when drawing images.

The Src operator now behaves like it did in Go 1.17 and earlier, which is a change from the behavior introduced in Go 1.18.

This change was made to revert a behavior change accidentally introduced by a Go 1.18 library optimization.

The Src operator is used to draw with the source image, and it works correctly when the destination and source images are both image.NRGBA or both image.NRGBA64.

This change is a minor but important update to the image/draw package, and it's likely to affect developers who use this package to work with images in their applications.

Go 1.19 includes a more specific error, syntax.ErrNestingDepth, for very deeply nested regular expressions.

This error is a result of a security fix in the regular expression parser, which was introduced in Go 1.18 release candidate 1, Go 1.17.8, and Go 1.16.15.

Prior to Go 1.19, the parser returned syntax.ErrInternalError in this case, but the new error provides more clarity and specificity.

The introduction of syntax.ErrNestingDepth in Go 1.19 is a welcome improvement for developers working with regular expressions.

Readers also liked: Golang Create Error

In Go 1.19, reflection and type features have been improved to make development more efficient. The Func.Origin and Var.Origin methods now return the corresponding Object of the generic type for synthetic Func and Var objects created during type instantiation.

The Value.Bytes method can now accept addressable arrays in addition to slices, making it more versatile. This change allows for more flexibility when working with arrays and slices.

The Value.Len and Value.Cap methods now successfully operate on a pointer to an array, returning the length of that array, just like the built-in len and cap functions. This ensures consistency in how lengths and capacities are calculated.

Go Types are a fundamental concept in the Go programming language, allowing you to work with types at runtime.

You can use the go/types package to create and manipulate types, including accessing the underlying type of a Named type.

Named type instantiations can be created, but recursive calls to Named.Underlying or Named.Method are no longer allowed to prevent infinite type instantiations.

The go/types package provides methods to work with synthetic Func and Var objects, such as Func.Origin and Var.Origin, which return the corresponding Object of the generic type.

The Reflect section is where things get really interesting. The method Value.Bytes now accepts addressable arrays in addition to slices.

This is a big deal because it means you can work with arrays in a more flexible way. The methods Value.Len and Value.Cap now successfully operate on a pointer to an array and return the length of that array.

The len and cap functions are built-in, so it's great to see the Value.Len and Value.Cap methods matching their behavior. This makes it easier to work with arrays and get the information you need.

With these changes, you can use Value.Bytes, Value.Len, and Value.Cap to work with arrays and slices in a more efficient and accurate way.

Expand your knowledge: Golang Copy Array

Hashing data in Go has become even more efficient with the introduction of the new functions Bytes and String. These functions provide a way to hash a single byte slice or string.

The Bytes function is equivalent to using the more general Hash function with a single write, but it avoids the setup overhead for small inputs. This makes it a great option for hashing small byte slices.

The String function works similarly, providing an efficient way to hash a single string. It's also equivalent to using the Hash function with a single write, but with the added benefit of avoiding setup overhead for small strings.

These new functions can be a big time-saver in certain situations, especially when working with small inputs.

Additional reading: Golang String to Time

The sorting algorithm in Go 1.19 has seen a significant improvement. It now uses pattern-defeating quicksort, which is faster for several common scenarios.

This change is a result of tweaking the algorithm to take advantage of the characteristics of the data being sorted. The new algorithm can achieve a best-case time of O(n) when the sequence is already sorted.

The new sort algorithm is still O(n log n) on average and in the worst case, but it's a notable improvement for certain use cases.

Suggestion: Golang Case

In Go 1.18, bufio.Writer.AvailableBuffer() was added to make it easier to use the low-level append-to-preallocated-byte-slice pattern.

This addition paved the way for further improvements in Go 1.19.

Go 1.19 expanded the low-level append-to-preallocated-byte-slice pattern with the addition of fmt.Append, fmt.Appendf, and fmt.Appendln.

These functions work similarly to fmt.Print, but instead of printing to standard out or an io.Writer or a string, they append to a byte slice.

This allows for very precise control of memory allocation, giving developers more flexibility and efficiency in their coding.

Explore further: Golang Copy Slice