Python vs Go vs TypeScript: Similarities, Differences, and When to Use Each

Most comparisons of Python, Go and TypeScript turn into a ranking. This one doesn't. All three are good general-purpose languages, and each makes different trade-offs about types, errors, concurrency and deployment. If you know one of them well, the fastest way to learn another is to see the same small programs written three ways and to know which habits will trip you up.

This programming language comparison does exactly that. You will find equivalent, runnable Python vs Go vs TypeScript examples for everyday tasks, a plain-English tour of the three type systems, the behavioral differences that cause real bugs, and the tooling you need to ship each language. At the end, I look at a real request path in my RoboShop AI project where a TypeScript storefront, a Python gateway and a Go service all handle the same currency data.

I assume you understand basic programming ideas such as variables, functions and loops, but you may know only one of these languages. Advanced material is marked as optional.

Python vs Go vs TypeScript in one minute

Python is a dynamically typed, interpreted language. "Dynamically typed" means a variable can hold any kind of value, and types are checked while the program runs, not before. Python lets you add optional type hints: annotations such as count: int that tools like mypy check before you run the code, but that the Python interpreter itself does not enforce. Python is common in data analysis, machine learning, AI integrations, automation scripts and web back ends.

Go is a statically typed, compiled language from Google. "Statically typed" means every variable has a fixed type that the compiler checks before the program can run. The Go compiler turns your code into a native executable for one operating system and CPU architecture, and that file runs without a separate interpreter. Go is common in network services, command-line tools and cloud infrastructure software.

TypeScript is JavaScript with a static type system added. You write .ts files; a tool checks the types and then removes them, leaving ordinary JavaScript that runs. TypeScript never runs by itself. The resulting JavaScript runs in a browser, in a server runtime such as Node.js, or in other JavaScript runtimes, and each environment offers different built-in APIs. TypeScript is the usual choice for browser interfaces, and it is common for full-stack web applications and Node.js services.

None of them wins everywhere. The rest of this article shows where each one fits better and why.

Where each language appears in my projects

I didn't want to assume anything here, so I checked the four repositories (counts are tracked source files, tests included, at the commits in the sources list). Go turned out to be present, which I had not expected before looking.

RoboShop AI also has 52 plain JavaScript .mjs files and a Java shipping service. The single Go file in tools can't be built as it stands (it has no module file), so I don't use it as an example. The real Go example in this article is the RoboShop currency service.

The versions each part pins:

What Python, Go and TypeScript have in common

Before looking at differences, it helps to see how much carries over. If you can write a small program in one of these languages, you already understand most of the ideas in the other two.

Two cells deserve a warning. "Exceptions" in Python and TypeScript look alike, but TypeScript doesn't track which functions throw. And all three have "concurrency", but the models are so different that section Concurrency and parallelism gets its own space.

How to run the examples

Every example in this article has a label:

• Standalone comparison example: a complete program I wrote for this article. Each one ends with an Output: comment showing exactly what it prints.
• Actual project code: copied exactly from one of my repositories, with the path and line numbers.
• Simplified from project code: shortened from a repository file, with the changes explained.

Where an example says Same output in all three languages, the three programs print identical text. Same values; the printed format differs means the results match but, for example, Python prints True and Go prints true. The outputs differ on purpose means the example exists to show a difference.

Python. Save the code as a .py file and run python3 example.py. The examples use syntax that works on Python 3.11 and later. To check type hints, install mypy into a virtual environment:

python3 -m venv .venv
source .venv/bin/activate
python -m pip install mypy pytest
mypy example.py

Go. Install Go 1.25 or later from go.dev (some examples use sync.WaitGroup.Go, added in 1.25). A single-file program runs with go run example.go. For examples with more than one file, create a module first:

mkdir example && cd example
go mod init example
go run .

go mod init writes a go.mod file that names the module. go vet ./... runs Go's built-in static checks, and gofmt -l . lists files that are not in the standard format.

TypeScript. Node.js 22.18 and later can run a .ts file directly with node example.ts. Node strips the type annotations and runs what's left, but it doesn't check the types and it ignores tsconfig.json. To check them, add a package.json containing {"type": "module"}, install the compiler with npm install --save-dev typescript @types/node, and use this tsconfig.json:

{
  "compilerOptions": {
    "strict": true,
    "noEmit": true,
    "target": "es2022",
    "module": "nodenext",
    "allowImportingTsExtensions": true,
    "erasableSyntaxOnly": true,
    "moduleDetection": "force",
    "types": ["node"]
  }
}

Then run npx tsc. noEmit means "check only, don't write JavaScript files". erasableSyntaxOnly makes the compiler reject the few TypeScript features that Node's type stripping can't run, such as enum and constructor parameter properties.

Python vs Go vs TypeScript examples, side by side

Hello world and the entry point

Every program needs a place to start. Python runs a file from top to bottom; the if __name__ == "__main__": check runs main() only when the file is executed directly, not when another file imports it. Go always starts at func main() in package main, and the fmt package (short for "format") provides printing. A TypeScript file run by Node.js also runs from top to bottom, so you simply call your function.

Standalone comparison example. Same output in all three languages.

# hello.py
def main() -> None:
    print("Hello, world!")


if __name__ == "__main__":
    main()

# Output:
# Hello, world!

// hello.go
package main

import "fmt"

func main() {
	fmt.Println("Hello, world!")
}

// Output:
// Hello, world!

// hello.ts
function main(): void {
  console.log("Hello, world!");
}

main();

// Output:
// Hello, world!

Go is the only one of the three that refuses to compile a file with an unused import. Delete the fmt.Println line and keep import "fmt", and the build fails. That feels strict at first, but it keeps imports honest.

Common mistake when switching: writing Python-style top-level statements in Go. Go allows only declarations (functions, types, variables, constants) at the top level of a file; statements must live inside a function.

Variables and constants

Standalone comparison example. Same output in all three languages.

# variables.py
from typing import Final

MAX_RETRIES: Final = 3

name = "Ada"
count = 2
count += 1
print(name, count, MAX_RETRIES)

# Output:
# Ada 3 3

// variables.go
package main

import "fmt"

const maxRetries = 3

func main() {
	name := "Ada"
	var count int = 2
	count++
	fmt.Println(name, count, maxRetries)
}

// Output:
// Ada 3 3

// variables.ts
const MAX_RETRIES = 3;

const name = "Ada";
let count = 2;
count += 1;
console.log(name, count, MAX_RETRIES);

// Output:
// Ada 3 3

What to notice:

• Python has no declaration keyword. name = "Ada" creates the variable. Final is a type hint that tells a type checker not to allow reassignment; Python itself would still let you reassign it.
• Go has two forms. name := "Ada" declares and infers the type (only inside functions). var count int = 2 spells the type out. const values must be known at compile time. Go also reports an unused local variable as a compile error.
• TypeScript uses const for bindings that are never reassigned and let for ones that are. const doesn't make an object immutable: const list = [1]; list.push(2) is allowed.

