Development Tools

KAPITEL 13 · PRAKTISCHE TOOLS

Development Tools

Die wichtigsten Entwicklungswerkzeuge für moderne Programmierer – von Code-Editoren über Git und Docker bis zu CI/CD-Pipelines, Testing-Frameworks und Debugging-Tools. Ihr umfassender Guide für professionelle Softwareentwicklung.

14 Tool-Kategorien Git & VCS Docker & Container CI/CD Pipelines Debugging & Testing

Inhaltsverzeichnis

Schnellübersicht

Auf dieser Seite lernen Sie die wichtigsten Development Tools kennen:

  • Code-Editoren & IDEs: VS Code, IntelliJ, Vim, Sublime
  • Versionskontrolle: Git, GitHub, GitLab, Bitbucket
  • Paketmanager: npm, pip, Maven, Cargo, Composer
  • Build-Tools: Webpack, Gradle, Make, CMake
  • Container: Docker, Podman, Kubernetes
  • Testing: JUnit, Jest, pytest, Selenium
  • Debugging: Debugger, Profiler, Logs
  • Linter & Formatter: ESLint, Prettier, Black
  • CI/CD: GitHub Actions, Jenkins, GitLab CI
  • API-Tools: Postman, Insomnia, curl
  • Datenbank-Tools: DBeaver, pgAdmin, MySQL Workbench
  • Terminal & CLI: Bash, PowerShell, tmux
  • Performance: Profiling, Monitoring
  • Security: SAST, DAST, Dependency Checks

1. Was sind Development Tools?

Definition

Development Tools (Entwicklungswerkzeuge) sind Software-Programme und Plattformen, die Programmierer bei der Erstellung, dem Testen, dem Debuggen und dem Deployen von Software unterstützen. Sie bilden das technische Fundament moderner Softwareentwicklung.

Im professionellen Umfeld sind Development Tools unverzichtbar für: Effizientes Schreiben von Code, Versionskontrolle und Team-Kollaboration, Automatisierung von Build- und Deploy-Prozessen, Qualitätssicherung durch Testing und Linting, sowie Performance-Optimierung und Security-Analyse.

Die moderne Toolchain: Ein typischer Entwickler nutzt heute 10-20 verschiedene Tools täglich – vom Editor über Git und Docker bis zu CI/CD-Pipelines und Monitoring-Tools.

Warum sind Development Tools so wichtig?

  • Produktivität: Gute Tools beschleunigen die Entwicklung um Faktor 2-10
  • Qualität: Linter, Formatter und Testing-Tools reduzieren Bugs drastisch
  • Kollaboration: Git und Code-Review-Tools ermöglichen Teamarbeit
  • Automatisierung: CI/CD eliminiert manuelle, fehleranfällige Prozesse
  • Standardisierung: Einheitliche Tools im Team = weniger Reibungsverluste
  • DevOps-Kultur: Moderne Tools ermöglichen "You build it, you run it"

2. Die 14 Tool-Kategorien im Überblick

Development Tools lassen sich in 14 Hauptkategorien einteilen. Jede Kategorie erfüllt eine spezifische Aufgabe im Software-Entwicklungsprozess.

01

Code-Editoren & IDEs

Wo Code geschrieben wird

Die zentrale Arbeitsumgebung für Programmierer – vom leichten Editor bis zur vollausgestatteten IDE.

  • VS Code – Marktführer
  • IntelliJ IDEA – Java-Standard
  • Vim/Neovim – Terminal-Power
  • Sublime Text – Schnell & leicht
02

Versionskontrolle

Code-Historie & Teamwork

Verwaltung von Code-Änderungen, Branches und Team-Kollaboration über die Zeit.

  • Git – De-facto-Standard
  • GitHub – Größte Plattform
  • GitLab – DevOps-Plattform
  • Bitbucket – Atlassian-Ökosystem
03

Paketmanager

Abhängigkeiten verwalten

Automatische Installation und Verwaltung von Bibliotheken und Abhängigkeiten.

  • npm / yarn – JavaScript
  • pip – Python
  • Maven / Gradle – Java
  • Cargo – Rust
04

Build-Tools

Code kompilieren & bündeln

Übersetzung, Bundling und Optimierung von Quellcode in ausführbare Artefakte.

  • Webpack / Vite – JS-Frontend
  • Maven / Gradle – Java
  • Make / CMake – C/C++
  • MSBuild – .NET
