Angewendet in mehr als 80% der Projekte der letzten 15 Jahre. Täglich im Gebrauch beim Arbeiten in der Linux Shell (Scripting).  Sehr erfahren beim Erstellen von Backend- Frontend- und IOT-Apps. 

Python 2.7 setze ich zwar nicht mehr ein, meine Erfahrungen damit befähigen mich aber in Migrations projekten (Python 2 nach Python 3) mitzuarbeiten. 

• Python 3.x (x>=4), Python 2.7

• Backend: Django, Wagtail, FastApi, Flask, SqlAlchemie,  typer, Custom TKInter, [nur für Migrationen: Zope, Plone]

• Frontend: Jinja, pygments, Anvil

• IOT

• Microservices

• Mobile Apps: Kivy

In mehr als 60% der Projekte der letzten 15 Jahre benutzte ich ECMAScript (Javascript/Typescript) entweder im Browser, mit NodeJS in der Konsole oder mit Electron zur Programmierung von Desktop-Apps.

• ECMAScript bis ES 2020 (11. Edition)

• NodeJS (ExpressJS, NPM,  ...)

• DOM Komponenten (jQuery, HTML)

• CommonJS, AMD, Webpack, Babel, ES Modules

• Frontend und Backend

• IOT (z.B. NodeRed)

In mehr als 60% der Projekte der letzten 15 Jahre kam Java oder eine Sprache aus dem JVM Ökosystem (Groovy, Kotlin, Scala, Xtend, Clojure) zum Einsatz  

• GUI-Programmierung

• Datenbankzugriffe, ORM, JPA

• RESTful APIs

• JEE Applikationen

• Frontend und Backend

• Microservice Architekturen 

Ungefähr zu 15% im Einsatz in den letzten 15 Jahren. In den 10 Jahren davor benutzt in ca 80% meiner Projekte. Aktuell meist für IOT- oder Hardware-Projekte benötigt.

• Treiberprogrammierung

• IOT-Projekte

• RTOS Programmierung

• HAL füt Microcontroller

• Embedded Linux Installationen mit Yocto

Eingesetzt in ca. 70% der Projekte in den vergangenen 15 Jahren.  CSS auch mit Hilfe von SCSS/SASS oder Less.  Sicherer Umgang beim Erstellen von Webseiten auf Basis einer Designvorlage. Ich bin kein Designer/UX Spezialist kann abe deren Vorgaben umsetzen.

• HTML5 Tags, Mediaqueries, Layouts

• DOM, Ajax, Websockets, WebAssembly

• React.JS, Vue.JS, AngularJs (teilweise auch Angular), jQuery, jQuery.ui

• Meta Tags, HTTP Protokoll, CORS, WebToken

Sicherer Umgang mit der Bash. Seit 25 Jahren tägliche Verwendung Shell Scripten. Regelmässige Änderungen an Shellscripten. Anfänger Erfahrung mit der ZSH.

• Bash Completion, Bash History

• Textmanipulation, Builtin Variablen, Arguments

• Signale, Prozesse, Communication Channels 

• Redirektionen, Background Prozesse, Nohup

• Tmux, Screen, Vim, VimScript, Sed, AWK, Perl

Verwendet in ca. 10% der Projekte in den letzten 5 Jahren. Zeitweilig benutzt um Verbesserungen an Tools vorzunehmen. Beispiele: GOGS an Asciidoc READMEs angepasst; HUGO Bugfixing.

Mit Rust habe ich bisher nur zum Spaß experimentiert:

• I2C Kerneltreiber für Linux

• Hochfrequenter Datenbankstresser um Postgresql an seine Grenzen zu bringen.

Bisher nur ein Großprojekt. Eine Portalseite auf Grundlage von Laravel. Früher oft genutzt um Änderungen und Erweiterungen für Typo3 und Joomla zu schreiben. Einige Male für Wordpress Erweiterungen genutzt.

Seit ca. 4 Jahren beim Entwickeln von Plattform übergreifenden Apps mit Flutter im Einsatz.  3 relevante Projekte bisher.

Expertenkenntnisse in den jahren 1999-2005, in den letzten 10 Jahren nur noch sporadisch genutzt.

Ab und zu zum Bau von AdHoc GUIs in Verwendung.  Wird zunehmend durch andere  GUI Frameworks ersetzt.

Von 1995 bis 2000  sehr oft verwendet. Umsetzung von Altverfahren  in "moderne Technologien". Damals waren das Java, Delphi und C++.

Umfangreiche Kenntnisse: Benötigt zur Umsetzung von Datenbankanwendungen und Rechenkernen von Fortran 77 / 90 in Java 11 Code. Ich kenne nur die älteren Versionen 77 und 90.

Entwicklung eines Grafikadapters zum Anschluss von Composite Video Kameras an moderne CSI Schnittstellen. Zusammenarbeit mit Ingenieuren des Kunden die die Hardware dazu gebaut haben.

Großes Interesse, daher ständige persönliche Weiterbildung mit Altera und Xilinx FPGAs.

Früher oft eingesetzt, mittlerweile nur noch, wenn ich dem Optimierer des C Compilers nicht traue. Prozessoren: x86/amd64, 68000, ARM Cortexe A, R und M, Risc-V, PIC, AVM, ST32, MSP430 und MSP 432.  

Anpassung der Rabbit MQ Message Queue. Performanceverbesserungen.  

Evaluierung der Sprache zur Verwendung in einem Großprojekt. 

Interessehalber in die Programmierung mit Haskel eingearbeitet. Wenig Erfahrung. 

Die Prinzipien der funktionalen Programmierung sind mir vertraut, nur die Syntax von Haskel ist für Entwickler mit meinem Background gewöhnungs-bedürftig.

