print_hej/README.md

Pi-beräkningsbenchmark 🥧

Vad är detta? 🤔

Detta är ett prestandatest som jämför hur snabbt olika programmeringsspråk kan beräkna talet π (pi) med många decimaler.

Pi (π) är ett matematiskt konstant som börjar med 3.14159... och fortsätter i evighet utan att upprepa sig. Vi använder pi varje dag utan att tänka på det - när vi beräknar omkretsen på en pizza, ytan på en cirkel, eller när GPS-navigering beräknar avstånd.

Varför göra detta? 🎯

1. Lära oss om programmeringsspråk - Olika språk fungerar på olika sätt
2. Förstå prestandaskillnader - Varför är vissa språk snabbare än andra?
3. Ha kul! - Det är fascinerande att se hur 34 olika språk löser samma problem

Hur fungerar testet? ⚙️

Metoden: Machins formel

Vi använder en 300 år gammal matematisk formel som upptäcktes av John Machin år 1706:

π/4 = 4 × arctan(1/5) - arctan(1/239)

På enkel svenska:

• Vi beräknar två "arctan"-värden (en matematisk funktion)
• Kombinerar dem med multiplikation och subtraktion
• Resultatet är π med hög precision

Varför denna metod? ✅

• Snabb - Konvergerar snabbt (behöver få iterationer)
• Noggrann - Kan beräkna miljontals decimaler
• Enkel - Kan implementeras i alla programmeringsspråk

Testproceduren 📋

För varje språk:

1. Bygg programmet (om det behöver kompileras)
2. Kör programmet med olika antal decimaler: 1, 2, 5, 10, 100, 1000, 10000
3. Jämför resultatet med det korrekta värdet av π
4. Mät hur lång tid det tar

Varför så stor skillnad i tid? ⏱️

Här är de huvudsakliga orsakerna till varför vissa språk är snabbare än andra:

1. Kompilerade vs Tolkade språk 🏃‍♂️

Kompilerade språk (SNABBA):

• C, C++, Rust, Go, Swift - Översätts till maskinkod EN gång, körs direkt av processorn
• Analogi: Som att ha en färdigöversatt bok - du kan läsa den direkt

Tolkade språk (LÅNGSAMMA):

• Python, Ruby, JavaScript - En "tolk" läser och kör koden rad för rad varje gång
• Analogi: Som att ha en tolk som översätter boken medan du läser

Skillnad: Kompilerade språk kan vara 10-100 gånger snabbare!

2. Hur språket hanterar stora tal 🔢

För att beräkna π med 10,000 decimaler måste vi hantera väldigt stora tal:

• Effektiva språk: Har inbyggt stöd för stora tal (C med GMP, Python med integers)
• Mindre effektiva: Måste implementera stora tal själva (JavaScript, Lua)

Skillnad: Kan göra språket 1000 gånger långsammare om det inte stöder stora tal!

3. Minnesanvändning och optimering 💾

• C, C++, Rust: Direkt åtkomst till minne, ingen "sophämtning"
• Java, C#: Automatisk sophämtning (garbage collection) som tar tid
• Python, Ruby: Flexibla objekt som kräver mer minne

4. JIT-kompilering (Just-In-Time) ⚡

Vissa språk kombinerar tolkning och kompilering:

• Java, C#, JavaScript (Node.js):
  • Startar som tolkade
  • Kompilerar "heta" koddelar automatiskt
  • Kan närma sig kompilerade språks hastighet

Språk-för-språk guide 📚

🚀 Supersnabba språk (Kompilerade, optimerade)

C ⚡⚡⚡

• Typ: Kompilerat, låg-nivå
• Prestanda: En av de snabbaste
• Varför: Direkt maskinkod, ingen overhead, manuellt minneshantering
• Analogi: Som att köra en Formel 1-bil - maximal prestanda, men du måste vara expertförare

C++ ⚡⚡⚡

• Typ: Kompilerat, objektorienterat
• Prestanda: Nästan lika snabbt som C
• Varför: Samma som C, men med moderna funktioner
• Analogi: Som en sportbil med automatväxel - snabb men enklare att köra

Rust ⚡⚡⚡

• Typ: Kompilerat, minnessäkert
• Prestanda: Jämförbar med C/C++
• Varför: Nollkostnadsabstraktioner, ingen sophämtning
• Analogi: Som en säker sportbil - snabb men med airbags och antiblockeringssystem

Go ⚡⚡

• Typ: Kompilerat, modernt
• Prestanda: Snabb, men med sophämtning
• Varför: Effektiv kompilator, bra standardbibliotek
• Analogi: Som en modern familjebils - snabb nog, men säker och bekväm

Swift ⚡⚡

• Typ: Kompilerat, modernt (från Apple)
• Prestanda: Snabb, optimerad för moderna processorer
• Varför: Avancerad kompilator, bra optimeringar
• Analogi: Som en iPhone - snabb, modern, användarvänlig

🏃 Snabba språk (JIT-kompilerade eller effektiva)

Java ⚡⚡

