Home

01 Modern Development Tools: Implementation Skills for Modern Software Development

October 2025 (6802 Words, 38 Minutes)

lecture python uv implementation modern-development best-practices

I Love Programming

12. From Scripts to Professional Software: The Modern Implementation Journey

Welcome to Part 2 of our first lecture! Now that you’ve established your development environment with Git, GitHub, VS Code, and Copilot, it’s time to dive into the heart of software engineering: implementation.

Writing code is exciting—it’s where ideas transform into reality. But there’s a vast difference between writing a script that works on your laptop and building professional software that scales, maintains quality, and collaborates well with teams. This lecture will show you that journey.

12.1 What You’ll Learn

In this part of the course, we’ll explore:

This is a teaser for the journey ahead. Throughout this course, we’ll take a hands-on, example-driven approach, starting with simple scripts and evolving them into a fully professional Python project using 2025’s best practices.

13. Why Python? The Inevitable Choice for Modern Developers

If you’re going to learn one programming language deeply in 2025, Python should be it. This isn’t subjective preference—it’s backed by overwhelming evidence from industry and academia.

13.1 Python’s Dominance: The Numbers Don’t Lie

Let’s look at the quantitative evidence:

13.1.1 Industry Adoption

GitHub Statistics (2024-2025):

Stack Overflow Developer Survey 2024:

TIOBE Index (October 2025):

13.1.2 Academic Dominance

Research and Education:

Scientific Computing:

13.2 Why Python Wins: Technical and Practical Reasons

The numbers tell us that Python dominates, but why does it dominate?

13.2.1 Readability and Productivity

Python’s syntax is as close to pseudocode as you can get:

# Python - reads like English
def calculate_average(numbers):
    """Calculate the average of a list of numbers."""
    return sum(numbers) / len(numbers)

students = [85, 92, 78, 90, 88]
average = calculate_average(students)
print(f"Average grade: {average}")

Compare this to equivalent code in other languages—Python wins on clarity and development speed.

13.2.2 Versatility: One Language, Every Domain

Python isn’t just for one thing—it’s for everything:

Career Impact: Learn Python once, work in any domain.

13.2.3 Ecosystem: Batteries Included and Beyond

Standard Library: Python comes with 200+ built-in modules for common tasks—file I/O, networking, data structures, concurrency, and more.

PyPI (Python Package Index):

Example: Need to work with dates, send HTTP requests, process JSON, and create a GUI?

# All built-in or one command away
uv add requests  # That's it for HTTP
# datetime, json, tkinter - already included

13.2.4 Community and Support

When you’re stuck, there’s always help available.

13.2.5 Industry Demand and Career Growth

Job Market (2025):

Companies Using Python:

13.3 The AI and Machine Learning Revolution

We’re living through an AI revolution, and Python is the language of AI:

If you want to work with cutting-edge AI (and you should—it’s transforming every industry), Python isn’t optional.

13.4 Python for Academic Success

In academic contexts, Python offers unique advantages:

Research Reproducibility:

Rapid Prototyping:

Collaboration:

13.5 The Bottom Line

Python is inevitable for modern developers because:

  1. ✅ Ubiquitous: Used everywhere, from startups to NASA
  2. ✅ Productive: Write less code, accomplish more
  3. ✅ Versatile: One language for web, data, AI, automation
  4. ✅ In-demand: Top salary, most job openings
  5. ✅ Future-proof: Leading AI/ML language, constantly evolving
  6. ✅ Beginner-friendly: Learn programming concepts, not syntax quirks
  7. ✅ Professional-grade: Scales from scripts to enterprise systems

Whether you’re building a research prototype, a startup MVP, or enterprise software, Python is the right choice.

14. The Journey Ahead: From Scripts to Professional Projects

Throughout this course, we’ll take you on a practical, hands-on journey. We’ll start with something you might already be familiar with—simple Python scripts—and evolve it step-by-step into a fully professional project using 2025’s best practices.

15. From Script to Production — The Professional Gap