Jenkins auch im eigenen Unternehmen im Einsatz. CI/CD Pipeline selbst aufgebaut. Bei mehr als 10 Kundenprojekten am Aufsetzen und/oder Weiterentwickeln der Pipeline beteiligt.

Bisher nur ein eigenes Projekt mit GitLab verwaltet. Keiner meiner bisherigen Kunden hatte GitLab im Einsatz.

Bisher konnte ich in zwei Kundenprojekten mit GitHub arbeiten. Beides waren interne Web-Portale, eines davon mit Deployment in Kubernetes (AWS-EKS; Ansible und HELM). 

In den letzten 5 Jahren mindestens ein Projekt pro Jahr bei dem Ansible eingesetzt wurde. Beispiel: Provisionierung von ca.  60 Wildfly Servern und Deployment von JEE Anwendungen, Datenbanken und REST APIs.

Einarbeitung zur Evaluierung, wegen möglichem Einsatz anstelle von Ansible. Zu einem Einsatz kam es dann aber nicht.

Einarbeitung zur Evaluierung, wegen möglichem Einsatz anstelle von Ansible. Zu einem Einsatz kam es dann aber nicht.

Ich bin erfahren im Erstellen von Unit-Tests für meine Hauptsprachen (Java, Javascript, Python, C/C++). Ich kennen verschiedenen Frameworks. 

• Java: Junit/Jupiter, TestNG, Spock, Mockito, EasyMock

• Python: unittest, PyTest, Robot Framework

• Javascript: MochaJS, Jasmine, Jest, Karma

• C++: CppUnit, CPPTest, Boost Test 

Ich bin ein Befürworter der Narrow Testing Strategy kann aber auch broad Tests aufsetzen. 

Auch für Integrationstests setze ich die Unit Testing Frameworks ein. Lediglich beim Aufsetzen von Integrationstests für die GUI kommen dafür passendere Frameworks zum Einsatz. 

• Selenium

• cypress.io

Erfahrung mit den gängigen Testtools

• Cypress.io

• Selenium

• TestCafe

• Puppeteer

• Protractor

• Percy.io (Design/Visual Bugs)

Die Arbeit in einem agilen Team ist mir vertraut. 

In manchen Situationen oder bei manchen Auftraggebern, können nicht alle Prinzipien befolgt werden.  (Covid/Face To Face)

 5 Großprojekte mit einer Laufzeit von mehr als einem Jahr in den letzten 10 Jahren waren agil ausgerichtet. 

Firmenintern arbeiten wir nur agil.  

Clean Code ist ein weiter Begriff, den jedes Team selbst definiert. Ich kennen viele der gängigen Prinzipien und lerne bei Bedarf weitere in kurzer Zeit dazu. 

Unter Clean Code verstehe ich unter anderem die Boy Scout Regel, KISS, DRY, inteligente Benamung , Bevorzugung monadischer Methoden,  nur sinnvolle Kommentare und  saubere Formatierung.

In den letzten 10 Jahren habe ich extern nur in DevOps Teams gearbeitet. Auch wenn man das früher noch nicht so genannt hat. 

Das Programmieren im Pair ist schon eine Weile her. Es würde mir aber nicht schwer fallen, sofort wieder in die Paarprogramierung einzusteigen. 

Meine bisherigen Erfahrungen mit den eXtreme Programming Iterationen waren allerdings nicht so erfreulich wie die mit SCRUM Sprints. 

Ich kenne die Grundlagen von DDD und habe schon in mehreren Projekten (meist mit Microservice Background) diese Verfahrenstechnik eingesetzt. 

• Bounded Contexts, Domain,  Model, Ubiquitous Language (Domain Experts)

• Entity with an Identity, Immutable Value Object, Aggregate, Root Entity

• Domain Event, Repository, Service, Factory für alternative Implementationen

• Domain Specific Languages

• Apache ISIS

Mehrjährige Erfahrung mit TDD und BDD: Ich kenne die Vorgehensweisen und entsprechenden Tools. Produktive Zusammenarbeit mit den  fachlichen Experten. 

BDD

• Requirements to User Stories

• User Scenarios anstelle simpler Test Cases

• Role/Feature/Reason Matrix 

• Given-When-Then Formel

Sowohl theoretisch als auch praktisch sattelfest.

• Synchronisation / Blocking - Non Blocking

• Transaktionen, Isolation Level

• Java, Javascript, Golang, Scala, Erlang, 

• Interaktion mit RDBMS (Postgresql), Service Meshes, Load Balancer, 

Weit zurückliegende Erfahrungen mit Parallelrechnern und Vector Rechnern (SB-PRAM, CM5, Cray-2). Grundlegende Kenntnisse von SIMD Instructionsets in modernen CPUs.  Mittlere Erfahrung mit GPU Rechenkernen CUDA, ROC, OpenCL und Parallelverarbeitung mit FPGAs. 

Routiniert im Programmieren von GPU Shader (Vertex, Geometry, Fragment). Cuda und ROC Cores.

Anfängererfahrung mit Nvidia Tensore Core (DLSS; ähnlich den Google TPUs).

Docker habe ich ständig im Einsatz. Meine gesamte interne Entwicklung betreibe ich innerhalb von Containern. Die CI/CD Pipes laufen auf Kubernetes Clustern mit Docker (Containerd) als Container Technology. Probeinstallationen, Testdatenbanken usw werden grundsätzlich mit Docker zur Verfügung gestellt.

Die gesamte interne und externe Service und Web Angebote werden mit Kubernetes betrieben. 

• Reichhaltige Erfahrung mit Kubernetes auf AWS (EKS). 

• Service Meshes (Istio)

• Provisionierung und Konfiguration mit HELM