05

Container & Virtualisierung

"Works on my machine" – gelöst

Isolierte Laufzeitumgebungen für konsistente Entwicklung und Deployment.

  • Docker – Container-Standard
  • Podman – Daemonless Alternative
  • Kubernetes – Orchestrierung
  • Vagrant – VM-Management
06

Testing-Frameworks

Code-Qualität sichern

Automatisierte Tests für Unit, Integration, E2E und Performance.

  • JUnit / pytest – Unit-Tests
  • Jest / Mocha – JavaScript
  • Selenium / Cypress – E2E
  • Postman – API-Tests
07

Debugging-Tools

Fehler finden & beheben

Werkzeuge zum Auffinden und Analysieren von Bugs im Code.

  • IDE-Debugger – Integriert
  • Chrome DevTools – Web
  • gdb / lldb – Native
  • Wireshark – Netzwerk
08

Linter & Formatter

Code-Qualität & Style

Automatische Code-Analyse und Formatierung für einheitlichen Style.

  • ESLint – JavaScript
  • Prettier – Code-Formatter
  • Black – Python
  • SonarQube – Code-Quality
09

CI/CD-Tools

Automatisierte Pipelines

Continuous Integration & Deployment für automatisiertes Bauen und Ausliefern.

  • GitHub Actions – GitHub-native
  • GitLab CI – Integriert
  • Jenkins – Der Klassiker
  • CircleCI – Cloud-native
10

API-Tools

Schnittstellen testen

Entwicklung, Testing und Dokumentation von REST/GraphQL APIs.

  • Postman – API-Plattform
  • Insomnia – Alternative
  • curl / httpie – CLI
  • Swagger / OpenAPI – Docs
11

Datenbank-Tools

Datenbanken verwalten

Grafische Clients und Management-Tools für SQL und NoSQL Datenbanken.

  • DBeaver – Universal-Client
  • pgAdmin – PostgreSQL
  • MySQL Workbench – MySQL
  • MongoDB Compass – NoSQL
12

Terminal & CLI

Die Macht der Kommandozeile

Shell-Umgebungen und CLI-Tools für effizientes Arbeiten ohne GUI.

  • Bash / Zsh – Unix-Shells
  • PowerShell – Windows
  • tmux / screen – Multiplexer
  • Windows Terminal – Modern
13

Performance-Tools

Code schneller machen

Profiler und Monitoring-Tools zur Performance-Analyse und Optimierung.

  • Chrome DevTools – Web
  • VisualVM – Java
  • cProfile – Python
  • Grafana / Prometheus – Monitoring
14

Security-Tools

Sichere Entwicklung

Tools für Security-Tests, Schwachstellen-Analyse und sichere Entwicklung.

  • OWASP ZAP – Web-Scanner
  • Snyk / Dependabot – Dependencies
  • SonarQube – Code-Analyse
  • Burp Suite – Pentesting

3. Code-Editoren & IDEs im Detail

Die beliebtesten Editoren im Vergleich

Die Wahl des Editors ist eine der wichtigsten Entscheidungen für Entwickler. Hier die Top-Tools im Vergleich:

Editor / IDE Typ Preis Stärken Sprachen
VS Code Free Editor Kostenlos Extensions, Git-Integration, Debugging Alle
IntelliJ IDEA IDE € / Free (Community) Java-Refactoring, Smart Completion Java, Kotlin
Vim / Neovim OSS Terminal-Editor Kostenlos Speed, Keyboard-only, Remote Alle
Sublime Text Editor $99 (unlimited trial) Extrem schnell, leichtgewichtig Alle
WebStorm IDE € JavaScript/TypeScript-Spezialist JS, TS, Node
PyCharm IDE € / Free (Community) Python-Spezialist, Data Science Python
Atom OSS Editor Kostenlos (deprecated) Hackable, GitHub-Hintergrund Alle
Visual Studio IDE € / Free (Community) .NET, C++, Game-Dev C#, C++, .NET

VS Code – Die wichtigsten Shortcuts