15.1 The Two Pythons

Script Python (What tutorials teach):

# analysis.py
import pandas as pd

data = pd.read_csv("data.csv")
result = data.describe()
print(result)

python analysis.py  # Works... for now

Production Python (What companies need):

Same functionality, professional structure:

# src/analytics/__init__.py
"""Analytics package for data processing."""
__version__ = "1.2.3"

# src/analytics/pipeline.py
import pandas as pd
from pathlib import Path

def analyze_data(file_path: Path) -> pd.DataFrame:
    """Analyze data from CSV file and return statistics.
    
    Args:
        file_path: Path to CSV file
        
    Returns:
        DataFrame with statistical summary
    """
    data = pd.read_csv(file_path)
    return data.describe()

# src/analytics/cli.py
import typer
from pathlib import Path
from analytics.pipeline import analyze_data

app = typer.Typer()

@app.command()
def analyze(file: Path) -> None:
    """Analyze data from CSV file."""
    result = analyze_data(file)
    print(result)

if __name__ == "__main__":
    app()

# Modern uv workflow - proper packaging
uv tool install analytics-platform
analytics-cli analyze data.csv

# Or run directly without installing
uv run analytics-cli analyze data.csv

15.2 What Changes at Scale?

15.2.1 Multiple People, Multiple Months

15.2.2 Code Lives Beyond Your Laptop

15.2.3 Quality Matters

15.2.4 Collaboration at Scale

15.3 Your First Professional Python Project: Road Profile Viewer

Time to get hands-on! Instead of building from scratch, we’ll start with real, working code and transform it step-by-step into a professional Python project.

15.3.1 Step 1: Download the Starting Code

For course students:

  1. Go to Canvas: Visit the course page
  2. Download: Get the file road-profile-viewer.7z
  3. Extract: Unzip the archive to see the code structure

For external users without Canvas access:

  1. Go to GitHub: Visit the Road Profile Viewer v1.0.0 release
  2. Download: Get the source code archive (zip or tar.gz)
  3. Extract: Unzip the archive to see the code structure

What you’ll find:

This is Script Python - the kind of code tutorials teach. Our mission: transform it into Production Python.

📦 “Wait, didn’t we just say Git is better than zipped files?”

Yes! And you’re right to notice. Normally, you’d clone a repository directly from GitHub. But for this first exercise, we’re deliberately having you:

  1. Start with a zip file (the “old way”)
  2. Initialize Git yourself
  3. Create your own GitHub repository
  4. Connect and push

Why? Because doing it once yourself teaches you how repositories are born. After this, you’ll always clone existing repos—but you’ll understand what’s happening under the hood. Think of it as learning to ride a bike with training wheels before joining the Tour de France! 🚴

15.3.2 Step 2: Set Up Your Local Environment

Open your terminal and create your project workspace:

# Create a dedicated folder for your project
mkdir road-profile-viewer
cd road-profile-viewer

# Copy the extracted files here
# (Use your file manager or copy commands)

15.3.3 Step 3: Customize the Project Configuration

Before we commit the code, let’s make it yours! Open the pyproject.toml file in VS Code:

# Open the project in VS Code
code .

Edit pyproject.toml:

  1. Find the authors section (around line 6)
  2. Replace L3GJ0N with your GitHub username
  3. Replace the email with your own email address

Example change:

# Before (what you downloaded):
authors = [{name = "L3GJ0N", email = "dominik.rother@hs-aalen.de"}]

# After (your version):
authors = [{name = "YOUR_GITHUB_USERNAME", email = "your.email@example.com"}]

💾 Save the file (Ctrl+S or Cmd+S)

Why this matters: This makes you the official author of your version of the project. When you publish packages or contribute to open source, proper attribution is crucial!

15.3.4 Step 4: Initialize Git Repository

Now let’s turn this code into a proper Git repository:

# Initialize Git in your project folder
git init

# Add all files to staging
git add .

# Create your initial commit
# IMPORTANT: Use this exact message so everyone starts the same
git commit -m "Initial commit: Road profile viewer scripts"