Common mistake when switching: in Go, := inside an if or for block declares a new variable that shadows an outer one with the same name. If you meant to update the outer variable, use =.

Strings and formatting

Standalone comparison example. Same output in all three languages.

# strings.py
name = "Ada"
items = 3
price = 4.5

print(f"{name} has {items} items costing {price:.2f}")
print(name.upper(), len(name))
print(", ".join(["a", "b", "c"]))

# Output:
# Ada has 3 items costing 4.50
# ADA 3
# a, b, c

// strings.go
package main

import (
	"fmt"
	"strings"
)

func main() {
	name := "Ada"
	items := 3
	price := 4.5

	fmt.Printf("%s has %d items costing %.2f\n", name, items, price)
	fmt.Println(strings.ToUpper(name), len(name))
	fmt.Println(strings.Join([]string{"a", "b", "c"}, ", "))
}

// Output:
// Ada has 3 items costing 4.50
// ADA 3
// a, b, c

// strings.ts
const name = "Ada";
const items = 3;
const price = 4.5;

console.log(`${name} has ${items} items costing ${price.toFixed(2)}`);
console.log(name.toUpperCase(), name.length);
console.log(["a", "b", "c"].join(", "));

// Output:
// Ada has 3 items costing 4.50
// ADA 3
// a, b, c

Python's f-strings (f"...") and TypeScript's template literals (`...${x}`) put expressions directly inside the string. Go has no string interpolation; you use fmt.Printf or fmt.Sprintf with verbs such as %s (string), %d (integer) and %.2f (float with two decimals). %v prints any value in a default format. String helpers live in the strings package rather than as methods.

len(name) and name.length both return 3 here, but they count different things. Go counts bytes, and JavaScript counts UTF-16 code units. For text outside plain ASCII, all three languages give different answers; see Unicode and string indexing.

Common mistake when switching: fmt.Println with a format verb. fmt.Println("%d", n) prints the literal %d followed by the number. Use fmt.Printf (and add \n yourself) when you need formatting.

Numbers and booleans

Standalone comparison example. Same values; the printed format differs.

# numbers.py
print(7 + 2, 7 - 2, 7 * 2, 7 / 2)
print(7 // 2, 7 % 2, 2 ** 10)

is_admin = True
is_active = False
print(is_admin and not is_active)

# Output:
# 9 5 14 3.5
# 3 1 1024
# True

// numbers.go
package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(7+2, 7-2, 7*2, 7.0/2)
	fmt.Println(7/2, 7%2, math.Pow(2, 10))

	isAdmin := true
	isActive := false
	fmt.Println(isAdmin && !isActive)
}

// Output:
// 9 5 14 3.5
// 3 1 1024
// true

// numbers.ts
console.log(7 + 2, 7 - 2, 7 * 2, 7 / 2);
console.log(Math.trunc(7 / 2), 7 % 2, 2 ** 10);

const isAdmin = true;
const isActive = false;
console.log(isAdmin && !isActive);

// Output:
// 9 5 14 3.5
// 3 1 1024
// true

Division is where the languages first disagree:

• Python has two operators. / always gives a float (3.5); // gives floor division (3).
• Go decides by type. 7/2 divides two integers and gives 3; 7.0/2 divides floats and gives 3.5. Go has no ** operator; math.Pow works on float64.
• JavaScript has one number type for both, so 7 / 2 is 3.5 and you use Math.trunc or Math.floor to drop the fraction.

Booleans are spelled True/False in Python and true/false in Go and TypeScript. Python uses the words and, or and not; Go and TypeScript use &&, || and !.

Common mistake when switching: in Go you can't mix types in arithmetic. If n is an int and f is a float64, n * f doesn't compile; you write float64(n) * f. Only untyped constants, such as the literal 2, adapt automatically.

Lists, slices and arrays

Standalone comparison example. Same values; the printed format differs.

# collections_demo.py
nums = [3, 1, 2]
nums.append(4)
print(nums, len(nums))
print(sorted(nums))
print(nums[1:3])

# Output:
# [3, 1, 2, 4] 4
# [1, 2, 3, 4]
# [1, 2]

// collections.go
package main

import (
	"fmt"
	"slices"
)

func main() {
	nums := []int{3, 1, 2}
	nums = append(nums, 4)
	fmt.Println(nums, len(nums))

	sorted := slices.Clone(nums)
	slices.Sort(sorted)
	fmt.Println(sorted)
	fmt.Println(nums[1:3])
}

// Output:
// [3 1 2 4] 4
// [1 2 3 4]
// [1 2]

// collections.ts
const nums = [3, 1, 2];
nums.push(4);
console.log(JSON.stringify(nums), nums.length);
console.log(JSON.stringify([...nums].sort((a, b) => a - b)));
console.log(JSON.stringify(nums.slice(1, 3)));

// Output:
// [3,1,2,4] 4
// [1,2,3,4]
// [1,2]

All three use zero-based indexes and half-open ranges: [1:3] and slice(1, 3) include index 1 and exclude index 3.

• A Python list holds values of any type and grows with append.
• A Go slice ([]int) holds values of one type. append returns a slice, and you must assign the result back: nums = append(nums, 4). The slices package (standard library since Go 1.21) provides Sort, Clone, Contains and similar helpers. Go also has fixed-length arrays such as [3]int, but you will use slices far more often.
• A JavaScript array grows with push. sort() sorts in place, which is why the example copies the array first with [...nums].

Common mistake when switching: calling sort() on numbers in JavaScript without a comparison function. The default sort compares values as strings, so [10, 9, 1].sort() gives [1, 10, 9]. Always pass (a, b) => a - b for numbers.

Dictionaries, maps and JavaScript objects

A dictionary or map stores values by key. Python has dict, Go has map[K]V, and JavaScript has two options: plain objects (often typed as Record<string, V> in TypeScript) and the Map class.

Standalone comparison example. Same values; the printed format differs.

# maps_demo.py
ages = {"ada": 36, "linus": 29}
ages["grace"] = 45

print(ages["ada"], len(ages), "bob" in ages)
for name in sorted(ages):
    print(name, ages[name])

# Output:
# 36 3 False
# ada 36
# grace 45
# linus 29

// maps.go
package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	ages := map[string]int{"ada": 36, "linus": 29}
	ages["grace"] = 45

	_, hasBob := ages["bob"]
	fmt.Println(ages["ada"], len(ages), hasBob)
	for _, name := range slices.Sorted(maps.Keys(ages)) {
		fmt.Println(name, ages[name])
	}
}

// Output:
// 36 3 false
// ada 36
// grace 45
// linus 29

// maps.ts
const ages: Record<string, number> = { ada: 36, linus: 29 };
ages["grace"] = 45;

console.log(ages["ada"], Object.keys(ages).length, "bob" in ages);
for (const name of Object.keys(ages).sort()) {
  console.log(name, ages[name]);
}

