Abhinav Kumar

Making Sense of Curves: Drawing Tangents and Normals with Diagrams Library

Sun, 06 Jul 2025 00:00:00 +0000

Drawing tangent and normal vectors on curves helps understand how curves behave. The Diagrams library in Haskell makes this easy. Based on Pontus Granström’s example, here’s how to do it.

First, import the libraries:

import Diagrams.Backend.SVG.CmdLine
import Diagrams.Prelude

Define your points and create a smooth curve:

pts = map p2 [(0,0), (1,1), (2,1), (3,0), (3.5,0)]

spline :: Located (Trail V2 Double)
spline = cubicSpline False pts

Pick a point on the curve and get its vectors:

param = 0.45
pt = atParam spline param
tangentVector = tangentAtParam spline param
normalVector = normalAtParam spline param

Create the visual elements - lines for vectors and a square for the right angle:

symmetricLine v = fromOffsets [2 *^ v] # center
tangentLine = symmetricLine tangentVector
normalLine = symmetricLine normalVector

rightAngleSquare = square 0.1 # alignBL # rotate (signedAngleBetween tangentVector unitX)

Finally, put everything together:

example :: Diagram B
example = frame 0.5 $
  strokeLocTrail spline
  <> mconcat
     [ tangentLine
     , baselineText "tangent" # translate tangentVector
     , normalLine
     , topLeftText "normal" # translate normalVector
     , rightAngleSquare
     ] # moveTo pt # fontSize large

A tangent vector shows which way the curve is pointing at any point. The normal vector sits at a right angle to the tangent, pointing away from the curve. We use a parameter - just a number - to tell us exactly where we are along the curve.

Seeing math as pictures makes it much easier to understand than staring at equations. You can quickly check if your calculations are right by looking at the visual result. This builds intuition faster than pure algebra.

You could animate the vectors to show how they change as you move along the curve. Another idea is to display vectors at several points at once. You might also add curvature circles to show how sharply the curve bends.

Check out the Diagrams docs for more examples. The original example by Pontus Granström shows this code in action. Learn more about Haskell to write your own diagrams.

Simple code for drawing tangent and normal vectors on curves using Haskell’s Diagrams library.

When Disks Dance: Visualizing Hanoi’s Puzzle in Haskell

Tue, 28 Jan 2025 00:00:00 +0000

Ever wondered what the Towers of Hanoi puzzle looks like when solved step by step? I found this cool Haskell code that shows the solution as pictures. It’s really neat to watch the disks move around!

The Towers of Hanoi is that old puzzle with three pegs and some disks of different sizes. You have to move all disks from the left peg to the right peg, but you can only move one disk at a time and you can never put a bigger disk on top of a smaller one.

Here’s how the code works:

First, it picks some nice colors for the disks:

colors = cycle $ map sRGB24read [ "#9FB4CC", "#CCCC9F", "#DB4105", "#FFF8E3", "#33332D"]

Each disk gets a different color based on its size. The bigger disks are wider rectangles, which makes sense when you look at it.

To draw a single disk, it makes a rectangle with width based on the disk number:

renderDisk :: Disk -> Dia
renderDisk n = rect (fromIntegral n + 2) 1
               # lc black
               # lw thin
               # fc (colors !! n)

For a whole stack of disks, it just piles them up on top of a peg:

renderStack :: Stack -> Dia
renderStack s = disks `atop` post
  where disks = (vcat . map renderDisk $ s)
                # alignB
        post  = rect 0.8 6
                # lw none
                # fc black
                # alignB

The cool part happens in the solving. The algorithm uses recursion - that’s when a function calls itself. For n disks, it:

Moves n-1 disks from the start to the middle peg
Moves the biggest disk to the end
Moves the n-1 disks from the middle to the end

solveHanoi :: Int -> [Move]
solveHanoi n = solveHanoi' n 0 1 2
  where solveHanoi' 0 _ _ _ = []
        solveHanoi' n a b c = solveHanoi' (n-1) a c b ++ [(a,c)]
                              ++ solveHanoi' (n-1) b a c

The doMove function actually does each move by taking a disk from one stack and putting it on another:

doMove :: Move -> Hanoi -> Hanoi
doMove (x,y) h = h''
  where (d,h')         = removeDisk x h
        h''            = addDisk y d h'
        removeDisk x h = (head (h!!x), modList x tail h)
        addDisk y d    = modList y (d:)

Finally, it makes a list of all the puzzle states and shows them stacked up and down:

renderHanoiSeq :: [Hanoi] -> Dia
renderHanoiSeq = vcat' (with & sep .~2) . map renderHanoi

Pretty cool how a few lines of code can show you exactly how an algorithm works, right? Sometimes the best way to understand something is to see it in action.

Visualizing the classic Towers of Hanoi puzzle solution using Haskell and the Diagrams library.

Understanding context.WithTimeout in Go

Mon, 10 Jun 2024 00:00:00 +0000

When you’re building real-world applications, things don’t always go as expected. Maybe an external API is slow, or a background process takes longer than it should. If your program just waits and waits, it can block everything else.

Go provides the context package to help deal with these situations. Specifically, context.WithTimeout lets you define a maximum time an operation should take — and cancels it if it runs too long.

This post walks through a simple example using context.WithTimeout, and how you can apply it in real applications.

What is the context Package?
The context package in Go helps manage deadlines, cancellation signals, and request-scoped data across goroutines. In other words, it gives you control over when to stop waiting for something that’s taking too long.

Why Timeouts Matter
Imagine making a network call to an external service. If it hangs or takes too long, your entire app might get stuck. Timeouts help prevent this. By setting a limit on how long you’ll wait, you make your application more robust and responsive.

A Simple Timeout Example

Let’s start by simulating a slow operation that takes 5 seconds to complete, but give it only 2 seconds to finish.

package main

import (
	"context"
	"fmt"
	"time"
)

func slowOperation(ctx context.Context) error {
	select {
	case <-time.After(5 * time.Second):
		return nil
	case <-ctx.Done():
		return ctx.Err()
	}
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	err := slowOperation(ctx)
	if err != nil {
		fmt.Println("Operation failed:", err)
		return
	}

	fmt.Println("Operation succeeded")
}

time.After(5 * time.Second) simulates a slow task.
ctx.Done() is a channel that is closed when the context is canceled or times out.
Since our context times out in 2 seconds, the function returns early with an error: context deadline exceeded.

Making an HTTP Request with Timeout

Here’s a practical use case: making an HTTP request that you don’t want to hang indefinitely.

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://httpbin.org/delay/5", nil)
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		fmt.Println("Request failed:", err)
		return
	}
	defer resp.Body.Close()

	fmt.Println("Response status:", resp.Status)
}

In this example:

We request an endpoint that intentionally waits 5 seconds before replying.
But our context times out in 2 seconds.
The request fails quickly, and we avoid a long delay.

Best Practices and Common Mistakes

Always call cancel() when you use context.WithTimeout (or WithCancel). This cleans up resources used by the context and avoids memory leaks.
Don’t ignore ctx.Err() – this tells you why the context ended (timeout, manual cancel, etc).
Don’t block forever – if you don’t listen to ctx.Done(), your goroutines may never exit.

When to Use context.WithTimeout

You need to limit how long an operation can run.
You’re making external calls (e.g., HTTP, DB).
You want graceful cancellation across goroutines.