# Check your status
git status

🎯 Checkpoint: You now have a local Git repository with your first commit!

15.3.5 Step 5: Create GitHub Repository

  1. Go to GitHub: Visit github.com and sign in
  2. Create New Repository:
    • Click the ”+” button → “New repository”
    • Repository name: road-profile-viewer
    • Description: Python tool for visualizing road elevation profiles
    • Visibility: Public (so you can showcase your work!)
    • ⚠️ Important: Do NOT initialize with README, .gitignore, or license
  3. Click “Create repository”

15.3.6 Step 6: Connect Local to GitHub

GitHub will show you instructions, but here’s exactly what to do:

# Add your GitHub repository as remote origin
git remote add origin https://github.com/YOUR_USERNAME/road-profile-viewer.git

# Push your code to GitHub
git branch -M main
git push -u origin main

Replace YOUR_USERNAME with your actual GitHub username!

15.3.7 Step 7: Verify Everything Works

  1. Refresh your GitHub repository page - you should see your code!
  2. Check the commit message - it should say “Initial commit: Road profile viewer scripts”
  3. Explore the files - click around to see your code on GitHub

🎉 Success! You now have:

16. Running Your First Modern Python Application

Now let’s see your code in action! We’ll use uv - the modern Python tooling that makes running projects effortless.

16.1 Step 1: Install uv

Choose your operating system:

Windows (PowerShell):

Open PowerShell and run:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

⚠️ Important for Windows: After installation, close and reopen your PowerShell/terminal window for the PATH changes to take effect.

Ubuntu/Linux:

Open your terminal and run:

curl -LsSf https://astral.sh/uv/install.sh | sh

⚠️ Important for Linux: After installation, either restart your terminal or run:

source $HOME/.cargo/env

Verify Installation:

uv --version

You should see something like uv 0.5.x or higher.

16.2 Step 2: Run the Road Profile Viewer

Navigate to your project folder and start the application:

# Make sure you're in the project directory
cd src/road-profile-viewer

# Run the main application
uv run main.py

Hint: The run command needs the path to your python files as an input. Thus main.py here is used as ./main.py.

That’s it! uv will automatically:

16.3 Step 3: View Your Application

After a few seconds, you’ll see output in your terminal. The application will start a web server.

Open your browser and navigate to:

http://127.0.0.1:8050

🎊 You should see the Road Profile Viewer dashboard!

If everything worked correctly, you should see the interactive Road Profile Viewer dashboard in your browser:

Road Profile Viewer Dashboard Figure 1: The Road Profile Viewer - Our first Python application running locally

Try interacting with the visualization - you’re now running a real Python web application!

16.4 What Just Happened?

With a single command (uv run main.py), you:

This is the modern Python workflow - no manual virtual environment creation, no dependency installation headaches, no “it works on my machine” problems.

16.5 Stopping the Application

To stop the server:

17. Understanding What Just Happened: Python Environments Demystified

You just ran uv run main.py and magically everything worked. But what actually happened behind the scenes? Understanding this is crucial for professional Python development.

17.1 The Magic Command: uv run main.py

When you executed uv run main.py, uv performed several sophisticated operations automatically:

  1. ✅ Read pyproject.toml to understand project requirements
  2. ✅ Created an isolated virtual environment
  3. ✅ Installed all dependencies (Dash, Plotly, Pandas, etc.)
  4. ✅ Executed your Python script in that isolated environment

Let’s unpack each of these steps to understand what’s really happening.

17.2 What is a Python Virtual Environment?

17.2.1 The Problem: Dependency Chaos

Imagine you’re working on three different Python projects:

Without virtual environments, you face the “dependency hell”:

# Install pandas for Project A
pip install pandas==1.5.0

# Now switch to Project B
pip install pandas==2.1.0  # ⚠️ Overwrites 1.5.0!

# Go back to Project A
python projectA.py  # ❌ CRASHES! Wrong pandas version