// Output:
// 36 3 false
// ada 36
// grace 45
// linus 29

Iteration order is a real difference. Python dicts keep insertion order. JavaScript objects mostly keep insertion order for string keys (integer-like keys come first). Go deliberately randomizes map iteration order, so code that depends on it breaks quickly. That's why all three examples sort the keys.

Use a JavaScript Map instead of a plain object when keys are not strings, when keys come from users (a key such as "__proto__" behaves specially on plain objects), or when you add and remove keys often.

Common mistake when switching: treating Go's ages["bob"] as an error. It returns the zero value for the value type (here 0) and doesn't fail. Use the two-value form value, ok := ages["bob"] to tell "missing" apart from "present with value 0".

Conditions

Standalone comparison example. Same output in all three languages.

# conditions.py
def grade(score: int) -> str:
    if score >= 90:
        return "A"
    elif score >= 75:
        return "B"
    else:
        return "C"


def label(status: str) -> str:
    match status:
        case "paid" | "shipped":
            return "done"
        case "pending":
            return "waiting"
        case _:
            return "unknown"


print(grade(95), grade(82), grade(40))
print(label("paid"), label("pending"), label("lost"))

# Output:
# A B C
# done waiting unknown

// conditions.go
package main

import "fmt"

func grade(score int) string {
	if score >= 90 {
		return "A"
	} else if score >= 75 {
		return "B"
	}
	return "C"
}

func label(status string) string {
	switch status {
	case "paid", "shipped":
		return "done"
	case "pending":
		return "waiting"
	default:
		return "unknown"
	}
}

func main() {
	fmt.Println(grade(95), grade(82), grade(40))
	fmt.Println(label("paid"), label("pending"), label("lost"))
}

// Output:
// A B C
// done waiting unknown

// conditions.ts
function grade(score: number): string {
  if (score >= 90) {
    return "A";
  } else if (score >= 75) {
    return "B";
  }
  return "C";
}

function label(status: string): string {
  switch (status) {
    case "paid":
    case "shipped":
      return "done";
    case "pending":
      return "waiting";
    default:
      return "unknown";
  }
}

console.log(grade(95), grade(82), grade(40));
console.log(label("paid"), label("pending"), label("lost"));

// Output:
// A B C
// done waiting unknown

Python uses elif; Go and TypeScript use else if. Go's if needs no parentheses but always needs braces. Python's match statement (Python 3.10 and later) is pattern matching, which can also destructure values. Here it's used like a simple switch.

Common mistake when switching: fall-through. In JavaScript, a case without return or break keeps running into the next case. Go stops at the end of each case unless you write fallthrough, and Python's match never falls through.

Loops

Python has for and while. Go has only for, which covers both. TypeScript has for...of, the classic three-part for, and while.

Standalone comparison example. Same output in all three languages.

# loops.py
names = ["ada", "linus"]
for i, name in enumerate(names):
    print(i, name)

n = 3
while n > 0:
    print("tick", n)
    n -= 1

# Output:
# 0 ada
# 1 linus
# tick 3
# tick 2
# tick 1

// loops.go
package main

import "fmt"

func main() {
	names := []string{"ada", "linus"}
	for i, name := range names {
		fmt.Println(i, name)
	}

	n := 3
	for n > 0 {
		fmt.Println("tick", n)
		n--
	}
}

// Output:
// 0 ada
// 1 linus
// tick 3
// tick 2
// tick 1

// loops.ts
const names = ["ada", "linus"];
for (const [i, name] of names.entries()) {
  console.log(i, name);
}

let n = 3;
while (n > 0) {
  console.log("tick", n);
  n--;
}

// Output:
// 0 ada
// 1 linus
// tick 3
// tick 2
// tick 1

Go's for i, name := range names gives the index and a copy of each element. Since Go 1.22, each iteration gets a fresh i and name, so closures and goroutines that capture them behave as you would expect. Go 1.22 also lets you write for i := range 3 to count from 0 to 2.

Common mistake when switching: using for...in on a JavaScript array. for (const i in names) loops over the keys as strings ("0", "1"), not the values. Use for...of for values.

Functions and return values

Standalone comparison example. Same output in all three languages.

# functions.py
from typing import Callable


def divide(a: int, b: int) -> tuple[int, int]:
    return a // b, a % b


def apply_twice(fn: Callable[[int], int], value: int) -> int:
    return fn(fn(value))


quotient, remainder = divide(7, 2)
print(quotient, remainder)
print(apply_twice(lambda x: x * 2, 5))

# Output:
# 3 1
# 20

// functions.go
package main

import "fmt"

func divide(a, b int) (int, int) {
	return a / b, a % b
}

func applyTwice(fn func(int) int, value int) int {
	return fn(fn(value))
}

func main() {
	quotient, remainder := divide(7, 2)
	fmt.Println(quotient, remainder)
	fmt.Println(applyTwice(func(x int) int { return x * 2 }, 5))
}

// Output:
// 3 1
// 20

// functions.ts
function divide(a: number, b: number): [number, number] {
  return [Math.trunc(a / b), a % b];
}

function applyTwice(fn: (x: number) => number, value: number): number {
  return fn(fn(value));
}

const [quotient, remainder] = divide(7, 2);
console.log(quotient, remainder);
console.log(applyTwice((x) => x * 2, 5));

// Output:
// 3 1
// 20

Returning two values looks similar in all three, but works differently. Python returns one tuple and unpacks it. TypeScript returns one array, typed as a tuple [number, number], and destructures it. Go has true multiple return values, which is why Go's error handling (value, err := ...) feels natural there. In Go, parameter types come after names, and a, b int shares one type between two parameters.

All three treat functions as values: lambda, Go's function literals and TypeScript's arrow functions are anonymous functions you can pass around.

Common mistake when switching: Python functions without a return statement return None; JavaScript functions return undefined. Go makes you declare the return type, and the compiler reports a missing return.

Optional and default inputs

Python and TypeScript have default parameter values. Go has neither defaults nor keyword arguments, and that is deliberate: every call shows every argument. Go code uses other patterns instead.

Standalone comparison example. Same output in all three languages.

# defaults.py
def greet(name: str, greeting: str = "Hello") -> str:
    return f"{greeting}, {name}!"


print(greet("Ada"))
print(greet("Ada", greeting="Hi"))

# Output:
# Hello, Ada!
# Hi, Ada!

// defaults.go
package main

import "fmt"

// GreetOptions groups optional settings. Its zero value means "use the defaults".
type GreetOptions struct {
	Greeting string
}

func greet(name string, opts GreetOptions) string {
	greeting := opts.Greeting
	if greeting == "" {
		greeting = "Hello"
	}
	return greeting + ", " + name + "!"
}

func main() {
	fmt.Println(greet("Ada", GreetOptions{}))
	fmt.Println(greet("Ada", GreetOptions{Greeting: "Hi"}))
}

// Output:
// Hello, Ada!
// Hi, Ada!