• Typ: JIT-kompilerat (Java Virtual Machine)
• Prestanda: Snabb efter uppvärmning
• Varför: JIT-kompilator optimerar koden under körning
• Analogi: Som en bil som blir snabbare ju mer du kör den

C# ⚡⚡

• Typ: JIT-kompilerat (.NET)
• Prestanda: Liknande Java
• Varför: Modern JIT-kompilator, bra optimeringar
• Analogi: Som Java men från Microsoft

Julia ⚡⚡

• Typ: JIT-kompilerat, vetenskapligt
• Prestanda: Mycket snabb för numerisk beräkning
• Varför: Designat för matematik, JIT optimerar bra
• Analogi: Som en miniräknare på steroider

Kotlin ⚡

• Typ: Kompilerat till Java bytecode
• Prestanda: Liknande Java
• Varför: Kör på samma JVM som Java
• Analogi: Som Java men med modernare syntax

🐢 Långsammare språk (Tolkade, men praktiska)

Python 🐢

• Typ: Tolkat, dynamiskt typat
• Prestanda: Långsamt, men har snabba bibliotek
• Varför: Tolkas rad för rad, dynamiska typer
• Analogi: Som att prata med en mycket hjälpsam assistent - långsamt men enkelt

Ruby 🐢

• Typ: Tolkat, objektorienterat
• Prestanda: Liknande Python
• Varför: Tolkas, flexibla objekt
• Analogi: Som Python men mer fokuserat på programmerarens glädje

JavaScript (Node.js) 🐢

• Typ: JIT-kompilerat i V8-motorn
• Prestanda: Överraskande snabbt för att vara tolkat
• Varför: V8-motorn optimerar aggressivt
• Analogi: Som en webbläsare som också kan köra program

PHP 🐢

• Typ: Tolkat, webb-fokuserat
• Prestanda: Måttligt snabbt
• Varför: Tolkas, designat för webben
• Analogi: Som en specialbyggd webbserver

🐌 Mycket långsamma språk (Speciella fall)

Bash 🐌

• Typ: Skalskript, kommandorad
• Prestanda: Mycket långsamt
• Varför: Startar nya program för varje operation
• Analogi: Som att be någon annan göra varje liten sak åt dig

Brainfuck 🐌🐌

• Typ: Esoteriskt, minimalt
• Prestanda: Extremt långsamt
• Varför: Endast 8 instruktioner, ingen optimering
• Analogi: Som att kommunicera med blinkningar - möjligt men smärtsamt

Lua 🐢

• Typ: Tolkat, inbäddningsbart
• Prestanda: Snabb för att vara tolkat
• Varför: Lättvikt tolk, enkel design
• Analogi: Som en liten, snabb motorcykel

Perl 🐢

• Typ: Tolkat, skript-språk
• Prestanda: Måttligt snabbt
• Varför: Tolkas, kraftfull textbehandling
• Analogi: Som en schweizisk armékniv - kan göra allt

R 🐢

• Typ: Tolkat, statistik-fokuserat
• Prestanda: Måttligt snabbt
• Varför: Optimerat för statistik, inte ren beräkning
• Analogi: Som en grafritande miniräknare

🔬 Specialiserade språk

Haskell ⚡

• Typ: Funktionellt, kompilerat
• Prestanda: Snabbt med optimeringar
• Varför: Kompilerar till effektiv kod
• Analogi: Som att lösa matteproblem med algebra istället för att räkna

Erlang 🏃

• Typ: Funktionellt, samtidighets-fokuserat
• Prestanda: Måttligt snabbt
• Varför: Optimerat för många samtidiga processer
• Analogi: Som en telefonväxel - hanterar många samtal samtidigt

Elixir 🏃

• Typ: Funktionellt, körs på Erlang VM
• Prestanda: Liknande Erlang
• Varför: Modern syntax på Erlangs plattform
• Analogi: Som Erlang men med modernare gränssnitt

Scala ⚡

• Typ: Hybrid funktionellt/objektorienterat, på JVM
• Prestanda: Liknande Java
• Varför: Kompilerar till Java bytecode
• Analogi: Som Java på steroider med funktionella superkrafter

Crystal ⚡⚡

• Typ: Kompilerat, Ruby-lik syntax
• Prestanda: Snabbt som C
• Varför: Kompilerar till effektiv maskinkod
• Analogi: Som Ruby men med en turbomotor

Nim ⚡⚡

• Typ: Kompilerat, Python-lik syntax
• Prestanda: Snabbt som C
• Varför: Kompilerar till C-kod
• Analogi: Som Python men kompilerat

Zig ⚡⚡

• Typ: Kompilerat, modernt system-språk
• Prestanda: Snabbt som C
• Varför: Ingen hidden control flow, direkt kompilering
• Analogi: Som C men säkrare och modernare

Odin ⚡⚡

• Typ: Kompilerat, system-språk
• Prestanda: Snabbt
• Varför: Designat för prestanda och enkelhet
• Analogi: Som Go men med C-prestanda

D ⚡⚡