17.2.2 The Solution: Isolated Environments

A virtual environment is like a separate Python installation for each project. It creates an isolated space where your project’s dependencies live independently from:

Think of it like apartments in a building:

17.2.3 What’s Actually Inside a Virtual Environment?

A virtual environment is just a directory structure containing:

.venv/                          # Virtual environment folder
├── bin/ (or Scripts/ on Windows)
│   ├── python                  # Python executable (copy or symlink)
│   ├── pip                     # Package installer for this env
│   └── activate                # Script to "enter" this environment
├── lib/
│   └── python3.12/
│       └── site-packages/      # WHERE YOUR PACKAGES LIVE
│           ├── pandas/         # Installed here, not globally!
│           ├── dash/
│           ├── plotly/
│           └── ...
└── pyvenv.cfg                  # Configuration file

Key insight: When you install packages in a virtual environment, they go into that environment’s site-packages/ folder, not your system’s global Python.

17.2.4 How Python Finds Packages

When you run Python, it searches for packages in this order:

  1. Current directory (where you run the script)
  2. Virtual environment’s site-packages/ (if active)
  3. System Python’s site-packages/ (global installation)
  4. Standard library (built-in modules)

Virtual environments work by putting their site-packages/ first in the search path, so their packages are found before global ones.

17.3 The Old Way: Manual Virtual Environments

Before uv, this is what you had to do every single time:

# Step 1: Create virtual environment (slow!)
python -m venv .venv            # Creates .venv/ folder

# Step 2: Activate it (OS-specific commands!)
# Windows:
.venv\Scripts\activate
# Mac/Linux:
source .venv/bin/activate

# Step 3: Upgrade pip (because it's always outdated)
pip install --upgrade pip

# Step 4: Install dependencies (one by one or from requirements.txt)
pip install dash plotly pandas numpy

# Step 5: Finally run your code
python main.py

# Step 6: Remember to deactivate when done
deactivate

Problems with this workflow:

17.4 The New Way: uv Does It All

With uv, all those steps collapse into one command:

uv run main.py  # That's it. Seriously.

What uv does automatically:

# Behind the scenes (you don't see this):
[1] Read pyproject.toml
    ↓
[2] Check if .venv/ exists
    ├─ No? Create it (in milliseconds!)
    └─ Yes? Verify it's correct
    ↓
[3] Lock dependencies (resolve versions)
    ↓
[4] Install only what's missing (cached!)
    ↓
[5] Run your script in the virtual environment

Why this is revolutionary:

✅ Fast: Virtual environment creation in <100ms (not 5-30 seconds)
✅ Automatic: No activation, no manual steps
✅ Reproducible: Exact same versions for everyone
✅ Smart: Only installs what’s missing
✅ Cached: Reuses packages across projects
✅ Safe: Checks dependency compatibility before installing

17.5 Understanding pyproject.toml: Your Project’s Blueprint

The pyproject.toml file is the single source of truth for your Python project. Let’s open it and see what it contains:

# Open your project's pyproject.toml
code pyproject.toml

17.5.1 Anatomy of pyproject.toml

Here’s what you’ll see (with explanations):

[build-system]
# How to build/package your project
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
# Project metadata
name = "road-profile-viewer"
version = "0.1.0"
description = "Python tool for visualizing road elevation profiles"
authors = [{name = "YOUR_USERNAME", email = "your.email@example.com"}]
readme = "README.md"
requires-python = ">=3.10"  # Minimum Python version

# Dependencies: What packages this project needs
dependencies = [
    "dash>=2.14.0",          # Web framework
    "plotly>=5.18.0",        # Interactive visualizations
    "pandas>=2.1.0",         # Data manipulation
    "numpy>=1.24.0",         # Numerical operations
]

[project.optional-dependencies]
# Optional dependencies (e.g., for development)
dev = [
    "pytest>=7.4.0",         # Testing framework
    "ruff>=0.1.0",           # Linter
]