// defaults.ts
interface GreetOptions {
  greeting?: string;
}

function greet(name: string, { greeting = "Hello" }: GreetOptions = {}): string {
  return `${greeting}, ${name}!`;
}

console.log(greet("Ada"));
console.log(greet("Ada", { greeting: "Hi" }));

// Output:
// Hello, Ada!
// Hi, Ada!

Python's greeting="Hi" is a keyword argument: you name the parameter at the call site. TypeScript has no keyword arguments, so the common pattern is an options object, destructured with defaults. The ? in greeting?: string makes the property optional. Go's options struct works the same way, but relies on the field's zero value ("") to mean "not set". When the zero value is a valid setting, Go code uses a pointer field (*string) or the functional options pattern (variadic functions such as WithGreeting("Hi")).

Common mistake when switching: Python evaluates a default value once, when the function is defined. See mutable default arguments for the bug that causes.

Structured data models

Most programs pass around records such as a user. Python commonly uses a dataclass, Go uses a struct, and TypeScript describes plain objects with an interface (a class also works).

Standalone comparison example. Same values; the printed format differs.

# models.py
from dataclasses import dataclass


@dataclass
class User:
    name: str
    email: str
    active: bool = True

    def label(self) -> str:
        return f"{self.name} <{self.email}>"


user = User("Ada", "ada@example.com")
print(user.label(), user.active)

# Output:
# Ada <ada@example.com> True

// models.go
package main

import "fmt"

type User struct {
	Name   string
	Email  string
	Active bool
}

func NewUser(name, email string) User {
	return User{Name: name, Email: email, Active: true}
}

func (u User) Label() string {
	return u.Name + " <" + u.Email + ">"
}

func main() {
	user := NewUser("Ada", "ada@example.com")
	fmt.Println(user.Label(), user.Active)
}

// Output:
// Ada <ada@example.com> true

// models.ts
interface User {
  name: string;
  email: string;
  active: boolean;
}

function label(user: User): string {
  return `${user.name} <${user.email}>`;
}

const user: User = { name: "Ada", email: "ada@example.com", active: true };
console.log(label(user), user.active);

// Output:
// Ada <ada@example.com> true

• @dataclass generates __init__, __repr__ and __eq__ from the annotated fields.
• A Go struct has no constructor and no default field values. Every field starts at its zero value, so Active would be false unless set. A NewUser function is the usual way to supply defaults. func (u User) Label() is a method: a function with a receiver u. Capitalized names (User, Name, Label) are exported, meaning visible to other packages.
• A TypeScript interface only describes a shape. The object is an ordinary JavaScript object, and the interface disappears when the types are removed.

Common mistake when switching: expecting a TypeScript interface to check data at runtime. It can't, because it doesn't exist at runtime. See annotations versus runtime validation.

Handling missing values

Each language has a different way to say "there's nothing here".

Standalone comparison example. The outputs differ on purpose.

# missing.py
emails = {"ada": "ada@example.com"}

email = emails.get("bob")
print(email)
print(email if email is not None else "unknown")
print(emails.get("ada", "unknown"))

# Output:
# None
# unknown
# ada@example.com

// missing.go
package main

import "fmt"

func main() {
	emails := map[string]string{"ada": "ada@example.com"}

	email, ok := emails["bob"]
	fmt.Printf("%q %t\n", email, ok)
	if !ok {
		email = "unknown"
	}
	fmt.Println(email)
	fmt.Println(emails["ada"])
}

// Output:
// "" false
// unknown
// ada@example.com

// missing.ts
const emails = new Map<string, string>([["ada", "ada@example.com"]]);

const email = emails.get("bob");
console.log(email);
console.log(email ?? "unknown");
console.log(emails.get("ada") ?? "unknown");

// Output:
// undefined
// unknown
// ada@example.com

Python has one "nothing" value, None, and you test it with is None. Go has no general null; a missing map entry is the zero value ("" here), plus a boolean that says whether the key was there. JavaScript has two "nothing" values, undefined and null. TypeScript's ?? (nullish coalescing) uses the right side only when the left side is null or undefined, and ?. (optional chaining) stops at either one.

Common mistake when switching: using or in Python or || in TypeScript as a default operator. count or 10 replaces a real 0 with 10, because 0 is falsy. Use is None in Python and ?? in TypeScript.

Errors: a first look

The full comparison comes in Error handling; this small example shows the basic shape: converting text to a number.

Standalone comparison example. The outputs differ on purpose.

# parse_number.py
for raw in ["42", "abc"]:
    try:
        print(int(raw))
    except ValueError as err:
        print("error:", err)

# Output:
# 42
# error: invalid literal for int() with base 10: 'abc'

// parse_number.go
package main

import (
	"fmt"
	"strconv"
)

func main() {
	for _, raw := range []string{"42", "abc"} {
		n, err := strconv.Atoi(raw)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println(n)
	}
}

// Output:
// 42
// error: strconv.Atoi: parsing "abc": invalid syntax

// parse_number.ts
for (const raw of ["42", "abc"]) {
  const n = Number(raw);
  if (Number.isNaN(n)) {
    console.log("error: not a number:", raw);
    continue;
  }
  console.log(n);
}

console.log(Number(""), Number(" 42 "), Number.parseInt("42px", 10));

// Output:
// 42
// error: not a number: abc
// 0 42 42

Python raises an exception; Go returns an error value next to the result; JavaScript's Number() returns the special value NaN ("not a number") and doesn't throw at all. The last TypeScript line shows why JavaScript parsing needs care: an empty string becomes 0, and parseInt silently stops at the first non-digit.

JSON serialization and parsing

Standalone comparison example. Same output in all three languages.

# json_demo.py
import json

raw = '{"name": "Ada", "tags": ["admin", "dev"], "age": 36}'
data = json.loads(raw)
print(data["name"], data["tags"][0], data["age"] + 1)

print(json.dumps({"ok": True, "count": 2}, separators=(",", ":")))

# Output:
# Ada admin 37
# {"ok":true,"count":2}

// json_demo.go
package main

import (
	"encoding/json"
	"fmt"
)

type Profile struct {
	Name string   `json:"name"`
	Tags []string `json:"tags"`
	Age  int      `json:"age"`
}

type Result struct {
	OK    bool `json:"ok"`
	Count int  `json:"count"`
}

func main() {
	raw := `{"name": "Ada", "tags": ["admin", "dev"], "age": 36}`
	var p Profile
	if err := json.Unmarshal([]byte(raw), &p); err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(p.Name, p.Tags[0], p.Age+1)

	out, err := json.Marshal(Result{OK: true, Count: 2})
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(string(out))
}

// Output:
// Ada admin 37
// {"ok":true,"count":2}

// json_demo.ts
interface Profile {
  name: string;
  tags: string[];
  age: number;
}

const raw = '{"name": "Ada", "tags": ["admin", "dev"], "age": 36}';
const profile = JSON.parse(raw) as Profile;
console.log(profile.name, profile.tags[0], profile.age + 1);