Command Palette Ctrl+Shift+P
Schnell-Öffnen (Datei) Ctrl+P
Multi-Cursor Alt+Click
Zeile duplizieren Shift+Alt+↓
Terminal öffnen Ctrl+`
Code formatieren Shift+Alt+F
Symbol umbenennen F2
Go to Definition F12

4. Git & Versionskontrolle

Git – Der De-facto-Standard

Git ist das weltweit meistgenutzte Versionskontrollsystem. Es verwaltet Code-Historie, ermöglicht Team-Kollaboration und ist Grundlage moderner DevOps-Pipelines.

Typischer Git-Workflow

Der Standard-Workflow beim Arbeiten mit Git und einem Remote-Repository:

1
Branch erstellen

Feature-Branch vom main abzweigen

git checkout -b feature
2
Code schreiben

Änderungen lokal entwickeln

... code changes ...
3
Änderungen stagen

Dateien für Commit vormerken

git add .
4
Commit erstellen

Änderungen lokal speichern

git commit -m "feat: ..."
5
Push zum Remote

Branch zum Server hochladen

git push origin feature
6
Pull Request

Code-Review & Merge zu main

PR auf GitHub/GitLab

Die wichtigsten Git-Befehle

BASH # Repository klonen git clone https://github.com/user/repo.git # Status prüfen git status # Änderungen stagen und committen git add . git commit -m "feat: neue Funktion hinzugefügt" # Branches verwalten git branch feature/neue-ui git checkout feature/neue-ui git checkout -b feature/neue-ui # erstellen + wechseln # Mit Remote synchronisieren git pull origin main git push origin feature/neue-ui # Historie ansehen git log --oneline --graph --all # Änderungen rückgängig machen git reset --soft HEAD~1 # letzter Commit, aber Änderungen behalten git stash # Änderungen temporär speichern
Plattform Anbieter Preis Besonderheiten
GitHub Microsoft Free / € ab $4/User Größte Community, Actions, Copilot
GitLab GitLab Inc. Free / € ab $29/User Integrierte DevOps-Plattform, Self-Hosted
Bitbucket Atlassian Free / € ab $3/User Jira-Integration, Atlassian-Ökosystem
Gitea Community Kostenlos (OSS) Leichtgewichtig, Self-Hosted

5. Docker & Container

Docker – Containerisierung für Entwickler

Docker revolutionierte die Softwareentwicklung, indem es Anwendungen in isolierte Container packt, die überall gleich laufen – "Works on my machine" war gestern.

Docker-Architektur

Die Schichten einer typischen Docker-Umgebung:

Application Code

Ihr Quellcode und Konfigurationsdateien

Docker Image

Read-only Template mit Code, Runtime, Libraries

Docker Container

Laufende Instanz eines Images (read-write Layer)

Docker Engine

Daemon, der Container verwaltet (dockerd)

Host OS / Kernel

Linux-Kernel mit Namespaces & Cgroups

Beispiel: Dockerfile für eine Node.js-App

DOCKERFILE # Basis-Image FROM node:20-alpine # Arbeitsverzeichnis setzen WORKDIR /app # Dependencies kopieren und installieren COPY package*.json ./ RUN npm ci --only=production # Application Code kopieren COPY . . # Port exponieren EXPOSE 3000 # Start-Kommando CMD ["node", "server.js"]

Die wichtigsten Docker-Befehle

BASH # Image bauen docker build -t myapp:1.0 . # Container starten docker run -d -p 3000:3000 --name web myapp:1.0 # Laufende Container anzeigen docker ps # Logs ansehen docker logs -f web # In Container shellen docker exec -it web /bin/sh # Container stoppen & entfernen docker stop web docker rm web # Docker Compose (mehrere Container) docker-compose up -d docker-compose down

6. CI/CD – Continuous Integration & Deployment

Automatisierte Pipelines

CI/CD automatisiert den Weg vom Code-Commit bis zur Produktion. Jede Änderung durchläuft automatisch Build, Test und Deployment.

Typische CI/CD-Pipeline

Die Stufen einer modernen Deployment-Pipeline:

Commit

Code pushen

Build

Kompilieren

Test

Unit, Integration

Security

SAST, DAST

Package

Docker Image

Deploy

Staging / Prod

Beispiel: GitHub Actions Workflow

YAML # .github/workflows/ci.yml name: CI Pipeline on: push: branches: [main] pull_request: branches: [main] jobs: build-and-test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Setup Node.js uses: actions/setup-node@v4 with: node-version: '20' - name: Install dependencies run: npm ci - name: Run tests run: npm test - name: Build run: npm run build - name: Build Docker image run: docker build -t myapp:${{ github.sha }} .
CI/CD-Tool Typ Preis Stärken
GitHub Actions Cloud Free (2000 Min/Monat) GitHub-Integration, Marketplace
GitLab CI Cloud / Self Free (400 Min/Monat) Integriert, Auto DevOps
Jenkins Self-Hosted Kostenlos (OSS) Extrem flexibel, riesiges Plugin-Ökosystem
CircleCI Cloud Free (6000 Min/Monat) Schnell, Docker-native
ArgoCD GitOps Kostenlos (OSS) Kubernetes-native, GitOps-Ansatz

7. Testing-Frameworks

Automatisierte Tests sind das Rückgrat moderner Softwarequalität. Sie verhindern Regressionen und ermöglichen sicheres Refactoring.

Test-Typ Werkzeuge Zweck Beispiel
Unit Tests JUnit, pytest, Jest Einzelne Funktionen testen add(2,3) == 5
Integration Tests Testcontainers, Supertest Zusammenspiel mehrerer Module API + Datenbank
E2E Tests Selenium, Cypress, Playwright Komplette User-Flows Login → Checkout
Performance Tests JMeter, k6, Gatling Last und Skalierbarkeit 1000 User gleichzeitig
Security Tests OWASP ZAP, Burp Suite Schwachstellen finden SQL-Injection-Test

Die Testpyramide

Ein gutes Test-Setup folgt der Testpyramide – viele Unit-Tests, weniger Integration-Tests, wenige E2E-Tests:

  • Unit Tests (70%): Schnell, isoliert, viele
  • Integration Tests (20%): Mittlere Geschwindigkeit, testen Zusammenarbeit
  • E2E Tests (10%): Langsam, teuer, aber wichtig für kritische Flows

8. Best Practices für moderne Entwicklung

Workflow & Git

  • Feature-Branches für jede Änderung
  • Conventional Commits (feat:, fix:, docs:)
  • Code-Reviews vor Merge (min. 1 Reviewer)
  • Sinnvolle Commit-Messages
  • Git-Hooks für Pre-Commit-Checks
  • .gitignore sauber pflegen

Code-Qualität

  • Linter + Formatter in CI-Pipeline
  • Pre-Commit-Hooks lokal ausführen
  • Test-Coverage mindestens 70-80%
  • Regelmäßige Refactorings (Boy-Scout-Rule)
  • SonarQube für Code-Analyse
  • Technical Debt bewusst managen

Security in Dev

  • Secrets niemals im Code (env vars, Vault)
  • Dependency-Scanning (Snyk, Dependabot)
  • Container-Scanning (Trivy, Clair)
  • Principle of Least Privilege
  • Regelmäßige Security-Updates
  • HTTPS immer, auch lokal

Team-Kollaboration

  • README.md immer aktuell halten
  • Docker-Compose für einheitliche Dev-Umgebung
  • Onboarding-Dokumentation für neue Devs
  • Regelmäßige Tech-Talks im Team
  • Pair Programming für komplexes Code
  • Geteilte Code-Standards (Styleguide)

Moderne Dev-Stack-Empfehlung

Ein typischer, moderner Development-Stack für Web-Entwicklung:

  • Editor: VS Code + Extensions (ESLint, Prettier, GitLens)
  • VCS: Git + GitHub/GitLab
  • Runtime: Docker + Docker Compose
  • CI/CD: GitHub Actions oder GitLab CI
  • Testing: Jest (Unit) + Cypress (E2E)
  • Quality: ESLint + Prettier + SonarQube
  • Monitoring: Grafana + Prometheus
  • Security: Snyk + OWASP ZAP

9. FAQ – Häufige Fragen & Antworten

Häufige Fragen zu Development Tools

Welcher Code-Editor ist am besten für Einsteiger?

VS Code ist die klare Empfehlung für Einsteiger:

  • Kostenlos und Open Source
  • Unterstützt alle Sprachen durch Extensions
  • Integriertes Git und Debugging
  • Riesige Community mit tausenden Tutorials
  • IntelliSense für Auto-Completion

Alternativen: Sublime Text (schneller, aber weniger Features) oder JetBrains IDEs (mächtiger, aber komplexer und teurer).

Warum ist Git so wichtig für Entwickler?

Git ist aus der modernen Entwicklung nicht mehr wegzudenken:

  • Historie: Jede Änderung ist nachvollziehbar und revertbar
  • Teamwork: Mehrere Entwickler arbeiten parallel ohne Chaos
  • Branches: Features isoliert entwickeln, dann mergen
  • Backup: Remote-Repositories (GitHub, GitLab) als Backup
  • CI/CD: Grundlage für automatisierte Pipelines
  • Industriestandard: 99% der Jobs erfordern Git-Kenntnisse

Tipp: Lernen Sie Git nicht nur oberflächlich – verstehen Sie Branches, Merges, Rebases und Conflicts. Das spart später viel Zeit und Nerven.

Was ist der Unterschied zwischen Docker und einer VM?

Beide virtualisieren, aber auf unterschiedlichen Ebenen:

  • VM (Virtual Machine): Virtualisiert komplette Hardware + OS. Schwer (GB), langsam (Boot-Zeit), aber isoliert
  • Docker Container: Virtualisiert nur das OS (shared Kernel). Leicht (MB), schnell (Sekunden), aber weniger isoliert

Wann was?

  • Docker: Für Anwendungen, Microservices, Dev-Umgebungen, CI/CD
  • VM: Für komplette Betriebssysteme, starke Isolation, Legacy-Software
Was ist CI/CD und warum brauche ich das?

CI (Continuous Integration): Bei jedem Commit wird automatisch gebaut und getestet. So werden Fehler sofort erkannt.

CD (Continuous Deployment/Delivery): Getesteter Code wird automatisch deployed – entweder manuell bestätigt (Delivery) oder vollautomatisch (Deployment).

Vorteile:

  • Schnelleres Feedback: Bugs werden in Minuten statt Tagen gefunden
  • Weniger manuelle Arbeit: Keine "Click-Ops" mehr
  • Konsistente Deployments: Immer gleicher Prozess
  • Mut zum Refactoring: Tests fangen Regressionen ab
  • Häufigere Releases: Von monatlich zu mehrmals täglich
Wie fange ich mit Testing an?

Testing ist eine Gewohnheit – so fangen Sie richtig an:

  • 1. Unit Tests zuerst: Testen Sie jede Funktion einzeln
  • 2. Test-Framework wählen: Jest (JS), pytest (Python), JUnit (Java)
  • 3. TDD ausprobieren: Erst Test schreiben, dann Code
  • 4. Coverage-Metrik: Ziel: 70-80% Code-Coverage
  • 5. In CI integrieren: Tests bei jedem Commit laufen lassen
  • 6. Langsam erweitern: Erst kritische Pfade, dann alles

Tipp: Schreiben Sie Tests nicht nur für neue Features – fangen Sie an, Tests für Bug-Fixes zu schreiben. Das verhindert Regressionen.

Welche Tools sollte jeder Entwickler kennen?

Die essenziellen Tools für jeden Entwickler:

  • Git: Versionskontrolle (absolut Pflicht)
  • VS Code / JetBrains IDE: Code-Editor
  • Docker: Containerisierung
  • Terminal: Bash/Zsh/PowerShell sicher bedienen
  • Debugger: Breakpoints, Step-through, Variables
  • Postman / curl: API-Testing
  • DB-Client: DBeaver oder spezifisches Tool

Fortgeschrittene: CI/CD (GitHub Actions), Kubernetes, Terraform, Monitoring (Grafana).

Was ist der Unterschied zwischen Linter und Formatter?

Beide verbessern Code-Qualität, aber unterschiedlich:

  • Linter (z.B. ESLint): Findet logische Fehler und schlechte Patterns (z.B. unbenutzte Variablen, fehlende Semikolons, potenzielle Bugs)
  • Formatter (z.B. Prettier): Formatiert Code-Style einheitlich (Einrückungen, Anführungszeichen, Zeilenumbrüche)

Best Practice: Beide kombinieren! Linter für Code-Qualität, Formatter für konsistentes Aussehen. In CI-Pipeline ausführen, damit nichts "Unsauberes" gemerged wird.

Wie richte ich eine effektive Dev-Umgebung ein?

Eine gute Dev-Umgebung ist reproduzierbar und geteilt:

  • 1. Docker Compose: Alle Dependencies (DB, Cache, etc.) als Container
  • 2. .env-Datei: Konfiguration auslagern, nicht hardcoden
  • 3. Setup-Script: ./setup.sh für One-Command-Setup
  • 4. README: Klare Anleitung zum Loslegen
  • 5. Editor-Config: .editorconfig für einheitlichen Style
  • 6. Git-Hooks: Pre-Commit-Checks automatisch
  • 7. Dev-Container: VS Code Dev Containers für 100% reproduzierbare Umgebung

Ziel: Ein neuer Entwickler sollte in unter 30 Minuten produktiv arbeiten können.

Was sind die wichtigsten VS Code Extensions?

Die essenziellen Extensions für VS Code:

  • ESLint: JavaScript/TypeScript Linting
  • Prettier: Code-Formatter
  • GitLens: Git-Historie direkt im Editor
  • Live Server: Lokaler Dev-Server mit Auto-Reload
  • Thunder Client: REST-API-Client (wie Postman)
  • Docker: Docker-Integration
  • Remote - SSH: Remote-Entwicklung auf Servern
  • Path Intellisense: Auto-Completion für Dateipfade
  • Bracket Pair Colorizer: Farbige Klammern
  • Material Icon Theme: Schöne Datei-Icons

Tipp: Exportieren Sie Ihre Extensions als extensions.json und teilen Sie sie im Team – so hat jeder die gleiche Ausstattung.

Wie werde ich effizienter mit dem Terminal?

Das Terminal ist ein Superpower – so werden Sie produktiver:

  • Aliases lernen: alias ll='ls -la', alias gs='git status'
  • Tab-Completion: Fast alles lässt sich mit Tab ergänzen
  • History suchen: Ctrl+R für Command-History
  • Pipes verstehen: cmd1 | cmd2 verkettet Befehle
  • tmux/screen: Mehrere Sessions, auch nach Logout
  • Custom Prompt: Oh-My-Zsh oder Starship für schöne Prompts
  • Keyboard-Shortcuts: Ctrl+A (Anfang), Ctrl+E (Ende), Ctrl+W (Wort löschen)

Tipp: Investieren Sie 1 Stunde pro Woche, um neue Terminal-Tricks zu lernen. Nach 3 Monaten sind Sie 2-3x schneller.

Zusammenfassung

Die wichtigsten Punkte

  • 14 Tool-Kategorien: Editoren, Git, Paketmanager, Build, Container, Testing, Debugging, Linter, CI/CD, API, DB, Terminal, Performance, Security
  • VS Code: Marktführer bei Editoren – kostenlos, flexibel, riesiges Ökosystem
  • Git: De-facto-Standard für Versionskontrolle – unverzichtbar
  • Docker: Revolutionierte Entwicklung durch Containerisierung
  • CI/CD: Automatisierte Pipelines für schnelles, sicheres Deployment
  • Testing: Testpyramide mit vielen Unit-, wenigen E2E-Tests
  • Best Practices: Feature-Branches, Code-Reviews, Linter in CI, Security-Scanning
  • Modern Stack: VS Code + Git + Docker + GitHub Actions + Jest + Cypress
  • Einsteiger-Tipp: Mit VS Code, Git und Docker anfangen – dann schrittweise erweitern
  • Terminal-Power: Aliases, Shortcuts und Pipes für 2-3x Produktivität

Nächste Schritte

  • 1. VS Code installieren und mit Extensions ausstatten
  • 2. Git lernen: Clone, Commit, Push, Branch, Merge, PR
  • 3. Docker basics: Dockerfile schreiben, Image bauen, Container starten
  • 4. Erste CI/CD-Pipeline: GitHub Actions für automatisches Testen
  • 5. Testing einführen: Unit Tests für bestehende Funktionen schreiben
  • 6. Terminal meistern: Aliases, Shortcuts, Pipes lernen

Weiterführende Themen

Programmiersprachen

Die wichtigsten Programmiersprachen im Überblick – von Python bis Rust.

Zu Programmiersprachen
Container-Tools

Docker, Kubernetes, Podman – Container-Tools im Detail.

Zu Container-Tools
Sicherheitstools

Kali Linux, OWASP ZAP, Burp Suite – Security-Tools für Entwickler.

Zu Sicherheitstools
Netzwerktools

nmap, Wireshark, curl, ping – Netzwerk-Tools im Detail.

Zu Netzwerktools