[tool.uv]
# uv-specific settings
dev-dependencies = [
    "pytest>=7.4.0",
]

17.5.2 Why pyproject.toml is Better Than Old Approaches

Old approach: requirements.txt

# requirements.txt - just a list
dash==2.14.0
plotly==5.18.0
pandas==2.1.0
numpy==1.24.0

Problems:

Modern approach: pyproject.toml

17.5.3 Version Specifiers Explained

dependencies = [
    "dash>=2.14.0",      # Any version 2.14.0 or higher
    "plotly~=5.18.0",    # 5.18.x only (patch updates OK)
    "pandas>=2.1,<3.0",  # 2.1+ but not 3.x (major version locked)
    "numpy==1.24.0",     # Exact version (usually too strict!)
]

Best practice: Use >= for most dependencies, let uv resolve compatible versions.

17.6 Why uv is a Game-Changer: The Technical Evolution

Let’s compare the tools to understand why uv represents a major leap forward:

17.6.1 The Evolution of Python Package Management

1️⃣ Ancient Times: pip + venv (2013-2023)

python -m venv .venv         # Create environment (slow)
source .venv/bin/activate    # Activate (manual)
pip install -r requirements.txt  # Install (slow, no conflict checking)

Problems:

2️⃣ Middle Ages: Poetry / Pipenv (2018-2024)

poetry install               # Better, but still slow

Improvements:

Remaining problems:

3️⃣ Modern Era: uv (2024-2025)

uv run main.py              # Everything, instantly

Revolutionary improvements:

🚀 Speed: Written in Rust

Benchmarks (creating venv + installing 10 packages):

🎯 Unified Tool

🔒 Reproducibility

🧠 Smart Caching

✅ Safety

17.6.2 What Makes uv So Fast?

Traditional Python tools (pip, poetry):

uv (written in Rust):

Real-world impact:

# Traditional workflow: Install Django + deps
time pip install django
# ⏱️ ~15 seconds

# Modern workflow with uv
time uv pip install django
# ⏱️ ~1 second ⚡

17.7 Putting It All Together: Your Development Workflow

Now you understand the complete picture:

You type: uv run main.py
         ↓
    [uv reads pyproject.toml]
         ↓
    "This project needs:
     - Python 3.10+
     - dash>=2.14.0
     - plotly>=5.18.0
     - pandas>=2.1.0
     - numpy>=1.24.0"
         ↓
    [uv checks .venv/]
         ↓
    No .venv? → Create one (100ms)
    .venv exists? → Verify it's correct
         ↓
    [uv resolves dependencies]
         ↓
    "Checking compatibility...
     dash 2.14.0 needs plotly 5.x ✓
     pandas 2.1.0 needs numpy 1.24+ ✓
     All compatible!"
         ↓
    [uv installs packages]
         ↓
    Check cache → Already have plotly 5.18.0? Reuse it!
    Missing pandas? → Download + install (fast!)
         ↓
    [uv runs your script]
         ↓
    python .venv/bin/python main.py
         ↓
    🎉 Your app runs!

The beauty: All this complexity is hidden. You just type uv run main.py and it works.

17.8 Key Takeaways

1. Virtual Environments:

2. pyproject.toml:

3. Why uv Matters:

4. Professional Workflow:

# That's it. One command.
uv run main.py

# Compare to the old way:
python -m venv .venv
source .venv/bin/activate  # or .\venv\Scripts\activate on Windows
pip install --upgrade pip
pip install -r requirements.txt
python main.py
deactivate

The future of Python development is here, and it’s fast.

18. Beyond the Basics: More uv Workflows

Now that you understand what’s happening behind the scenes, let’s explore additional ways to work with uv. There’s more than one way to run your Python applications!

18.1 Three Ways to Run Your Application

18.1.1 Method 1: uv run (What You Just Learned) ⚡ Fastest for Development

uv run main.py

Pros:

When to use: Day-to-day development, testing, quick runs

18.1.2 Method 2: Manual Virtual Environment 🔧 More Control