• Typ: Kompilerat, C-liknande
• Prestanda: Snabbt
• Varför: Kompilerar till effektiv maskinkod
• Analogi: Som C men med moderna funktioner

Fortran ⚡⚡

• Typ: Kompilerat, vetenskapligt
• Prestanda: Mycket snabbt för numerisk beräkning
• Varför: Optimerat för matematik i 60+ år
• Analogi: Som en räknare byggd för vetenskap

Objective-C ⚡⚡

• Typ: Kompilerat, objektorienterat
• Prestanda: Snabbt
• Varför: Kompilerar till maskinkod
• Analogi: Som C med objektorientering

Assembly ⚡⚡⚡

• Typ: Låg-nivå, direkt maskinkod
• Prestanda: Snabbast möjligt (om skrivet rätt)
• Varför: Direkt kontroll över processorn
• Analogi: Som att programmera processorn direkt - maximal kontroll

🆕 Nya/Speciella språk

TypeScript 🏃

• Typ: Kompilerat till JavaScript
• Prestanda: Liknande JavaScript
• Varför: Kompilerar till JS, körs i Node.js
• Analogi: Som JavaScript med typer

Dart ⚡

• Typ: Kompilerat eller JIT
• Prestanda: Snabbt med JIT
• Varför: Designat för moderna appar
• Analogi: Som JavaScript men designat för appar

Vimscript 🐌

• Typ: Tolkat i Vim
• Prestanda: Mycket långsamt
• Varför: Designat för textredigering, inte beräkning
• Begränsning: Endast 15 decimalers precision (flyttals-gräns)
• Analogi: Som att använda en texteditor för att räkna matte

Wolfram Language 🔬

• Typ: Tolkat, matematiskt
• Prestanda: Snabbt för matematik
• Varför: Inbyggd matematisk motor
• Analogi: Som att ha en matematikprofessor inbyggd

Resultat-exempel 📊

Här är typiska körtider för 10,000 decimaler:

Språk	Tid	Kategori
C	~50ms	Supersnabb
C++	~50ms	Supersnabb
Rust	~50ms	Supersnabb
Go	~100ms	Snabb
Java	~200ms	Snabb
Julia	~150ms	Snabb
Python	~2000ms	Måttlig
Ruby	~3000ms	Måttlig
JavaScript	~1500ms	Måttlig
Bash	~30000ms	Långsam
Brainfuck	~60000ms+	Mycket långsam

Skillnad: Snabbaste vs långsammaste = 1000x skillnad!

Hur man kör testerna 🚀

Bygga alla språk:

./build.sh

Köra tester:

# Testa alla språk
./test.sh

# Testa ett specifikt språk
./test.sh python
./test.sh rust

Köra prestandatest:

# Testa med 100 decimaler
./run_all.sh 100

# Testa med 10000 decimaler
./run_all.sh 10000

Varför är skillnaden så stor? 🤯

Sammanfattningsvis:

1. Kompilerade språk (C, C++, Rust) = 100-1000x snabbare än tolkade
2. JIT-kompilerade (Java, C#) = 10-100x snabbare än tolkade
3. Tolkade språk (Python, Ruby) = Baslinjen
4. Specialfall (Bash, Brainfuck) = 100-1000x långsammare än baslinjen

Den verkliga skillnaden:

För 10,000 decimaler:

• C/Rust: ~50 millisekunder (en ögonblinkning)
• Python: ~2 sekunder (tid att säga "en två tre")
• Bash: ~30 sekunder (tid att dricka en kaffe)
• Brainfuck: ~60+ sekunder (tid att undra varför du gör detta)

Slutsats 🎓

Vilket språk ska du välja?

• Maximal prestanda: C, C++, Rust, Zig
• Balans mellan prestanda och enkelhet: Go, Swift, Kotlin
• Snabb utveckling: Python, Ruby, JavaScript
• Matematik/Vetenskap: Julia, Python (med NumPy), R
• Lära sig: Python, Ruby, JavaScript

Kom ihåg: Det snabbaste språket är inte alltid det bästa valet. Ofta är utvecklingstid viktigare än körtid!

---

Tekniska detaljer för nyfikna 🔧

Machins formel i detalj:

π/4 = 4 × arctan(1/5) - arctan(1/239)

Där arctan(x) beräknas med Taylor-serien:

arctan(x) = x - x³/3 + x⁵/5 - x⁷/7 + ...

Varför denna formel?

1. Snabb konvergens: Behöver få termer för hög precision
2. Enkel implementation: Bara division och multiplikation
3. Hög noggrannhet: Kan beräkna miljontals decimaler

Implementation i alla språk:

Alla språk använder samma algoritm:

1. Beräkna arctan(1/5) med Taylor-serien
2. Beräkna arctan(1/239) med Taylor-serien
3. Kombinera: π = 16 × arctan(1/5) - 4 × arctan(1/239)

Detta garanterar att vi jämför språkens prestanda, inte olika algoritmer!

---

Skapad med ❤️ för programmeringsentusiaster överallt!