console.log(JSON.stringify({ ok: true, count: 2 }));

// Output:
// Ada admin 37
// {"ok":true,"count":2}

• Python turns JSON into plain dict, list, str, int, float, bool and None values. By default json.dumps adds spaces after , and :; separators removes them.
• Go decodes into a struct. The text in backquotes after each field, such as `json:"name"`, is a struct tag: metadata that tells encoding/json which JSON key to use. Only exported (capitalized) fields are encoded. &p passes a pointer so Unmarshal can fill in p. Unknown JSON keys are ignored, missing keys leave the zero value, and key matching is case-insensitive by default ("NAME" would also fill Name). Since Go 1.27, encoding/json is implemented on top of the new encoding/json/v2; the release notes say the behavior is preserved, but error message text may differ.
• TypeScript: JSON.parse returns any, and as Profile is a type assertion. It tells the compiler "trust me"; nothing checks that the data really has that shape.

Common mistake when switching: lowercase struct fields in Go. A field named name (unexported) is silently skipped by encoding/json, so your output is {}.

Modules and imports

A module is a unit of code you can import. Here each language splits a greeting function into its own file.

Standalone comparison example. Same output in all three languages.

# greetings.py
def hello(name: str) -> str:
    return f"Hello, {name}!"

# main.py
from greetings import hello

if __name__ == "__main__":
    print(hello("Ada"))

# Output:
# Hello, Ada!

// greetings/greetings.go
package greetings

// Hello is exported because its name starts with a capital letter.
func Hello(name string) string {
	return prefix() + name + "!"
}

// prefix is unexported: only code in package greetings can call it.
func prefix() string {
	return "Hello, "
}

// main.go
package main

import (
	"fmt"

	"example/greetings"
)

func main() {
	fmt.Println(greetings.Hello("Ada"))
}

// Output:
// Hello, Ada!

// greetings.ts
export function hello(name: string): string {
  return `Hello, ${name}!`;
}

// main.ts
import { hello } from "./greetings.ts";

console.log(hello("Ada"));

// Output:
// Hello, Ada!

• Python: every .py file is a module. from greetings import hello finds greetings.py on the module search path, which includes the script's folder. Everything is importable; a leading underscore (_helper) is only a convention for "private".
• Go: a package is a folder. The import path example/greetings is the module name from go.mod plus the folder name. Visibility is decided by the first letter: Hello is exported, prefix is not. Go also rejects circular imports between packages.
• TypeScript: every file with import or export is an ES module, and you export names explicitly. Node's type stripping needs the real .ts extension in relative imports. If you compile with tsc to .js files instead, TypeScript can rewrite these extensions for you (the rewriteRelativeImportExtensions option), or you can import the .js name.

Common mistake when switching: naming a Python file after a standard library module, such as json.py or random.py. Your file shadows the real module, and import json loads your file instead.

A small HTTP request

This example fetches JSON from a local mock server, so it needs no credentials and touches no real service. Save this file as user.json in an empty folder:

Mock API response.

{"id": 1, "name": "Ada Lovelace", "role": "admin"}

Then start a local server in that folder with python3 -m http.server 8000 --bind 127.0.0.1, and run each program in another terminal.

Standalone comparison example. Same output in all three languages.

# http_get.py
import json
from urllib.request import urlopen

URL = "http://127.0.0.1:8000/user.json"

with urlopen(URL, timeout=5) as response:
    status = response.status
    user = json.load(response)

print(status, user["name"], user["role"])

# Output:
# 200 Ada Lovelace admin

// http_get.go
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

type User struct {
	Name string `json:"name"`
	Role string `json:"role"`
}

func main() {
	client := &http.Client{Timeout: 5 * time.Second}
	resp, err := client.Get("http://127.0.0.1:8000/user.json")
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		fmt.Println("unexpected status:", resp.StatusCode)
		return
	}
	var user User
	if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
		fmt.Println("bad JSON:", err)
		return
	}
	fmt.Println(resp.StatusCode, user.Name, user.Role)
}

// Output:
// 200 Ada Lovelace admin

// http_get.ts
interface User {
  name: string;
  role: string;
}

const response = await fetch("http://127.0.0.1:8000/user.json", {
  signal: AbortSignal.timeout(5000),
});
if (!response.ok) {
  throw new Error(`unexpected status: ${response.status}`);
}
const user = (await response.json()) as User;
console.log(response.status, user.name, user.role);

// Output:
// 200 Ada Lovelace admin

All three use only the standard library (or, for TypeScript, the fetch built into Node.js and browsers). In real Python projects, people often use the third-party httpx or requests packages instead of urllib.

Two details matter in production code:

• Timeouts. None of these clients should wait forever. Python's timeout=5, Go's http.Client{Timeout: ...} and AbortSignal.timeout(5000) each set a limit. Go's zero-value http.Client and http.Get have no timeout.
• Status codes. Python's urlopen raises an exception for 4xx and 5xx responses. Go and fetch treat any response as success, so you must check resp.StatusCode or response.ok yourself.

defer resp.Body.Close() schedules the close to run when main returns. Forgetting to close response bodies in Go leaks connections.

Type systems explained simply

Dynamic typing versus static typing

A type says what kind of value something is and what you can do with it. In a dynamically typed language, values carry their types and the interpreter checks them while running. In a statically typed language, the compiler checks types before the program runs.

That makes three different situations:

• Python: dynamically typed, with optional static checking. Type hints are stored but not enforced; an external tool such as mypy or Pyright checks them.
• Go: statically typed. A type error is a compile error, and there is no program to run until you fix it.
• TypeScript: statically typed at check time, dynamically typed at run time. The compiler checks your types, then the types are erased and plain JavaScript runs.

The same mistake shows all three:

Standalone comparison example. The outputs differ on purpose.

# hints.py
def add(a: int, b: int) -> int:
    return a + b


print(add(2, 3))
print(add("2", "3"))  # a type checker flags this line

# Output:
# 5
# 23

// hints.go
package main

import "fmt"

func add(a, b int) int {
	return a + b
}

func main() {
	fmt.Println(add(2, 3))
	fmt.Println(add("2", "3"))
}

// Error: cannot use "2" (untyped string constant) as int value in argument to add

// hints.ts
function add(a: number, b: number): number {
  return a + b;
}

console.log(add(2, 3));
// @ts-expect-error: tsc rejects these arguments, but Node.js still runs the line
console.log(add("2", "3"));

// Output:
// 5
// 23

Python runs the bad call and joins the strings into "23"; mypy would have reported it. The Go program doesn't build, and the compiler prints the error shown. The TypeScript program fails tsc, but node hints.ts runs it anyway and also prints 23, because Node.js only strips the types. (@ts-expect-error tells tsc that the next line is expected to fail, which lets this article's checker confirm that it does.)