Sometimes you want more control over the environment. Here’s how to create and manage it manually with uv:

Step 1: Create the virtual environment

# uv creates venvs MUCH faster than python -m venv
uv venv

This creates .venv/ folder in your project (just like python -m venv .venv, but 10-100x faster!)

Step 2: Activate the environment

Windows (PowerShell):

.venv\Scripts\Activate.ps1

Ubuntu/Linux/Mac:

source .venv/bin/activate

You’ll see (.venv) appear in your terminal prompt, indicating the environment is active.

Step 3: Sync your project dependencies

# Modern uv way: sync environment with pyproject.toml
uv sync

This installs all dependencies listed in your pyproject.toml into the active virtual environment.

Step 4: Run your application

# Now you can just run python directly
python main.py

Step 5: Deactivate when done

deactivate

Pros:

Cons:

When to use:

18.1.3 Method 3: Named Scripts 🎯 Most Professional

This is where Python projects really shine! You can define named commands in pyproject.toml that run your application. Let’s set this up!

18.2 Hands-On Task: Add a Named Script

Step 1: Open pyproject.toml

code pyproject.toml

Step 2: Add a scripts section

Find the [project] section and add this at the end (before [tool.uv] if it exists):

[project.scripts]
# Command name = "module:function"
road-viewer = "main:main"

What this means:

Step 3: Update your main.py to have a main() function

Open main.py and wrap the main code in a function:

# main.py
import dash
from dash import dcc, html
import plotly.graph_objects as go
# ... other imports ...

def main():
    """Main entry point for the Road Profile Viewer application."""
    # Your existing code that creates and runs the app
    app = dash.Dash(__name__)
    
    # ... rest of your app code ...
    
    app.run_server(debug=True, host='127.0.0.1', port=8050)

# This allows running as script OR as installed command
if __name__ == "__main__":
    main()

Step 4: Sync your project to register the script

# Sync installs dependencies and registers scripts from pyproject.toml
uv sync

This will:

Step 5: Run using the named command!

# Now you can run your app with a clean, professional command
road-viewer

Or even better, use uv run with the script name:

uv run road-viewer

🎉 You’ve just created a professional CLI command!

18.3 Why Named Scripts Are Professional

Instead of:

python main.py                    # ❌ Not very professional
python src/road_profile/main.py   # ❌ Hard to remember paths
cd /path/to/project && python main.py  # ❌ Requires navigation

You get:

road-viewer                       # ✅ Clean, memorable command

Real-world examples:

These are all Python packages with named scripts in pyproject.toml!

18.4 Comparing the Three Methods

Method Command Setup Required Speed Use Case
uv run uv run main.py None ⚡ Instant Quick development
Manual venv python main.py Create + activate 🔧 Controlled Debugging, IDE setup
Named script road-viewer Add to toml + install 🎯 Professional Production, distribution

18.5 Advanced: Multiple Scripts

You can define multiple commands in one project:

[project.scripts]
# Main application
road-viewer = "main:main"

# Data processing utilities
process-data = "scripts.process:main"
export-report = "scripts.export:generate_report"

# Development tools
dev-server = "main:run_dev_mode"

Then use them like:

uv run road-viewer          # Start the viewer
uv run process-data input.csv    # Process data
uv run export-report --format pdf  # Export report

18.6 What You Should Do Next

For this course, we recommend:

  1. During development: Use uv run main.py - it’s fastest and simplest
  2. For this task: Add the named script road-viewer to your pyproject.toml
  3. Commit your changes: 
    git add pyproject.toml main.py
git commit -m "Add professional CLI command for road viewer"
git push

Benefits of adding the script now:

18.7 Quick Reference: uv Commands You Should Know

# Environment management
uv venv                    # Create virtual environment (fast!)
uv venv --python 3.12      # Create with specific Python version

# Package management (modern uv way)
uv add package             # Add package to pyproject.toml and install
uv add package --dev       # Add as development dependency
uv remove package          # Remove package from project
uv sync                    # Sync environment with pyproject.toml
uv lock                    # Create/update uv.lock file

