Linux Aufbaukurs: Shell Programmierung (LPI03)
Shell-Scripting, Textverarbeitung und Automatisierung für Linux-Administration und LPIC-1
Praxisnahe Programmier-Schulungen für Softwareentwicklung, Webentwicklung und sauberen Code
Alle Kurse anzeigenSoftwareentwicklung entscheidet darüber, wie flexibel Unternehmen Prozesse abbilden, digitale Produkte weiterentwickeln und individuelle Anforderungen in stabile Anwendungen überführen. In den Programmier-Schulungen von cmt baust du genau das Wissen auf, das in Entwicklungsprojekten gebraucht wird: von grundlegenden Programmierkonzepten über objektorientierte Entwicklung, Webentwicklung und Skriptsprachen bis zu Softwarearchitektur, Testing, Clean Code und Projektorganisation.
Die Kategorie bündelt praxisnahe Trainings für Einsteigerinnen und Einsteiger, erfahrene Entwicklerinnen und Entwickler sowie IT-Teams, die ihre Entwicklungsprozesse professionalisieren möchten. Dazu gehören unter anderem Schulungen zu Java, JavaScript, TypeScript, C++, Go, Python, .NET, Office-Programmierung, Softwaredesign und agiler Softwareentwicklung. Wer Grundlagen systematisch aufbauen möchte, findet mit dem OOP-Grundkurs zur objektorientierten Programmierung einen geeigneten Einstieg. Für moderne Webprojekte bieten sich der JavaScript Grundkurs und der TypeScript Grundkurs an.
Im Mittelpunkt stehen nicht nur Syntax und einzelne Werkzeuge, sondern der gesamte Softwareentwicklungszyklus: Anforderungen analysieren, tragfähige Konzepte erstellen, Programmlogik strukturieren, Code testen, Qualität sichern und Entwicklungsprojekte planbar umsetzen. Ergänzend unterstützen Trainings wie die Clean Code Entwicklerschulung und Moderne Software-Entwicklung und Architektur dabei, wartbare, robuste und teamfähige Softwarelösungen zu entwickeln.
Vom ABAP-Einstieg bis Objects, Reports und Dictionary: SAP-Entwicklung gezielt lernen
Mobile Apps mit Kotlin, Java, Android Studio und Jetpack praxisnah entwickeln lernen
Praxisnahe AUTOSAR-Trainings für Classic, Adaptive, RTE und ECU-Softwareentwicklung
COBOL-Wissen für Mainframe-Teams: Programme lesen, Fehler finden und Legacy-Anwendungen ändern
Firmware, RTOS, Embedded Linux, Yocto und Rust für zuverlässige Geräte-Software mit Hardware-Bezug
Praxisnahe Spieleentwicklung mit Game Engines, Scripting und eigenen 2D- oder 3D-Projekten
Versionskontrolle, Branching und Team-Workflows mit Git, GitHub und GitLab sicher beherrschen
Bash-Skripte entwickeln, Admin-Aufgaben automatisieren und Fehler systematisch behandeln
SysML praxisnah lernen: Modelle, Anforderungen und Systemarchitekturen sicher entwickeln
Zig lernen und Speicher, Fehlerpfade sowie Builds für systemnahe Software selbst kontrollieren
Praxisnah programmieren lernen: Grundlagen, Softwareentwicklung, OOP und Git verständlich erklärt
Praxisnahe Testing-Weiterbildung von ISTQB® bis IREB® für stabile Software und bessere Qualität
Python lernen für Entwicklung, Automatisierung, Data Science und Machine Learning mit Praxisbezug
Praxisnahe UML Weiterbildung für Analyse, Softwaredesign und verständliche Systemmodelle
C-Code sicher entwickeln, Speicherfehler finden und systemnahe Anwendungen selbst umsetzen
Praxisnahe Perl Weiterbildung für Skripting, Automatisierung und sichere Anwendungen
Ruby-Code verstehen und mit Rails datenbankgestützte Webanwendungen entwickeln und warten
Praxisnahe Rust Schulungen für sichere Systemprogrammierung, Webentwicklung und Embedded-Projekte
Entwickle wartbare Windows-Anwendungen mit Object Pascal, VCL, Datenzugriff und Debugger
Praxisnahe Go Weiterbildung für Backend, REST APIs, Testing, Nebenläufigkeit und Microservices
Vom Java-Einstieg bis Enterprise-Entwicklung: praxisnahe Schulungen für Entwicklerteams
Shell-Scripting, Textverarbeitung und Automatisierung für Linux-Administration und LPIC-1
Praxisnahes Shell-Scripting mit POSIX, Bash, Pipelines, Variablen und Fehlerbehandlung
In 5 Tagen Python lernen: praxisnah programmieren, Code strukturieren und eigene Anwendungen starten
Fortgeschrittene Python-Techniken für wartbaren Code, APIs, Datenzugriff und saubere Projektstrukturen
Reproduzierbare Python-Umgebungen mit pipenv, pip, Pipfile.lock und stabilen Paketversionen
Wir bieten die Kurse auch als Inhouse oder Firmenseminar an - vor Ort oder Live-Online.
Java SE von Setup bis OOP: in 5 Tagen sicher kompilieren, debuggen und erste Anwendungen entwickeln
Vertiefe Java-Praxis für Datenbanken, Streams, Threads, Netzwerkkommunikation und saubere Projekte
Praxisnahes Java-Training für JDBC, SQL-Zugriff, Transaktionen und JPA-Persistenz
Von Python-Basics bis scikit-learn: Daten auswerten, visualisieren und erste ML-Modelle trainieren
Textdaten analysieren, Frameworks vergleichen und NLP-Projekte fachlich belastbar planen
ML-Modelle mit Python, scikit-learn und TensorFlow/Keras anhand nachvollziehbarer Unternehmensfälle entwickeln
Wir arbeiten direkt an euren eigenen Themen - effizient und mit klarem Alltagsbezug.
Trainingsdaten vorbereiten, neuronale Netze trainieren sowie die Modellleistung visualisieren und bewerten
Neuronale Netze mit Python aufbauen, trainieren und für erste TensorFlow-Projekte belastbar einsetzen
Von Tensoren bis CNNs: Deep-Learning-Modelle in PyTorch verstehen, trainieren und bewerten
Syntax, Speicherverwaltung und Debugging sicher beherrschen, ohne Programmiererfahrung vorauszusetzen
Wartbaren Python-Code strukturieren, Code Smells erkennen und Qualitätsprinzipien im Team verankern
Automatisierte Web-, API- und RPA-Tests strukturiert erstellen und stabil in CI/CD-Prozesse integrieren
Wir helfen dir kurz weiter und empfehlen dir das passende Training.
Reproduzierbare Builds, saubere Abhängigkeiten und PyPI-Releases für wartbare Python-Projekte
Praxisnahes pytest Training für saubere Tests, TDD und zuverlässige Python-Entwicklung
REST- und SOAP-Schnittstellen mit Jakarta EE entwickeln, testen und für Enterprise-Systeme absichern
Dynamische Java-Webanwendungen mit JSP, Servlets, HTTP, Sessions und MVC praxisnah entwickeln
JSF-Webanwendungen mit Managed Beans, Facelets, Ajax und Validierung praxisnah entwickeln
Session Beans implementieren, Container-Transaktionen steuern und javax-Projekte auf jakarta vorbereiten
Verteilte Spring-Boot-Systeme sicher entwerfen, betreiben und von Monolithen sauber abgrenzen
Enterprise-Java-Anwendungen mit Jakarta EE, Servlets, JSP, EJB, Datenzugriff und Security verstehen
Nach einem Tag Architekturvorschläge prüfen, Migrationsrisiken erkennen und Java-Investitionen bewerten
Migriere Monolithen, ohne den Betrieb zu riskieren: Patterns, Tooling und ein belastbarer Fahrplan für Spring Boot in Kubernetes.
Entwickle belastbare REST-Backends mit Spring Boot, Spring MVC, Security, JPA, Tests und OpenAPI
JSON-Daten mit Python sicher einlesen, erzeugen, validieren und für APIs sowie Pandas nutzen
In 4 Tagen Daten mit Python analysieren, auswerten und überzeugend visualisieren
XML mit Python sicher einlesen, parsen und erzeugen, praxisnah im Training vor Ort oder online
Du verfolgst Code vom System Call bis zum Treiber und entwickelst Kernel-Module, die Speicher und Nebenläufigkeit korrekt behandeln.
Entwickle in drei Tagen einen Mehrbenutzer-Server mit IPv6, Timeouts und abgesicherter TLS-Verbindung
Nach drei Tagen entwickelst du ein eigenes Kernel-Modul mit einem Character Device und testest es mit Debugging
Von prüfbaren Anforderungen zu klaren Testfällen, Bug Reports und belastbaren Abnahmeentscheidungen
Sichere Basis für Softwaretest, Testmanagement und die CTFL-Prüfung nach Lehrplan 4.0
Teststrategien planen, Risiken steuern und Teams souverän durch anspruchsvolle Testprojekte führen
Agiles Testen praxisnah trainieren und gezielt auf die ISTQB® Agile Tester Prüfung vorbereiten
Modellbasiertes Testen praxisnah anwenden und gezielt auf die ISTQB®-MBT-Prüfung vorbereiten
E/E-Systeme nach Automotive-Standards testen und dich fundiert auf die CT-AuT-Prüfung vorbereiten
Medizinische Software regulatorisch bewerten und IEC 62304, ISO 14971 sowie Usability verknüpfen
Praxisnahes Advanced-Level-Training für nachhaltige Testautomatisierung, CI/CD-Integration und Reporting
Build practical testing skills and prepare for the ISTQB® CTFL 4.0 certification exam
LLMs gezielt für Testfälle, Testautomatisierung, Fehleranalyse und sichere KI-Workflows nutzen
Qualitätsrisiken in IoT-Lösungen bewerten und typische Aufgaben der CPIoT-Foundation-Prüfung bearbeiten
Unit-, Integration- und E2E-Tests für stabile JavaScript- und TypeScript-Webanwendungen
Kotlin praxisnah lernen: Syntax, OOP, Lambdas, Null-Safety und Android-Einstieg in 3 Tagen
Praxisnaher Einstieg in Android Studio, SDK, Java, Kotlin und erste eigene Android-Apps
Du überführst eine Xamarin.Forms-App in eine moderne MAUI App inkl. Android- und iOS-Deployments
Automatisiere Admin-Aufgaben mit Python, Shell-Integration, Logging, SSH und Systemdatenanalyse
Groovy sicher einsetzen: Syntax, Closures, Datentypen und Builder für produktive JVM-Skripte
Eigene Embedded-Linux-Images mit Yocto, BitBake, Recipes und BSPs sicher erstellen und anpassen
Git praxisnah lernen: Versionierung, Branching und Teamarbeit in 2 intensiven Trainingstagen
Spring AI und LangChain4j in Java-Microservices einsetzen, von LLM-Integration bis RAG
Code gezielt analysieren, refaktorieren und mit KI-Unterstützung sicherer bewerten
LLM-Integration, RAG und Governance für gewachsene Systeme mit belastbarem Weg von PoC bis Rollout
Speicherfehler früh finden, Exploit-Pfade verstehen und native Codebasen gezielt härten
Pipelines, Runner und Deployments in GitLab sicher planen, automatisieren und optimieren
Java-Microservices mit REST, Security, Observability und Native-Optionen sicher entwickeln
Von DeviceTree bis Threading: du bringst Zephyr sauber auf Hardware und lieferst deterministisches Verhalten
Baue produktionsnahe Zephyr-Firmware mit Devicetree, Kconfig, West, Debugging und wartbarer Echtzeitarchitektur.
Baue robuste Firmware mit DeviceTree, Threads, Networking und Debug-Workflows, die im Feld bestehen.
Vom Django-Modell zur getesteten API: DRF, Authentifizierung, Serialisierung und OpenAPI im Workflow
Vom Projekt-Setup bis Deployment: Django-Anwendungen strukturiert entwickeln, testen und absichern
WDM-Treiber in C entwickeln, installieren und debuggen: praxisnah mit echter Hardware
Bereite dich gezielt auf PCAP-31-03 vor: mit Python-Vertiefung, OOP-Training und Prüfungssimulationen
Anforderungen sicher ermitteln, dokumentieren, prüfen und gezielt auf die CPRE-Prüfung vorbereiten
In unserer intensiven zweitägigen Schulung tauchen Sie tief in die Welt des Requirements Engineering (RE) ein, kombiniert mit den dynamischen Prinzipien agiler Methoden. Diese Schulung basiert auf dem..
Vertiefe agiles Requirements Engineering mit Praxisübungen und Vorbereitung auf die IREB-Prüfung
Im Seminar IREB® RE@Agile Kompakt kombinierst Du den RE@Agile Primer und den IREB® RE@Agile Practitioner (CPRE-AL) in einem kompakten Format. Die Schulungsinhalte entsprechen den Inhalten der beiden..
Baue schnelle Java-Services als Native Image und bringe sie sicher in Kubernetes.
Java-Container sauber bauen, deployen und im Betrieb gezielt analysieren
Du entwickelst eine vollständige API mit Pydantic 2, pytest und Docker und stellst sie als Service bereit.
Rust idiomatisch programmieren: Ownership, Concurrency, Testing und Deployment praxisnah anwenden
Word, Excel, Writer und Calc mit Python automatisieren und Dokumente zuverlässig erzeugen
Automatisierung von FreeCAD, QCAD und SVG-Workflows mit Python praxisnah umsetzen
Raspberry Pi mit Python praxisnah programmieren: GPIO, Sensoren und LEDs sicher einsetzen
Integriere Tool-Calling in Spring Boot, verbinde PostgreSQL per PGVector und prüfe KI-Antworten mit Evaluation und Tracing.
Baue asset-zentrierte Pipelines mit Python, Backfills, Tests und CI/CD für Analytics und KI
Von der Prüfung der Gerätezustände, über Änderungen mit Dry-Runs aus und der Validierung von Konfigurationen vor dem Wartungsfenster.
Entwickle zustandsbehaftete Kafka-Pipelines, teste Recovery per Checkpoint und schreibe Streams nach Iceberg oder Paimon.
REST-API-Tests mit Postman, Newman und Postman CLI für QA- und DevOps-Prozesse automatisieren
REST-APIs entlang der OWASP API Top 10 2023 testen: mit Postman, Proxy-Workflows, Tokens und Fuzzing
Sicherer Einstieg in Rust mit Ownership, Cargo, Fehlerbehandlung und praxisnahen Übungen
GitHub 100 Training für Administration, Sicherheit, Actions und Produktfunktionen im Unternehmen
Asynchrones Rust, Ownership und Bibliotheksdesign für robuste Projekte sicher anwenden
Entwickle eine vollständige Compose-App mit StateFlow, Room, Retrofit und Navigation in fünf Tagen
UML-Grundlagen praxisnah lernen: Diagramme, Use Cases und Modelle sicher anwenden
Solide Skripting-Kompetenz für Automation, Datenverarbeitung, Regex, Module und Systemaufgaben
Praxisnaher Einstieg in Ruby-Syntax, Objektorientierung und Skriptentwicklung für Beruf und IT
Übertrage prozedurale Programme in erweiterbare Objektmodelle und bereite den Wechsel zu C# oder Java vor
Programmierlogik, Sprachen, Tools und Entwicklungsprozesse verstehen – ohne Vorkenntnisse
Nebenläufigkeit, Module und Tooling sicher nutzen und erste robuste Anwendungen entwickeln
Praxisnaher Einstieg in Delphi, VCL, Object Pascal und Datenbankanwendungen in 5 Tagen
Rails-Anwendungen mit Ruby, Active Record, MVC, Routing und Datenbankzugriff strukturiert entwickeln
Tool-Chain, Datenbanken und Nebenläufigkeit souverän in anspruchsvollen Go-Projekten einsetzen
Verbinde statische und dynamische UML-Modelle zu konsistenten Architektur- und Komponentensichten
Fortgeschrittene Perl-Entwicklung mit OOP, DBI, Netzwerkprogrammierung und Praxisübungen
RESTful Web Services mit Persistenz entwickeln und über Docker, Kubernetes oder OpenShift bereitstellen
Versionsverwaltung, GitLab-Workflows und CI/CD-Pipelines vom ersten Commit bis zum Runner verstehen
ABAP-Programmierung praxisnah lernen: Workbench, ABAP SQL, Debugging und Dialogentwicklung
Eine lauffähige Desktop-App entwickeln und das passende Rust-GUI-Framework für dein Projekt wählen
Systemnah programmieren lernen: Speicher, Toolchain und C-Integration sicher anwenden
AUTOSAR-Grundlagen praxisnah verstehen und sicher in Entwicklungs-Workflows einordnen
Eigene SAP-Datenmodelle mit Tabellenbeziehungen, Suchhilfen und Sperrobjekten in SE11 aufbauen
Vom Rust-Projekt zur getesteten Web-API, die Daten sicher verarbeitet und im Team weiterentwickelt werden kann
Rollen mit PFCG pflegen, Zugriffsfehler analysieren und Berechtigungen für Prüfungen dokumentieren
Unit-Tests, Testify und CI/CD praxisnah trainieren mit realen Go-Codebeispielen
CI/CD, Azure-Deployments und GitHub-Prozesse praxisnah mit GitHub Actions automatisieren
Vertiefe Android-Apps mit Threading, Sensorik, Location-APIs und praxisnaher Performance-Optimierung
Entwickle performante Go-Services mit gRPC, Kubernetes-Integration und belastbarer Observability
Vertiefe Delphi-Programmierung mit Streams, Threads, DLLs, COM und Komponentenentwicklung
GitHub Copilot sicher einsetzen, Prompts verbessern und KI-gestützte Entwicklung im Team steuern
Praxisnahes Testmanagement in Jira: Testfälle, Testausführung, Defects und Reports mit XRay
CodeQL, Push Protection und Dependabot so konfigurieren, dass Risiken vor dem Merge sichtbar werden
Vertiefe Datenzugriff, REST-Kommunikation und lokale Persistenz für robuste Android-Apps
Steuere GitHub Copilot mit Repository-Kontext und prüfe KI-Code, bevor er in Tests und Reviews gelangt
SysML-Modelle praxisnah mit Enterprise Architect erstellen, strukturieren und im Team nutzen
ABAP-Programme selbst erstellen, Fehler mit Breakpoints finden und Änderungen über Transportaufträge weitergeben
Migriere bestehende ADT-Projekte, verstehe Gradle-Builds und arbeite in der offiziellen IDE weiter
Praxisnahes Android Jetpack Training für stabile Apps mit ViewModel, Room, LiveData und WorkManager
Netzwerk-Clients, TCP/UDP-Server, REST-APIs und Tokio praxisnah mit Rust umsetzen
Entwirf ABAP-Klassen, behandle Fehler mit Exceptions und mache bestehenden SAP-Code leichter testbar
Entwickle Web-Dynpro-Anwendungen, die sich in bestehenden SAP-Landschaften warten und erweitern lassen
Praxisnahes Go-Training für sichere REST APIs mit Routing, Authentifizierung und PostgreSQL
In fünf Tagen entwickelst du einen ausführbaren ABAP-Report mit Selektionsbild, Open SQL und ALV-Ausgabe
Skalierbare Android-Apps mit SOLID, MVVM, Repository Pattern, RxJava und Dependency Injection entwickeln
Objektorientierte ABAP-Entwicklung sicher anwenden und Klassen, Interfaces sowie Events praxisnah nutzen
GenAI im Softwaretest sicher einsetzen, KI-Ausgaben bewerten und CT-GenAI Prüfung vorbereiten
Repositories, Pull Requests, Copilot und Codespaces sicher für Zusammenarbeit im Team einsetzen
Nachhaltige Softwarequalität durch Clean Code, SOLID, Architekturwissen und praxisnahe Übungen
Lange Methoden zerlegen, Abhängigkeiten reduzieren und Refactorings mit Tests absichern
Von der Anforderung bis zur Verifikation: DO-178C praxisfest anwenden und Audit-Fragen souverän beantworten
Code-Smells erkennen, Refactoring gezielt einsetzen und technische Schulden im Team abbauen
Embedded Rust praxisnah vertiefen: no_std, Hardware-Zugriff, Treiber, Debugging und Security
SysML-Modelle mit Cameo Simulation Toolkit ausführbar machen und Modellverhalten verlässlich analysieren
COBOL-Code strukturiert lesen, schreiben und für Datei-, Tabellen- und SQL-Verarbeitung einsetzen
Serviceorientierte Architektur, Adaptive Applications und SOME/IP für anspruchsvolle Fahrzeugsoftware
Nach fünf Tagen RTE-Konfigurationen aus ARXML ableiten und Integrationsfehler früher finden
Vertiefe COBOL mit Pointern, Unterprogrammen, XML-Verarbeitung und Performance-Tuning im Code
COBOL-Programme strukturiert entwickeln, Daten verarbeiten und Wartung im Mainframe-Umfeld sichern
Nach drei Tagen steht dein verknüpftes SysML-Systemmodell mit Anforderungen, Architektur und Verhalten
Nach zwei Tagen Classic-AUTOSAR-Modelle aus ARXML konfigurieren und Seriencode mit Embedded Coder erzeugen
Modelle Anforderungen, Struktur und Verhalten komplexer Systeme nachvollziehbar und prüfbar mit SysML
Komplexe Bestandsprogramme mit Tabellen, Unterprogrammen und Dateizugriffen weiterentwickeln
Automotive-Software systematisch mit AUTOSAR Classic, RTE, BSW und praxisnahen Beispielen entwickeln
Race Conditions finden, Goroutine-Leaks vermeiden und Channel-Pipelines kontrolliert abbrechen
Vom Lua-Einstieg zu wartbaren Skripten, Modulen, Patterns und robustem Tool-Code
Pattern Matching, Modulsystem und Tests gezielt nutzen, um robuste OCaml-Projekte aufzubauen
Rechenintensive Browser-Funktionen mit sicheren Rust-Modulen messbar schneller ausführen
Bestehende Mainframe-Programme analysieren, XML sauber verarbeiten und Encoding-Fehler vermeiden
XML-Dokumente in Java sicher lesen, transformieren, binden, signieren und verschlüsseln
Builds, Dependencies und CI/CD-Integration für Java- und Kotlin-Projekte sicher beherrschen
Builds, POM, Dependencies und CI/CD sicher im Java-Projektalltag einsetzen
Web-Container sicher installieren, konfigurieren, absichern und produktiv mit Proxies betreiben
Das passende Importverfahren wählen, Datenfelder zuordnen und fehlerhafte SAP-Importläufe analysieren.
Wir erstellen dir gern ein individuelles Trainingsangebot.
Keine Schulungen gefunden
Bitte passe deine Filter an.
4.9/5 aus 86 Bewertungen
Teste dein Wissen zu Branching, Merging, Remote Repositories, Stash und Git-Workflows.
Quiz startenTeste dein Wissen zu OOP, Datentypen, Collections, Exceptions, Streams und mehr.
Quiz startenTeste dein Wissen für die Linux Foundation Prüfung LFCS: Kommandozeile, Netzwerk, Storage, Container und Dienste.
Quiz startenTeste dein Wissen zu Linux-Grundlagen mit unserem LPI Essentials Quiz. Finde heraus, welche Schulungen zu dir passen.
Quiz startenTeste dein Wissen für die LPIC-1 Prüfungen 101 und 102: Shell, Prozesse, Dateisysteme, Netzwerk und Sicherheit.
Quiz startenBereite dich auf die PCAP-31-03 Zertifizierungsprüfung vor. Teste dein Wissen zu OOP, Exceptions, Generatoren und mehr.
Quiz startenTeste dein Wissen zu Python-Grundlagen. Finde heraus, ob du fit für die nächste Schulung bist.
Quiz startenTeste dein Wissen zu Ownership, Borrowing, Lifetimes, Traits, Result und dem, was der Compiler garantiert.
Quiz startenSelbst entwickelte Softwarelösungen schaffen Flexibilität, beschleunigen Geschäftsprozesse und ermöglichen Anwendungen, die exakt zu fachlichen Anforderungen passen. Unternehmen nutzen individuelle Softwareentwicklung, um besondere Produkte und Dienstleistungen, höhere Qualität oder wirtschaftlichere Abläufe umzusetzen. Die cmt vermittelt dafür methodisches, technologisches und organisatorisches Wissen in praxisnahen Schulungen für Softwareentwicklung, Programmierung und Webentwicklung.
Das Schulungsangebot reicht von grundlegenden Programmierkursen bis zu spezialisierten Workshops für erfahrene Entwicklerinnen und Entwickler. Behandelt werden Programmiersprachen und Technologien wie C++, Java, JavaScript, TypeScript, Go, Python, .NET und Office-Programmierung. Für den Einstieg in zentrale Konzepte eignet sich der Grundkurs objektorientierte Programmierung. Wer Webanwendungen entwickelt, findet passende Trainings zu JavaScript, TypeScript und angrenzenden Frameworks.
Die Referentinnen und Referenten sind erfahrene Softwarearchitektinnen, Softwarearchitekten und Entwickler mit langjähriger Projekterfahrung. Sie vermitteln nicht nur einzelne Befehle oder Entwicklungswerkzeuge, sondern zeigen, wie Softwareprojekte über den gesamten Lebenszyklus geplant und umgesetzt werden: von der Anforderungsanalyse über Architektur und Programmdesign bis zu Anwendungstest, Qualitätssicherung und Übergabe in den Betrieb.
Ergänzend zu Technologie-Trainings bietet cmt Schulungen zu sauberem Code, moderner Softwarearchitektur und IT-Projektmanagement. Die Clean Code Entwicklerschulung unterstützt Teams dabei, Code verständlicher, wartbarer und testbarer zu schreiben. Für organisatorische Aspekte in Entwicklungsprojekten bieten sich die IT-Projektmanagement Seminare an. Sollte eine gewünschte Schulung nicht verfügbar sein, erstellt cmt über Kontakt und Beratung ein individuelles Angebot für Firmen-Schulungen und Inhouse-Trainings.
Wenn du neu in die Programmierung einsteigst, eignet sich ein Grundlagentraining zu objektorientierter Programmierung oder eine Einführung in eine konkrete Programmiersprache. Mit vorhandener Projekterfahrung sind Aufbaukurse zu Java, JavaScript, TypeScript, Go, C++ oder .NET sinnvoll. Für Entwicklerinnen und Entwickler mit mehr Erfahrung bieten sich Schulungen zu Clean Code, Softwarearchitektur, Testing und sicherer Softwareentwicklung an.
Ja, cmt bietet Programmierkurse für Personen ohne tiefgehende Entwicklungserfahrung an. Diese Trainings vermitteln grundlegende Konzepte wie Variablen, Kontrollstrukturen, Funktionen, Klassen, Objekte, Fehlerbehandlung und einfache Programmentwürfe. Besonders hilfreich ist ein systematischer Einstieg über objektorientierte Programmierung, wenn später Sprachen wie Java, C#, C++ oder TypeScript eingesetzt werden.
Das Angebot umfasst unter anderem Java, JavaScript, TypeScript, C, C++, C#, .NET, Python, Go, VBA und weitere Technologien aus Softwareentwicklung und Webentwicklung. Je nach Schulung stehen Grundlagen, Aufbauwissen, Frameworks, Architektur, sichere Programmierung oder praktische Projektumsetzung im Mittelpunkt.
Die Trainings sind praxisnah aufgebaut. Neben den fachlichen Grundlagen gehören Live-Demos, Übungen, typische Entwicklungssituationen und konkrete Code-Beispiele zum Seminar. Ziel ist, dass du das Gelernte direkt in Entwicklungsprojekten, bei der Wartung bestehender Anwendungen oder beim Aufbau neuer Softwarelösungen einsetzen kannst.
Ja, Inhouse- und Firmen-Schulungen können inhaltlich an Technologien, Projekte, Vorkenntnisse und Lernziele des Unternehmens angepasst werden. Die Dozentinnen und Dozenten stimmen die Inhalte vorab mit dir ab und entwickeln ein passendes Programm für dein Team, zum Beispiel zu einer bestimmten Programmiersprache, Architekturfrage oder Entwicklungsumgebung.
Clean Code und Softwarearchitektur sind zentrale Themen für wartbare und erweiterbare Software. Die entsprechenden Schulungen behandeln unter anderem Lesbarkeit, Struktur, Refactoring, Entwurfsmuster, Verantwortlichkeiten, Testbarkeit und typische Architekturentscheidungen. Dadurch wird Code nicht nur funktionsfähig, sondern langfristig besser verständlich und teamfähig.
Ja, viele Schulungen richten sich ausdrücklich an erfahrene Entwicklerinnen und Entwickler. Aufbaukurse und Spezialtrainings vertiefen Themen wie moderne Sprachfeatures, Webentwicklung, sichere Programmierung, Architektur, Testing, Performance und Projektorganisation. So lassen sich bestehende Kenntnisse gezielt aktualisieren und auf neue Anforderungen übertragen.
Weitere häufig gestellte Fragen und Antworten findest du in den FAQs.
Softwareentwicklung ist ein facettenreiches Fachgebiet. Es umfasst Webanwendungen, Datenbankanwendungen, mobile Anwendungen, Schnittstellen, Automatisierungen, Office-Integrationen und unternehmenskritische Fachverfahren. Entwicklungsumgebungen, Frameworks und Tools sind leistungsfähiger geworden, gleichzeitig steigen die Anforderungen an Entwicklerinnen und Entwickler. Gefragt sind ein solides Verständnis grundlegender Programmiertechniken, sauberes Softwaredesign, sichere Umsetzung, strukturierte Tests und die Fähigkeit, Anforderungen aus Fachbereichen in tragfähige IT-Lösungen zu übersetzen.
Die Programmierschulungen von cmt vermitteln genau diese Verbindung aus Grundlagen, Technologie und Projekterfahrung. In Grundlagenkursen werden Syntax, Kontrollstrukturen, Datentypen, Funktionen, Klassen, Objekte und Fehlerbehandlung systematisch aufgebaut. Aufbaukurse vertiefen Themen wie Architektur, Design Patterns, Schnittstellen, Performance, Testing und Wartbarkeit. Dadurch eignen sich die Trainings sowohl für Personen, die neu in die Programmierung einsteigen, als auch für erfahrene Entwicklerinnen und Entwickler, die ihre Kenntnisse in einer bestimmten Sprache oder Methode gezielt erweitern möchten.
Ein wichtiger Bestandteil ist die Qualität von Software. Gute Software entsteht nicht allein durch funktionierenden Code, sondern durch nachvollziehbare Strukturen, klare Verantwortlichkeiten, testbare Einheiten und verständliche Dokumentation. Schulungen zu Clean Code, Softwarearchitektur und Entwurfsmustern zeigen, wie wiederkehrende Probleme im Softwaredesign gelöst werden, ohne jedes Projekt neu zu erfinden. Der Clean Code Workshop vermittelt dafür praktische Regeln, Refactoring-Ansätze und typische Fehlerbilder aus realen Entwicklungsprojekten. Ergänzend behandelt Moderne Software-Entwicklung und Architektur grundlegende Architekturentscheidungen und deren Auswirkungen auf Wartbarkeit, Erweiterbarkeit und Teamarbeit.
Auch Programmiersprachen und Plattformen haben unterschiedliche Stärken. Java wird häufig für Enterprise-Anwendungen, Backend-Systeme und Webservices eingesetzt. JavaScript und TypeScript prägen moderne Webentwicklung. C und C++ spielen eine wichtige Rolle in systemnaher Entwicklung, performanten Anwendungen und sicherheitsrelevanten Umgebungen. Go eignet sich für schlanke, robuste Anwendungen und moderne Infrastruktur-Themen. .NET, Python und Office-Programmierung decken weitere zentrale Anwendungsfelder ab. Passende Einstiegspunkte sind beispielsweise der Java Aufbaukurs, der Go Programmierung Aufbaukurs oder das Training Sichere Anwendungen mit C und C++.
Softwareprojekte erfordern außerdem methodisches Vorgehen. Anforderungen müssen analysiert, priorisiert und in technische Spezifikationen übersetzt werden. Änderungen im Projektverlauf, Risiken, Kommunikation mit Auftraggebern und die Zusammenarbeit im Entwicklungsteam beeinflussen maßgeblich den Projekterfolg. Deshalb verbindet cmt Programmiertrainings mit Wissen zu Anforderungsanalyse, Projektplanung, agiler Entwicklung und Qualitätssicherung. Die IT-Projektmanagement Seminare ergänzen technische Schulungen um Methoden für Planung, Steuerung und Kommunikation in IT-Projekten.
Das Angebot richtet sich an Einsteigerinnen und Einsteiger, Fortgeschrittene, Softwareentwicklerinnen und Softwareentwickler, Administratorinnen und Administratoren mit Automatisierungsaufgaben, Projektverantwortliche sowie Teams, die Softwarelösungen effizienter entwickeln und betreiben möchten. Die Trainings sind praxisorientiert aufgebaut: Live-Demos, Übungen, typische Projektsituationen und konkrete Entwicklungsaufgaben helfen dabei, das Gelernte direkt in den Arbeitsalltag zu übertragen. So entsteht Weiterbildung, die nicht bei Theorie stehen bleibt, sondern auf reale Aufgaben in der Softwareentwicklung vorbereitet.