The lesson for TypeScript: running a .ts file is not checking it. Put tsc --noEmit (or your framework's equivalent) in CI.

Type inference and structural typing

Type inference means the compiler works out a type you didn't write. Go infers types for x := 42, TypeScript infers const n = 42 as number (actually the literal type 42), and Python type checkers infer n = 42 as int.

Structural typing means two types are compatible if they have the same shape, regardless of their names. TypeScript is structural, and so are Go interfaces and Python Protocol classes. None of them requires you to declare "this class implements that interface".

Standalone comparison example. Same output in all three languages.

# shapes.py
from dataclasses import dataclass
from typing import Protocol


class Shape(Protocol):
    def area(self) -> int: ...


@dataclass
class Rect:
    width: int
    height: int

    def area(self) -> int:
        return self.width * self.height


@dataclass
class Square:
    side: int

    def area(self) -> int:
        return self.side * self.side


def total_area(shapes: list[Shape]) -> int:
    return sum(s.area() for s in shapes)


print(total_area([Rect(2, 3), Square(2)]))

# Output:
# 10

// shapes.go
package main

import "fmt"

type Shape interface {
	Area() int
}

type Rect struct{ Width, Height int }

func (r Rect) Area() int { return r.Width * r.Height }

type Square struct{ Side int }

func (s Square) Area() int { return s.Side * s.Side }

func totalArea(shapes []Shape) int {
	total := 0
	for _, s := range shapes {
		total += s.Area()
	}
	return total
}

func main() {
	fmt.Println(totalArea([]Shape{Rect{2, 3}, Square{2}}))
}

// Output:
// 10

// shapes.ts
interface Shape {
  area(): number;
}

class Rect {
  width: number;
  height: number;

  constructor(width: number, height: number) {
    this.width = width;
    this.height = height;
  }

  area(): number {
    return this.width * this.height;
  }
}

// A plain object with the right shape is also a Shape.
const square = {
  side: 2,
  area(): number {
    return this.side * this.side;
  },
};

function totalArea(shapes: Shape[]): number {
  return shapes.reduce((sum, s) => sum + s.area(), 0);
}

console.log(totalArea([new Rect(2, 3), square]));

// Output:
// 10

These look alike, but they are not the same feature:

• A Go interface is a real runtime value. A variable of type Shape holds a pair: the concrete type (Rect) and the value. That's why Go can ask at runtime, r, ok := s.(Rect) (a type assertion) or use a type switch. Go interfaces contain only methods, never fields.
• A TypeScript interface exists only at check time. It can describe fields, methods, optional properties and index signatures, but you can't write value instanceof Shape, because nothing named Shape exists in the running JavaScript.
• A Python Protocol exists only for type checkers too, unless you add @runtime_checkable, which then allows a basic isinstance check of method names.

TypeScript's constructor is written out longhand on purpose. The shortcut constructor(public width: number) (a parameter property) generates code, so Node's type stripping can't run it and erasableSyntaxOnly rejects it.

Python Any, Go any, and TypeScript any and unknown

All three have a type meaning "could be anything", and the name any means something different in Go and TypeScript.

• Python Any turns off checking: a type checker allows any operation on it. Use object when you mean "any value, but make me check before using it".
• Go any is an alias for interface{}, the empty interface. Every type satisfies it, but it is not an escape hatch. You can't add to it, call methods on it or index it until you get the concrete type back with a type assertion or type switch. In TypeScript terms, Go's any behaves like unknown.
• TypeScript any turns off checking, like Python's Any. unknown accepts any value but requires you to narrow it before use.

Standalone comparison example. Same output in all three languages.

# describe.py
def describe(value: object) -> str:
    if isinstance(value, int):
        return f"number {value}"
    if isinstance(value, str):
        return f"text {value}"
    if value is None:
        return "nothing"
    return "something else"


for v in [42, "hi", None, [1]]:
    print(describe(v))

# Output:
# number 42
# text hi
# nothing
# something else

// describe.go
package main

import "fmt"

func describe(value any) string {
	switch v := value.(type) {
	case int:
		return fmt.Sprintf("number %d", v)
	case string:
		return "text " + v
	case nil:
		return "nothing"
	default:
		return "something else"
	}
}

func main() {
	for _, v := range []any{42, "hi", nil, []int{1}} {
		fmt.Println(describe(v))
	}
}

// Output:
// number 42
// text hi
// nothing
// something else

// describe.ts
function describe(value: unknown): string {
  if (typeof value === "number") return `number ${value}`;
  if (typeof value === "string") return `text ${value}`;
  if (value === null || value === undefined) return "nothing";
  return "something else";
}

for (const v of [42, "hi", null, [1]]) {
  console.log(describe(v));
}

// Output:
// number 42
// text hi
// nothing
// something else

isinstance, Go's type switch and typeof all narrow the type: inside each branch, the checker knows the more specific type. One trap is Python-specific: bool is a subclass of int, so isinstance(True, int) is True. If booleans can reach code like this, check for bool first.

Annotations versus runtime validation

Data from outside your program (JSON, form input, environment variables) has whatever shape the sender gave it. Here a client sends the age as a string:

Standalone comparison example. The outputs differ on purpose.

# runtime_check.py
import json
from dataclasses import dataclass


@dataclass
class Person:
    name: str
    age: int


person = Person(**json.loads('{"name": "Ada", "age": "36"}'))
print(repr(person.age))
try:
    print(person.age + 1)
except TypeError as err:
    print("TypeError:", err)

# Output:
# '36'
# TypeError: can only concatenate str (not "int") to str

// runtime_check.go
package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

func main() {
	var p Person
	err := json.Unmarshal([]byte(`{"name": "Ada", "age": "36"}`), &p)
	fmt.Println(err)
}

// Output:
// json: cannot unmarshal string into Go struct field Person.age of type int

// runtime_check.ts
interface Person {
  name: string;
  age: number;
}

const person = JSON.parse('{"name": "Ada", "age": "36"}') as Person;
console.log(typeof person.age);
console.log(person.age + 1);

// Output:
// string
// 361

• The Python dataclass happily stores a string in a field annotated int, and the problem surfaces later as a TypeError.
• Go refuses at the boundary, because encoding/json must put a value of the declared type into the field. Go checks types only, though, not rules such as "age must be positive".
• TypeScript gives the worst result: no error at all, and "36" + 1 quietly becomes the string "361". The as Person assertion promised something nobody checked.

The fix in Python and TypeScript is a runtime validation library. My projects use Pydantic in the Python services (MOKS and the jithendar.com executor) and Zod in the jithendar.com website; you will see a real Zod schema in the project section. In Go, you decode into a struct and then validate the rules yourself, or use a third-party validation package.

Python None, Go nil and zero values, JavaScript null and undefined

Go's approach is the least familiar, so here it is on its own. Every Go variable starts with a zero value: 0 for numbers, "" for strings, false for booleans, and nil for pointers, slices, maps, channels, functions and interfaces.

Standalone comparison example. Go only.

// zero_values.go
package main

import "fmt"

type User struct{ Name string }

func main() {
	var count int
	var name string
	var ready bool
	var tags []string
	var owner *User

	fmt.Println(count, name == "", ready)
	fmt.Println(tags == nil, len(tags), owner == nil)

	tags = append(tags, "go") // appending to a nil slice works
	fmt.Println(tags)
}

// Output:
// 0 true false
// true 0 true
// [go]

Zero values mean you rarely see "uninitialized variable" bugs, and many types are usable without setup (a nil slice can be appended to and has length 0). The costs: you can't tell "not set" from "set to zero" without an extra boolean or a pointer, and two things do fail at runtime. Writing to a nil map panics, and so does reading a field through a nil pointer.

Python has only None. JavaScript has undefined (a missing property, a variable with no value) and null (an explicit "no value"). With strict enabled, TypeScript makes you handle both: a value of type string | undefined can't be used as a string until you check it.

Classes, dataclasses, structs and interfaces

Important behavioral differences

These are the differences that cause bugs when you switch languages, because the code looks right.

Indentation versus braces

Python uses indentation to mark blocks: the body of an if is the indented lines beneath it, and inconsistent indentation is a syntax error. Go and TypeScript use braces, so indentation is just for people. Go removes the debate entirely: gofmt defines one standard layout, using tabs, and almost all Go code is formatted with it. TypeScript projects usually pick a formatter such as Prettier, and Python projects often use Black or Ruff's formatter. Neither of those is part of the language.

Go also inserts semicolons automatically at the end of certain lines, which is why the opening brace must be on the same line as if or func. Putting it on the next line is a compile error.

Truthiness: Go conditions require booleans

Truthiness is the rule that decides whether a non-boolean value counts as true in a condition.

Standalone comparison example. The outputs differ on purpose.

# truthiness.py
items: list[str] = []
print("empty" if not items else "has items")
print(bool(""), bool("0"), bool(0), bool([]))
print(isinstance(True, int), True + True)

# Output:
# empty
# False True False False
# True 2

// truthiness.go
package main

import "fmt"

func main() {
	items := []string{}
	// if items { ... } does not compile: non-boolean condition in if statement
	if len(items) == 0 {
		fmt.Println("empty")
	}
}

// Output:
// empty

// truthiness.ts
const items: string[] = [];
console.log(items ? "has items" : "empty");
console.log(items.length === 0 ? "empty" : "has items");
console.log(Boolean(""), Boolean("0"), Boolean(0), Boolean([]));

// Output:
// has items
// empty
// false true false true

In Python, empty collections, 0, "" and None are falsy. In JavaScript, 0, "", null, undefined and NaN are falsy, but an empty array and an empty object are truthy. That's why items ? ... says "has items" for an empty array. Go has no truthiness at all: a condition must be a bool, so you write what you mean.

Common mistake when switching: Python developers writing if (items) in TypeScript to test for an empty list. It's always true. Test items.length === 0.

Equality, identity and references

Standalone comparison example. The outputs differ on purpose.

# equality.py
a = [1, 2]
b = [1, 2]
c = a
print(a == b, a is b, a is c)
c.append(3)
print(a)

# Output:
# True False True
# [1, 2, 3]

// equality.go
package main

import (
	"fmt"
	"slices"
)

type Point struct{ X, Y int }

func main() {
	a := []int{1, 2}
	b := []int{1, 2}
	// a == b does not compile: slices can only be compared to nil
	fmt.Println(slices.Equal(a, b))
	fmt.Println(Point{1, 2} == Point{1, 2})

	c := a
	c[0] = 99
	fmt.Println(a)
}

// Output:
// true
// true
// [99 2]

// equality.ts
const a = [1, 2];
const b = [1, 2];
const c = a;
console.log(a === b, JSON.stringify(a) === JSON.stringify(b), a === c);
c.push(3);
console.log(JSON.stringify(a));

// Output:
// false true true
// [1,2,3]

• Python: == compares contents; is asks "is this the same object?". Assigning c = a makes a second name for one list.
• Go: == works on numbers, strings, booleans, pointers, and structs or arrays made of comparable fields. It does not compile for slices, maps or functions; use slices.Equal or maps.Equal.
• JavaScript: === on objects and arrays compares references, so two arrays with the same contents are not equal. There is no built-in deep equality; test libraries provide one (toEqual in Vitest). Always use === rather than ==, which converts types first ("1" == 1 is true).

Python lists, Go slices and JavaScript arrays in functions

You may have read that some language "passes objects by reference". That phrase causes confusion, so here is what actually happens:

• Python and JavaScript pass a reference to the object by value. The function gets its own variable pointing at the same list. Mutating the list (append, push) is visible to the caller; assigning a new list to the parameter is not.
• Go passes everything by value: the function gets a copy of the argument. For a slice, the copied value is a small slice header (a pointer to an underlying array, a length and a capacity). The copy points at the same array, so changing an element is visible to the caller, but changing the length with append is not, because the caller still has its old header.

Standalone comparison example. The outputs differ on purpose.

# passing.py
def add_item(items: list[int]) -> None:
    items.append(4)


def replace(items: list[int]) -> None:
    items = [0]


nums = [1, 2, 3]
add_item(nums)
replace(nums)
print(nums)

# Output:
# [1, 2, 3, 4]

// passing.go
package main

import "fmt"

func setFirst(s []int) {
	s[0] = 99 // writes to the shared underlying array
}

func appendItem(s []int) {
	s = append(s, 4) // updates only this function's copy of the slice header
}

func appendItemReturning(s []int) []int {
	return append(s, 4)
}

func main() {
	nums := []int{1, 2, 3}
	setFirst(nums)
	appendItem(nums)
	fmt.Println(nums, len(nums))

	nums = appendItemReturning(nums)
	fmt.Println(nums, len(nums))
}

// Output:
// [99 2 3] 3
// [99 2 3 4] 4

// passing.ts
function addItem(items: number[]): void {
  items.push(4);
}

function replace(items: number[]): void {
  items = [0];
}

const nums = [1, 2, 3];
addItem(nums);
replace(nums);
console.log(JSON.stringify(nums));

// Output:
// [1,2,3,4]

That's why Go's append returns a slice, and why Go functions that grow a slice return it. A related subtlety: two slices of the same array can affect each other until one of them grows past its capacity and append copies it to a new array. Use slices.Clone when you need an independent copy.

Map and dictionary access with missing keys

Standalone comparison example. Same values; the printed format differs.

# word_count.py
counts: dict[str, int] = {}
for word in "a b a".split():
    counts[word] = counts.get(word, 0) + 1
print(counts)

try:
    counts["z"]
except KeyError as err:
    print("KeyError:", err)

# Output:
# {'a': 2, 'b': 1}
# KeyError: 'z'

// word_count.go
package main

import (
	"fmt"
	"strings"
)

func main() {
	counts := map[string]int{}
	for _, word := range strings.Fields("a b a") {
		counts[word]++ // a missing key reads as 0
	}
	fmt.Println(counts, counts["z"])

	var missing map[string]int // nil map: reading works, writing would panic
	fmt.Println(missing["z"], len(missing))
}

// Output:
// map[a:2 b:1] 0
// 0 0

// word_count.ts
const counts: Record<string, number> = {};
for (const word of "a b a".split(" ")) {
  counts[word] = (counts[word] ?? 0) + 1;
}
console.log(JSON.stringify(counts), counts["z"]);

// Output:
// {"a":2,"b":1} undefined

Python raises KeyError for a missing key with []; use .get(), in, or collections.defaultdict / Counter. Go returns the zero value, which makes counting a one-liner. JavaScript returns undefined, and undefined + 1 is NaN, hence the ?? 0. With the compiler option noUncheckedIndexedAccess, TypeScript makes counts[word] have type number | undefined, which forces you to handle the missing case.

Mutable default arguments in Python

This one is Python-only, but it surprises everyone coming from TypeScript.

Standalone comparison example. The outputs differ on purpose.

# mutable_default.py
def add_tag(tag: str, tags: list[str] = []) -> list[str]:
    tags.append(tag)
    return tags


def add_tag_fixed(tag: str, tags: list[str] | None = None) -> list[str]:
    if tags is None:
        tags = []
    tags.append(tag)
    return tags


print(add_tag("a"))
print(add_tag("b"))
print(add_tag_fixed("a"))
print(add_tag_fixed("b"))

# Output:
# ['a']
# ['a', 'b']
# ['a']
# ['b']

// mutable_default.ts
function addTag(tag: string, tags: string[] = []): string[] {
  tags.push(tag);
  return tags;
}

console.log(JSON.stringify(addTag("a")));
console.log(JSON.stringify(addTag("b")));

// Output:
// ["a"]
// ["b"]

Python evaluates = [] once, when def runs, so every call that uses the default shares one list. JavaScript evaluates default values on every call. The Python fix is the None sentinel shown in add_tag_fixed. Go has no default arguments, so the problem can't occur there.

Integer arithmetic, division, overflow and precision

Standalone comparison example. The outputs differ on purpose.

# arithmetic.py
print(-7 // 2, -7 % 2, int(-7 / 2))
print(2 ** 64)
print(0.1 + 0.2)

# Output:
# -4 1 -3
# 18446744073709551616
# 0.30000000000000004

// arithmetic.go
package main

import "fmt"

func main() {
	fmt.Println(-7/2, -7%2)

	var small int8 = 127
	small++
	fmt.Println(small)

	var big uint64 = 1 << 63
	fmt.Println(big * 2)

	a, b := 0.1, 0.2
	fmt.Println(a + b)
}

// Output:
// -3 -1
// -128
// 0
// 0.30000000000000004

// arithmetic.ts
console.log(Math.floor(-7 / 2), -7 % 2, Math.trunc(-7 / 2));
console.log(2 ** 64, 2n ** 64n);
console.log(2 ** 53 + 1 === 2 ** 53);
console.log(0.1 + 0.2);

// Output:
// -4 -1 -3
// 18446744073709552000 18446744073709551616n
// true
// 0.30000000000000004

• Integer size. Python's int has arbitrary precision: it grows as large as memory allows. Go has fixed-size types (int8 to int64, unsigned uint8 to uint64, and int, which is 64 bits on common 64-bit platforms). Go integer overflow at runtime wraps around silently, as small++ shows; overflow in a constant expression is a compile error instead. Use math/big for larger values. JavaScript's number is a 64-bit float, so integers are exact only up to 2⁵³ − 1 (Number.MAX_SAFE_INTEGER). BigInt (the n suffix) gives arbitrary-size integers, but you can't mix it with number in arithmetic.
• Negative division. Python's // rounds toward negative infinity and its % takes the sign of the divisor. Go and JavaScript truncate toward zero, and their % takes the sign of the dividend.
• Floating point. All three use IEEE 754 64-bit floats, so 0.1 + 0.2 is not exactly 0.3. For money, use integer cents or a decimal type: Python's decimal.Decimal, a decimal package in Go, or integer cents in JavaScript. RoboShop's Python gateway uses Decimal for checkout conversion, as the project section shows.

One Go oddity: fmt.Println(0.1 + 0.2) with literal constants prints 0.3, because Go evaluates constant expressions exactly before converting to float64. The variables in the example show normal float behavior.

Unicode and string indexing

A string is text, but each language stores and counts it differently. The example string has an accented letter and an emoji.

Standalone comparison example. The outputs differ on purpose.

# unicode_demo.py
s = "héllo😀"
print(len(s), s[1], s[-1])
print(len(s.encode("utf-8")))

# Output:
# 6 é 😀
# 10

// unicode.go
package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "héllo😀"
	fmt.Println(len(s), utf8.RuneCountInString(s))
	fmt.Println(s[1], string([]rune(s)[1]))
	for i, r := range "hé" {
		fmt.Println(i, string(r))
	}
}

// Output:
// 10 6
// 195 é
// 0 h
// 1 é

// unicode.ts
const s = "héllo😀";
console.log(s.length, [...s].length, s[1]);
console.log(new TextEncoder().encode(s).length);
console.log(s.slice(-1) === "😀", s.slice(-2) === "😀");

// Output:
// 7 6 é
// 10
// false true

• Python strings are sequences of Unicode code points, so len is 6 and indexing returns characters.
• Go strings are read-only byte sequences, usually UTF-8. len counts bytes (10), and s[1] is a single byte (195, the first byte of é). A rune is Go's name for a Unicode code point; range over a string walks runes and gives the byte offset of each.
• JavaScript strings are UTF-16 code units. Most characters take one unit, but the emoji takes two (a surrogate pair), so length is 7 and slicing can cut a character in half. Spreading [...s] iterates by code point.

What a user sees as one character can still be several code points (a flag emoji, or e plus a combining accent), in all three languages. For user-facing text operations, use a library or API that understands grapheme clusters, such as Intl.Segmenter in JavaScript.

Go pointers, briefly

A pointer holds the memory address of a value. &x takes the address of x, and *p reads or writes the value that p points to. Python and JavaScript have no pointers you can see; objects are always accessed through references, and numbers and strings are immutable.

Standalone comparison example. Go only.

// pointers.go
package main

import "fmt"

type Counter struct{ N int }

// Value receiver: the method gets a copy of the Counter.
func (c Counter) IncrementCopy() { c.N++ }

// Pointer receiver: the method can change the caller's Counter.
func (c *Counter) Increment() { c.N++ }

func double(n *int) { *n *= 2 }

func main() {
	c := Counter{}
	c.IncrementCopy()
	fmt.Println(c.N)
	c.Increment()
	fmt.Println(c.N)

	x := 21
	double(&x)
	fmt.Println(x)
}

// Output:
// 0
// 1
// 42