# Installing tools globally (like pytest, black, ruff)
uv tool install ruff       # Install a tool globally
uv tool install pytest     # Available everywhere, not just this project
uv tool list               # List globally installed tools
uv tool uninstall ruff     # Remove a global tool

# Running code
uv run script.py           # Run a Python script
uv run command             # Run a named script from pyproject.toml
uv run --with package script.py  # Run with temporary dependency
uv run python              # Start Python REPL with project dependencies

# Project initialization
uv init                    # Create new Python project with pyproject.toml
uv init --app              # Create application project
uv init --lib              # Create library project

# Python version management
uv python install 3.12     # Install Python 3.12
uv python list             # List available Python versions
uv python pin 3.12         # Pin project to Python 3.12

💡 Key Difference:

Why uv add is better:

19. Lecture Quiz: Test Your Understanding

Now that you’ve completed Chapter 01 (Modern Python Development), it’s time to assess your understanding of modern Python development practices. This quiz serves multiple important purposes:

19.1 Why Take This Quiz?

For Your Learning:

For Course Improvement:

19.2 Quiz Details

19.3 Important Notes

📋 Ready to test your knowledge of modern Python development?

Take the Chapter 01 (Modern Python Development) Quiz

After completing the quiz, you’ll have a clear picture of your mastery of this lecture’s content. Remember: the goal isn’t to memorize numbers or specific commands, but to understand the why behind modern Python development practices. Struggling with some questions is normal and expected—that’s how you learn!

20. References

[1] GitHub Search - Python Repositories. https://github.com/search?q=language%3Apython&type=repositories

[2] GitHub Octoverse 2024 - The State of Open Source. https://octoverse.github.com/

[3] RedMonk Programming Language Rankings (2024). https://redmonk.com/sogrady/category/programming-languages/

[4] Stack Overflow Developer Survey 2024. https://survey.stackoverflow.co/2024/

[5] TIOBE Index (October 2025). https://www.tiobe.com/tiobe-index/

[6] IEEE Spectrum Top Programming Languages 2024. https://spectrum.ieee.org/top-programming-languages-2024

[7] Papers With Code - Python Usage in ML Research. https://paperswithcode.com/

[8] arXiv.org - AI/ML Code Repository Analysis. https://arxiv.org/

[9] Google Scholar - Programming Language Citations (2020-2025). https://scholar.google.com/

[10] NumPy, SciPy, Pandas Official Documentation and Usage Statistics. https://numpy.org/, https://scipy.org/, https://pandas.pydata.org/

[11] Jupyter Project - Notebook Statistics. https://jupyter.org/, GitHub Search: https://github.com/search?q=extension%3Aipynb

[12] Nature and Science Journal Computational Methods Surveys (2024). Analysis of programming language mentions in computational biology and scientific computing papers.

[13] PyPI Statistics - Python Package Index. https://pypi.org/, https://pypistats.org/

[14] Stack Overflow Python Tag Statistics. https://stackoverflow.com/questions/tagged/python

[15] Stack Overflow Developer Survey 2024 - Salary Insights & Indeed Salary Survey 2025. https://survey.stackoverflow.co/2024/#salary, https://www.indeed.com/career/python-developer/salaries

[16] LinkedIn Jobs - Python Skills Demand (October 2025). https://www.linkedin.com/jobs/search/?keywords=python

[17] Public company engineering blogs and official technology stack announcements:

[18] PyTorch and TensorFlow Official Documentation and GitHub Statistics:

[19] Hugging Face Model Hub Statistics. https://huggingface.co/

[20] LangChain and LlamaIndex Documentation:

[21] OpenAI Platform and Anthropic API Documentation:

Note: Statistics and market data reflect information available as of October 2025. Job market figures and salary data vary by region, experience level, and specific role requirements. Links to surveys and indices are updated annually or quarterly.

© 2026 Dominik Mueller   •  Powered by Soopr   •  Theme  Moonwalk