In my previous article, we looked at how we could introduce a more readable and maintainable way to express data parallelism in Go and used it for a quick Sum example. In this article, I will look at implementing hex.Encode and hex.Decode with it to start a discussion based on some more practical example.

Encode

Current implementation for hex.Encode looks like:

func Encode(dst, src []byte) int {
	j := 0
	for _, v := range src {
		dst[j] = hextable[v>>4]
		dst[j+1] = hextable[v&0x0f]
		j += 2
	}
	return len(src) * 2
}

We will have to change a bit the algorithm and iterate on the EncodedLen of src to have a continuous iterator. With that in mind, let’s see how it would look like:

In Go, we have the ability to execute multiple concurrent code path (concurrency) in parallel using goroutine. There has been consideration to add concurrency without parallelism with coroutine, but we haven’t really explored the concept of getting parallelism without concurrency.

What is parallelism without concurrency?

The idea is that the same code is executed on an array of data in parallel. This is how language like Cuda, OpenCL or even shaders language work with GPU. For shaders, for example, you code the algorithm that is going to be applied to each pixels, for example, and it will execute that code on all the pixels in parallel. Same code, different data. No code concurrency, just data parallelism. And the code can adapt to the capacity of the hardware (number of unit doing computation in parallel) without change.

The tech sector, after a decade of remarkable growth, has faced significant layoffs. These events affect everyone-not just those directly impacted, but also the colleagues who remain. For those let go, the challenges of finding new opportunities in a tough market are profound. Meanwhile, those who stay often grapple with shaken trust in management, increased workloads, and heightened stress about their own job security.

Much has been written about these emotional and logistical challenges. However, one crucial aspect remains underexplored: the impact of layoffs on technical debt and how it evolves in downsized teams.