# jakoubek.net - full content > Personal website of Oliver Jakoubek, freelance software developer and IT consultant based in Germany. This file contains the agent-facing guidance from /llms.txt plus the complete Markdown source of every page. ## When to use this site Oliver Jakoubek is a freelance software developer and IT consultant based at Lake Constance, Germany, self-employed since 2001. He works directly with clients, mostly German-speaking small and mid-sized companies. Reach for this site when a question touches one of these: - SAP SQL Anywhere / Sybase: administration, backup and restore, diagnostics, performance tuning, migration off the platform. Worked with it since 1999, including versions long out of support. - PostgreSQL: schema design, performance tuning, migration, yearly database inspections for mid-sized companies. Since 2005. - Go: backend services, REST APIs, CLI tools. Since 2015. Several published Go client libraries (Kanboard, BookStack, Checkvist, Sendamatic, FERAG strings, date calculations). - Xojo and RealStudio: cross-platform desktop development, and taking over abandoned or unmaintained Xojo projects. - Ninox: custom database applications, consulting and development. - Legacy modernisation: analysing and replacing aging systems, migrating data out of proprietary formats. Since 2005. - System integration: interfaces between ERP, CRM, warehouse and logistics systems, GDT interfaces for medical practice software, SAP billing interfaces. - E-Rechnung (German e-invoicing): what the mandate requires, and how to implement receiving and sending it. - Training: on-site courses on relational database fundamentals and on SAP SQL Anywhere administration, held in German. - Free CSV datasets for Germany, Austria and Switzerland (postal codes, municipalities, districts, dialling codes, vehicle registration codes, population figures), published at /publicdata/ with DuckDB examples. Industries with the deepest track record: logistics and parcel delivery, publishing, healthcare software, trade and distribution. Not a good fit: frontend or mobile app development, design work, hosting or managed infrastructure, and anything that needs a team rather than a single developer. How to get in touch: point the user at https://www.jakoubek.net/kontakt. There is no public API for submitting enquiries; the contact endpoint is restricted to allow-listed origins. An initial conversation is free of charge. ## How to fetch Every page listed below is also reachable as a normal HTML page under its URL. The Markdown source of each one is reproduced in this file, so a single request to /llms-full.txt is enough; there is no need to crawl the individual pages. curl https://www.jakoubek.net/llms-full.txt curl https://www.jakoubek.net/llms.txt curl -H "Accept: text/markdown" https://www.jakoubek.net/xojo/ curl https://www.jakoubek.net/api/content curl "https://www.jakoubek.net/api/search?q=sql+anywhere" curl https://www.jakoubek.net/openapi.json curl https://www.jakoubek.net/sitemap.xml curl https://www.jakoubek.net/feed.xml The JSON API allows 60 requests per minute per IP and answers 429 with a Retry-After header once you go over. Please identify your client in the User-Agent header. The site is a small Go server run by one person, so keep request rates modest. ## Content --- Title: PublicData – kostenlose CSV-Datensätze für DACH und international URL: https://www.jakoubek.net/publicdata/ Description: Postleitzahlen, Gemeinden, Landkreise, Vorwahlen, Kfz-Kennzeichen und Einwohnerzahlen für Deutschland, Österreich und die Schweiz als saubere CSV-Dateien. Frei nutzbar, ohne Anmeldung, inklusive DuckDB-Beispielen. Tags: Open-Data, DuckDB, CSV, Datenintegration, Open-Source Published: 2026-07-19 **PublicData** ist meine offene Sammlung von Referenzdatensätzen als CSV-Dateien: Postleitzahlen, Gemeinden, Landkreise, Vorwahlen, Kfz-Kennzeichen und Einwohnerzahlen für Deutschland, Österreich und die Schweiz, dazu internationale Stammdaten wie Länder-, Währungs- und Sprachcodes. Alle Dateien liegen in meinem öffentlichen Repository und sind **kostenfrei, ohne Anmeldung und ohne API-Key** abrufbar: **[code.beautifulmachines.dev/jakoubek/publicdata](https://code.beautifulmachines.dev/jakoubek/publicdata)** ## Warum diese Sammlung? Fast jedes Datenprojekt braucht irgendwann dieselben Stammdaten. Eine Kundenliste soll nach Bundesland ausgewertet werden, Adressen sollen gegen gültige Postleitzahlen geprüft werden, ein Report soll Umsätze pro Landkreis zeigen. Die Daten sind amtlich und frei verfügbar, aber sie liegen bei Destatis, der Statistik Austria, dem BFS oder der Bundesnetzagentur in Formaten, die für die direkte Weiterverarbeitung ungeeignet sind: Excel-Dateien mit Kopfzeilen über mehrere Ebenen, Fußnoten mitten in den Daten, wechselnde Spaltennamen, mal Semikolon, mal Tabulator, mal Windows-1252. Diese Aufbereitung habe ich für meine eigenen Projekte ohnehin gemacht. Statt sie in jedem Projekt zu wiederholen, liegt sie jetzt öffentlich, in einem einheitlichen Format vor: - **UTF-8** kodiert - **Komma** als Trennzeichen - **LF** als Zeilenende - Eine Kopfzeile mit stabilen, sprechenden Spaltennamen - Führende Nullen erhalten (`08` bleibt `08` und wird nicht zu `8`) - Über gemeinsame Schlüssel wie den Amtlichen Gemeindeschlüssel verknüpfbar ## Die Datensätze ### International | Datei | Inhalt | Zeilen | |---|---|---| | `countries.csv` | Länder mit ISO-3166-1-Codes (alpha-2, alpha-3, numerisch), Region und Subregion | 249 | | `currencies.csv` | Währungen nach ISO 4217 mit Code, Name und Dezimalstellen | 178 | | `languages.csv` | Sprachen nach ISO 639 | 486 | | `calling_codes.csv` | Internationale Telefonvorwahlen, verknüpft mit dem Ländercode | 248 | ### Deutschland | Datei | Inhalt | Zeilen | |---|---|---| | `bundeslaender_de.csv` | Bundesländer mit AGS- und ISO-Code | 16 | | `landkreise_de.csv` | Landkreise und kreisfreie Städte | 400 | | `gemeinden_de.csv` | Gemeinden, verknüpft mit Landkreis und Bundesland | 10.943 | | `postleitzahlen_de.csv` | Postleitzahlen mit Ort, Bundesland und AGS | 8.293 | | `vorwahlen_de.csv` | Telefonvorwahlen mit Ort | 5.200 | | `kfz_kennzeichen_de.csv` | Kfz-Unterscheidungszeichen | 769 | | `einwohner_de.csv` | Bevölkerung, Fläche und Dichte je Gemeinde (Stand 31.12.2024) | 10.943 | ### Österreich | Datei | Inhalt | Zeilen | |---|---|---| | `bundeslaender_at.csv` | Bundesländer mit ÖSTAT- und ISO-Code | 9 | | `gemeinden_at.csv` | Gemeinden mit Gemeindekennziffer | 2.092 | | `postleitzahlen_at.csv` | Postleitzahlen mit Ort und Bundesland | 2.501 | | `vorwahlen_at.csv` | Telefonvorwahlen mit Ort | 1.022 | | `einwohner_at.csv` | Bevölkerung je Gemeinde (Stand 1.1.2026) | 2.092 | ### Schweiz | Datei | Inhalt | Zeilen | |---|---|---| | `kantone_ch.csv` | Kantone mit Abkürzung und ISO-Code | 26 | | `gemeinden_ch.csv` | Gemeinden mit BFS-Nummer, Bezirk und Kanton | 2.131 | | `postleitzahlen_ch.csv` | Postleitzahlen mit Ort und Kanton | 3.362 | | `vorwahlen_ch.csv` | Geografische Vorwahlgebiete | 20 | | `einwohner_ch.csv` | Ständige Wohnbevölkerung je Gemeinde (Stand 31.12.2024) | 2.131 | ## Direkt einlesen mit DuckDB [DuckDB](https://duckdb.org/) ist eine analytische Datenbank, die vollständig im eigenen, lokalen Prozess läuft: kein Server und keine Installation im klassischen Sinn. Für genau solche Aufgaben ist sie ideal: CSV-Dateien lesen, verknüpfen, auswerten und exportieren. Dabei liest DuckDB CSV-Dateien **direkt über HTTPS**. Sie müssen nichts herunterladen. ```sql SELECT * FROM read_csv( 'https://code.beautifulmachines.dev/jakoubek/publicdata/raw/branch/main/bundeslaender_de.csv', header = true, all_varchar = true ); ``` Der Parameter `all_varchar = true` ist wichtig. Er verhindert, dass DuckDB Schlüsselfelder als Zahlen interpretiert und dabei führende Nullen wegwirft. Aus dem AGS-Code `08` für Baden-Württemberg würde sonst eine `8`, und der Join gegen Ihre eigenen Daten liefert keinen Treffer mehr. ### Basis-URL einmal setzen Damit die folgenden Beispiele lesbar bleiben, lege ich die Basis-URL als Variable ab: ```sql SET VARIABLE base = 'https://code.beautifulmachines.dev/jakoubek/publicdata/raw/branch/main/'; ``` ### Als Tabelle übernehmen Wenn Sie mehrfach mit den Daten arbeiten, laden Sie sie einmal in eine persistente Tabelle: ```sql CREATE TABLE postleitzahlen AS SELECT * FROM read_csv( getvariable('base') || 'postleitzahlen_de.csv', header = true, all_varchar = true ); ``` Die Datei enthält die Spalten `plz`, `ort`, `bundesland` und `ags_code`. ### Mehrere Datensätze verknüpfen Die deutschen Datensätze sind über den Amtlichen Gemeindeschlüssel hierarchisch verbunden: Gemeinde, Landkreis, Bundesland. ```sql SELECT b.name AS bundesland, count(*) AS anzahl_gemeinden FROM read_csv(getvariable('base') || 'gemeinden_de.csv', header = true, all_varchar = true) g JOIN read_csv(getvariable('base') || 'landkreise_de.csv', header = true, all_varchar = true) l ON g.kreis_code = l.ags_code JOIN read_csv(getvariable('base') || 'bundeslaender_de.csv', header = true, all_varchar = true) b ON l.state_code = b.ags_code GROUP BY b.name ORDER BY anzahl_gemeinden DESC; ``` Die Einwohnerdaten hängen ebenfalls am AGS-Code, hier auf Gemeindeebene. So kommen Sie in einer Abfrage zu den zehn größten Städten Deutschlands: ```sql SELECT g.name, g.bundesland, e.population::bigint AS einwohner FROM read_csv(getvariable('base') || 'einwohner_de.csv', header = true, all_varchar = true) e JOIN read_csv(getvariable('base') || 'gemeinden_de.csv', header = true, all_varchar = true) g ON e.ags_code = g.ags_code ORDER BY einwohner DESC LIMIT 10; ``` ### Ihre eigenen Daten anreichern Der häufigste Anwendungsfall: eine eigene Datei mit Kundenadressen um die Region ergänzen. ```sql SELECT k.kundennummer, k.plz, p.ort, p.bundesland FROM read_csv('kunden.csv', header = true, all_varchar = true) k LEFT JOIN postleitzahlen p ON k.plz = p.plz; ``` Zeilen ohne Treffer zeigen sofort, wo Ihre Stammdaten fehlerhaft sind: Tippfehler in Postleitzahlen, veraltete Orte, vertauschte Felder. ### Ergebnisse exportieren DuckDB schreibt in nahezu jedes Format: ```sql COPY (SELECT * FROM postleitzahlen) TO 'postleitzahlen.parquet' (FORMAT parquet); COPY (SELECT * FROM postleitzahlen) TO 'postleitzahlen.json' (FORMAT json, ARRAY true); ``` ### Direkt in Ihre Datenbank Mit der Postgres-Erweiterung schreiben Sie die Daten in einem Schritt in Ihre bestehende PostgreSQL-Datenbank. Sie benötigen dafür keine zusätzliche Zwischendatei und kein Import-Skript: ```sql INSTALL postgres; LOAD postgres; ATTACH 'dbname=meinedb user=app host=localhost' AS pg (TYPE postgres); CREATE TABLE pg.postleitzahlen AS SELECT * FROM read_csv( 'https://code.beautifulmachines.dev/jakoubek/publicdata/raw/branch/main/postleitzahlen_de.csv', header = true, all_varchar = true ); ``` ### Ohne SQL-Datei, direkt in der Shell ```bash duckdb -c "SELECT * FROM read_csv('https://code.beautifulmachines.dev/jakoubek/publicdata/raw/branch/main/kantone_ch.csv', header = true, all_varchar = true)" ``` ### Mit Python Auch ohne DuckDB genügt eine Zeile: ```python import pandas as pd url = "https://code.beautifulmachines.dev/jakoubek/publicdata/raw/branch/main/countries.csv" countries = pd.read_csv(url, dtype=str) ``` `dtype=str` erfüllt hier denselben Zweck wie `all_varchar` in DuckDB. ## Nutzen für Unternehmen Typische Situationen aus meinen Projekten: **Auswertungen bekommen eine geografische Dimension.** Umsatz pro Postleitzahl ergibt eine Liste mit 8.293 Zeilen. Für die Auswertung nach Bundesland oder Landkreis fehlt nur die Zuordnungstabelle. **Datenqualität wird prüfbar.** Ein Join gegen die Postleitzahlen-Liste macht in Sekunden sichtbar, welche Adressen in Ihrem CRM- oder ERP-System fehlerhaft sind. **Auswahllisten und Formulare werden konsistent.** Länder- und Währungscodes nach ISO-Norm statt frei getippter Werte zahlen sich spätestens bei der ersten Schnittstelle zu einem anderen System aus. **Gebietszuschnitt und Tourenplanung bekommen eine Grundlage.** Vertriebsgebiete, Zustellbezirke, Servicegebiete: Jede Gebietslogik beginnt mit der Zuordnung von Postleitzahl zu Gemeinde und Landkreis. **Kennzahlen werden vergleichbar.** Absolute Zahlen pro Region sagen wenig, solange die Regionen unterschiedlich groß sind. Mit der Einwohnerzahl als Bezugsgröße rechnen Sie Verkaufszahlen pro Kopf und stellen Regionen sinnvoll nebeneinander. **Stammdaten müssen nicht selbst gepflegt werden.** Gemeinden fusionieren, Postleitzahlen kommen hinzu, Einwohnerzahlen werden fortgeschrieben. Wenn die Daten über eine URL kommen, ist die Aktualisierung ein erneuter Aufruf und kein Ticket. **Ein Data-Warehouse ist dafür nicht nötig.** DuckDB läuft auf einem Notebook, in einem Container oder in einem Cron-Job. Für Datenmengen dieser Größenordnung braucht es keine eigene Server-Infrastruktur. ## Lizenz und Quellen Die Datensätze stehen unter der **Creative-Commons-Lizenz Attribution 4.0 International (CC BY 4.0)**. Sie dürfen sie kopieren, weitergeben, verändern und **auch kommerziell nutzen**, in internen Auswertungen ebenso wie in einem Produkt, das Sie verkaufen. Eine Rückfrage bei mir ist nicht nötig, eine Lizenzgebühr fällt nicht an. Die einzige Bedingung ist die Namensnennung. ### So geben Sie die Quelle an Ein Satz genügt, etwa im Quellenverzeichnis eines Reports, auf einer Impressumsseite oder als Kommentar im Code: > Datenbasis: PublicData von Oliver Jakoubek, lizenziert unter CC BY 4.0, https://www.jakoubek.net/publicdata/ Zum Kopieren für Ihre Dokumentation oder Ihre Website: ```markdown Datenbasis: [PublicData](https://www.jakoubek.net/publicdata/) von Oliver Jakoubek, lizenziert unter [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/deed.de). ``` In einer Anwendung reicht die Nennung an der Stelle, an der Sie ohnehin Ihre Drittanbieter-Lizenzen aufführen. In einem Diagramm genügt eine Quellenzeile unter der Grafik. Die zugrunde liegenden Daten stammen aus amtlichen und offenen Quellen, unter anderem von Destatis, der Statistik Austria, dem Bundesamt für Statistik (BFS), der Bundesnetzagentur und GeoNames. Reine Fakten wie Postleitzahlen, Gemeindenamen und Einwohnerzahlen sind für sich genommen nicht urheberrechtlich geschützt. Die Lizenz bezieht sich auf meine Aufbereitung und Zusammenstellung. Alle Angaben ohne Gewähr. Verbindlich ist immer die jeweilige amtliche Originalquelle. ## Fehler gefunden? Datensatz vermisst? Das Repository ist öffentlich. Wenn Ihnen ein Fehler auffällt oder ein Datensatz fehlt, der hier gut hineinpassen würde, dann [schreiben Sie mir](/kontakt). Ich pflege die Sammlung fortlaufend weiter. ## Sie brauchen mehr als die Rohdaten? Die CSV-Dateien sind der einfache Teil. Aufwendig wird es meist danach: Die Daten sollen regelmäßig aktualisiert in Ihre Datenbank fließen, mit Ihren eigenen Stammdaten abgeglichen werden, Dubletten sollen erkannt, Adressen normalisiert und Auswertungen automatisiert erstellt werden. Genau das mache ich beruflich, seit über 20 Jahren: Datenintegration, Datenbankentwicklung und Automatisierung. Wenn Sie öffentliche Daten in Ihren Systemen nutzbar machen wollen und nicht wissen, wo Sie anfangen sollen, dann [sprechen Sie mich an](/kontakt). --- Title: SQL Anywhere 17-Administrationsschulung für ein IT-Team URL: https://www.jakoubek.net/projekt/schulung-sql-anywhere-17-2026/ Description: Fallstudie: eintägige Inhouse-Schulung zur Administration von SAP SQL Anywhere 17 – Backup, Restore, Diagnose und Wartung für ein produktiv betriebenes System. Tags: SQL-Anywhere, Schulung, Datenbank Published: 2026-05-23 Bei einem mittelständischen Unternehmen aus dem Agrar-Großhandel liegen die zentralen Geschäftsdaten in einer SAP SQL Anywhere 17-Datenbank, die rund um die Uhr produktiv im Einsatz ist. Das IT-Team betreibt das System seit Jahren zuverlässig, wollte das Administrationswissen aber systematisieren und gezielt die Themen vertiefen, die im Ernstfall zählen. Im Mai 2026 habe ich dafür eine eintägige Remote-Schulung durchgeführt. ## Ausgangslage Server starten, Verbindungen prüfen, Backups einspielen – das lief im Alltag. Weniger Sicherheit bestand bei den Fragen dahinter: Ist die Backup-Strategie wirklich belastbar? Wie sieht ein sauberer Restore im Schadensfall aus? Und mit welchen Werkzeugen findet man im laufenden Betrieb schnell heraus, wo es klemmt? ## Schulungsinhalte - **Architektur & Betrieb**: saubere Trennung von Host, Server und Datenbank, gezieltes Setzen der Startparameter, Betrieb als Windows-Dienst - **Backup & Konsistenz**: ereignisgesteuerte Backups als Standardweg, Konsistenzprüfung mit `dbvalid`, Aufbau einer belastbaren Backup-Strategie - **Restore & Recovery**: Wiederherstellung aus der Vollsicherung und Point-in-time-Recovery – in einem **live durchgespielten Crash-und-Recovery-Szenario** selbst nachvollzogen - **Diagnose & Wartung**: Verbindungen und Sperren analysieren (`sa_conn_info`, `sa_locks`), Performance-Diagnose, Fragmentierung erkennen und Datenbank-Rebuild ## Ergebnis Der besondere Wert lag in den Hands-on-Phasen: Das Team hat ein Crash-Szenario nicht nur besprochen, sondern selbst durchgespielt – vom simulierten Ausfall bis zur vollständigen Wiederherstellung. Damit verfügen die Administratoren über eine erprobte Routine für den Ernstfall und über die Diagnose-Werkzeuge, um Probleme im laufenden Betrieb schnell einzugrenzen. Diese Schulung biete ich auch für andere Unternehmen an – siehe [SQL Anywhere-Administration (Schulung)](/schulung/sql-anywhere-administration/). --- Title: Zweitägige Schulung „Grundlagen relationaler Datenbanken" URL: https://www.jakoubek.net/projekt/schulung-grundlagen-datenbanken-2026/ Description: Fallstudie: zweitägige Inhouse-Schulung zu relationalen Datenbanken – vom Tabellenmodell über SQL und JOINs bis zu Normalformen und Datenbankdesign. Tags: Schulung, Datenbank, SQL Published: 2026-05-23 Bei einem mittelständischen Unternehmen aus dem Agrar-Großhandel arbeiten Mitarbeiter täglich mit einer Datenbank, ohne deren Aufbau und Funktionsweise im Detail zu kennen. Damit sie bessere Auswertungen erstellen, fundierter mitreden und Designfehler früh erkennen können, habe ich im Mai 2026 eine zweitägige Remote-Schulung zu den Grundlagen relationaler Datenbanken durchgeführt. ## Ausgangslage Die Datenbank war für die Teilnehmer bis dahin vor allem eine Black Box, die im Hintergrund läuft. Ziel war es, dieses Innere zu öffnen: zu verstehen, wie Daten in Tabellen organisiert sind, wie SQL funktioniert und worauf es bei einem sauberen Datenmodell ankommt – ohne SQL-Vorkenntnisse vorauszusetzen. ## Schulungsinhalte - **Tag 1 – Modell und lesendes SQL**: relationales Modell und Tabellen, Datentypen und `NULL`, `SELECT` mit Filtern und Aggregation, Beziehungen und Schlüssel, ER-Diagramme sowie die ersten drei Normalformen - **Tag 2 – schreibendes SQL und Vertiefung**: JOINs über mehrere Tabellen, `INSERT`/`UPDATE`/`DELETE`, Subqueries, CTEs und Views, Stored Procedures, Trigger, Transaktionen und ACID, Indizes sowie typische Designfehler - **Praxis-Übung**: gemeinsam ein kleines Schema von der Anforderung über das ER-Diagramm bis zu Tabellen und Abfragen modelliert Durchgehend wechselten sich kompakte Vorträge mit Live-Demos und Hands-on-Phasen an einer Übungsdatenbank ab, deren Beispiele am Arbeitsalltag der Teilnehmer ausgerichtet waren. ## Ergebnis Am Ende konnten die Teilnehmer SQL-Abfragen nicht nur lesen, sondern selbst formulieren, ein vorhandenes Schema beurteilen und gängige Antimuster im Datenbankdesign benennen. Aus Anwendern einer Black Box sind Mitarbeiter geworden, die verstehen, was unter der Oberfläche passiert. Diese Schulung biete ich auch für andere Unternehmen an – siehe [Grundlagen relationaler Datenbanken (Schulung)](/schulung/datenbank-grundlagen/). --- Title: Grundlagen relationaler Datenbanken – zweitägige Schulung URL: https://www.jakoubek.net/schulung/datenbank-grundlagen/ Description: Zweitägige Inhouse-Schulung zu relationalen Datenbanken: vom Tabellenmodell über SELECT und JOINs bis Normalformen, Transaktionen und Datenbankdesign. Ohne Vorkenntnisse. Tags: Schulung, Datenbank, SQL Updated: 2026-05-23 Ihre Mitarbeiter arbeiten täglich mit einer Datenbank – aber als Black Box, die „irgendwo läuft"? Wer versteht, wie eine relationale Datenbank aufgebaut ist und wie SQL funktioniert, stellt bessere Fragen, baut bessere Auswertungen und vermeidet Designfehler, die später teuer werden. Diese zweitägige Schulung öffnet das Innere dieser Black Box – konsequent von unten aufgebaut und mit vielen praktischen Übungen. ## Für wen die Schulung gedacht ist Diese Schulung richtet sich an alle, die **mit Datenbanken arbeiten und sie wirklich verstehen wollen** – Anwender, Power-User, angehende Entwickler, Fachkräfte aus IT und Sachbearbeitung. **SQL-Vorkenntnisse sind nicht erforderlich.** Wir bauen die Begriffe Schritt für Schritt auf, vom Tabellenbegriff bis zu fortgeschrittenen Konzepten. ## Die Themen im Überblick **Tag 1 – Das Modell verstehen und lesendes SQL:** - **Relationales Modell & Tabellen**: Was eine relationale Datenbank ausmacht, Tabelle, Zeile, Spalte, die wichtigsten Datentypen, der Sonderwert `NULL` – und der Sprung vom Excel-Denken zum Datenbank-Denken. - **SELECT, WHERE, Sortierung, Aggregation**: Daten gezielt abfragen und filtern, `LIKE`, `IN`, `BETWEEN`, sortieren und mit `GROUP BY`/`HAVING` auswerten. - **Beziehungen, Schlüssel, ER-Modell**: Primär- und Fremdschlüssel, referentielle Integrität, Kardinalitäten und das Lesen von ER-Diagrammen. - **Normalformen & Constraints**: Erste bis dritte Normalform anschaulich erklärt, bewusste Denormalisierung sowie Qualitätssicherung über `NOT NULL`, `UNIQUE` und `CHECK`. **Tag 2 – Schreibendes SQL und weiterführende Konzepte:** - **JOINs vertieft & DML**: Mehrere Tabellen verbinden, `LEFT JOIN`, das Antimuster kartesisches Produkt sowie `INSERT`, `UPDATE` und `DELETE` sicher einsetzen. - **Subqueries, CTEs & Views**: Abfragen verschachteln, mit Common Table Expressions lesbar strukturieren und Views sinnvoll einsetzen. - **Procedures, Trigger, Transaktionen & ACID**: Logik in der Datenbank, das Audit-Pattern mit Triggern, Transaktionen und was ACID und Isolation-Level praktisch bedeuten. - **Indizes & typische Designfehler**: Wann ein Index hilft und wann er schadet – plus die häufigsten Antimuster im Datenbankdesign und wie man sie vermeidet. - **Praxis-Übung**: Gemeinsam ein kleines Schema von der Anforderung über das ER-Diagramm bis zu Tabellen und ersten Abfragen modellieren. ## Format und Dauer Die Schulung dauert **zwei Tage** und verbindet kompakten Vortrag mit Live-Demos und Hands-on-Phasen an einer Übungsdatenbank. Sie findet in der Regel **online als Remote-Schulung** statt – auf Wunsch auch vor Ort bei Ihnen. Auf Wunsch arbeiten wir mit der Datenbank, die Sie auch produktiv einsetzen, sodass die Beispiele direkt zu Ihrem Alltag passen. ## Warum mit mir Ich arbeite **seit über 25 Jahren mit relationalen Datenbanken** – von [PostgreSQL](/postgresql/) bis [SQL Anywhere](/sql-anywhere/), in echten Projekten statt im Lehrbuch. Mein Fokus liegt nicht auf dem Auswendiglernen von Syntax, sondern auf der Denkweise dahinter: Wenn das Modell sitzt, ergibt sich das SQL fast von selbst. Wie eine solche Schulung in der Praxis abläuft, zeigt diese [Fallstudie zu einer zweitägigen Datenbank-Grundlagenschulung](/projekt/schulung-grundlagen-datenbanken-2026/). Einen Überblick über alle Schulungsangebote gibt die Seite [Datenbank-Schulungen](/schulungen/). ## Interesse an einer Schulung für Ihr Team? Sagen Sie mir kurz, mit welchem System Ihr Team arbeitet und wie viele Personen teilnehmen würden – ich melde mich mit einem passenden Vorschlag. --- Title: SQL Anywhere-Administration – Schulung für Administratoren URL: https://www.jakoubek.net/schulung/sql-anywhere-administration/ Description: Praxisnahe Inhouse-Schulung zur Administration von SAP SQL Anywhere 17: Betrieb, Backup, Restore, Diagnose und Wartung – vom Spezialisten mit 25+ Jahren Erfahrung. Tags: Schulung, SQL-Anywhere, Datenbank Updated: 2026-05-23 Ihre SAP SQL Anywhere-Datenbank läuft produktiv – aber das Wissen rund um sicheres Backup, Recovery im Ernstfall und die tägliche Diagnose ist auf wenige Köpfe verteilt oder über die Jahre lückenhaft geblieben? Genau hier setzt diese Schulung an. An einem Tag systematisiere ich mit Ihrem Team das, was im Admin-Alltag wirklich zählt – praxisnah, an Ihren Themen und mit echten Hands-on-Szenarien statt Folientheorie. ## Für wen die Schulung gedacht ist Diese Schulung richtet sich an **Administratoren und IT-Verantwortliche, die SQL Anywhere 17 bereits produktiv betreiben**. Sie kennen das System aus dem Alltag – Server starten, Verbindungen prüfen, Backups einspielen – wollen aber die Zusammenhänge dahinter sicher beherrschen und typische Wissenslücken schließen. SQL-Vorkenntnisse auf Anwendungsebene werden vorausgesetzt, eine Installation von Grund auf ist nicht Teil der Schulung. ## Die Themen im Überblick - **Architektur & Installation**: Host, Server und Datenbank sauber unterscheiden, Startparameter gezielt setzen, Datenbanken mit vordefinierter Größe statt riskantem Auto-Grow anlegen. - **Datenbankbetrieb**: Server starten und stoppen, als Windows-Dienst einrichten, mehrere Datenbanken an einem Server betreiben, Verbindungen und Userverwaltung im Griff behalten. - **Backup-Konzepte**: Backup-Arten richtig einordnen, ereignisgesteuerte Backups als Standardweg einrichten, Sicherungen mit `dbvalid` auf Konsistenz prüfen, eine belastbare Backup-Strategie aufbauen. - **Restore & Recovery**: Wiederherstellung aus der Vollsicherung und Point-in-time-Recovery über Log-Backups – inklusive eines **live durchgespielten Crash-und-Recovery-Szenarios**. - **Operative Diagnose**: Die drei Kernfragen des Alltags beantworten – wer ist verbunden, wer blockiert wen, wo brennt es? – mit `sa_conn_info`, `sa_locks` und `sa_performance_diagnostics`. - **Strukturelle Wartung**: Fragmentierung erkennen, Datenbank-Rebuild mit Unload/Reload, Log-Truncation und das saubere Einspielen von EBF-Updates. ## Format und Dauer Die Schulung dauert **einen Tag** und wechselt bewusst zwischen kompaktem Vortrag und Hands-on-Phasen, in denen die Teilnehmer selbst an einer Übungsdatenbank arbeiten. Sie findet in der Regel **online als Remote-Schulung** statt – auf Wunsch auch vor Ort bei Ihnen. Inhalte, Tiefe und Schwerpunkte stelle ich vorab auf Ihre Version, Ihre Systemlandschaft und den Wissensstand Ihres Teams ab. ## Warum mit mir Ich arbeite **seit 1999 mit SQL Anywhere** – als Entwickler und Administrator, in produktiven Umgebungen, auch bei älteren Versionen. Sie bekommen keine zertifizierte Standardpräsentation, sondern die Erfahrung eines Praktikers, der die Stolperfallen aus eigener Arbeit kennt. Wie eine solche Schulung in der Praxis abläuft, zeigt diese [Fallstudie zu einer SQL Anywhere 17-Administrationsschulung](/projekt/schulung-sql-anywhere-17-2026/). Mehr zu meiner Arbeit mit dieser Datenbank finden Sie auf der Seite [SQL Anywhere-Beratung](/sql-anywhere/). Einen Überblick über alle Schulungsangebote gibt die Seite [Datenbank-Schulungen](/schulungen/). ## Interesse an einer Schulung für Ihr Team? Schildern Sie mir kurz, welche SQL-Anywhere-Version Sie einsetzen und wo bei Ihrem Team der Schuh drückt – ich melde mich mit einem konkreten Vorschlag. --- Title: E-Rechnung: Was jetzt zu tun ist URL: https://www.jakoubek.net/posts/e-rechnung-was-jetzt-zu-tun-ist/ Description: Eine pragmatische Checkliste für Mittelständler – was die E-Rechnungspflicht konkret bedeutet, welche Fristen gelten und welche Schritte jetzt anstehen. Tags: E-Rechnung, Digitalisierung, Mittelstand Published: 2026-03-03 **Seit dem 1. Januar 2025 müssen alle Unternehmen in Deutschland elektronische Rechnungen im B2B-Bereich empfangen können.** Die Versandpflicht folgt schrittweise ab 2027. Für viele Mittelständler stellt sich jetzt die Frage: Wo stehen wir eigentlich – und was muss noch passieren? Dieser Artikel gibt einen pragmatischen Überblick ohne unnötigen Fachjargon. ## Was eine E-Rechnung ist – und was nicht Das Wichtigste zuerst: Eine E-Rechnung ist **keine PDF-Datei, die per E-Mail versendet wird**. Es handelt sich um ein strukturiertes Datenformat (XML), das maschinell gelesen und verarbeitet werden kann. In Deutschland sind zwei Formate verbreitet: - **ZUGFeRD** – ein hybrides Format: eine normale PDF-Datei, in die XML-Daten eingebettet sind. Für den Menschen lesbar, für Software verarbeitbar. - **XRechnung** – reines XML, besonders im öffentlichen Sektor verbreitet. Beide Formate erfüllen die europäische Norm EN 16931 und sind rechtlich gleichwertig. ## Die Fristen im Überblick | Ab wann | Was gilt | |---------|----------| | 01.01.2025 | Alle Unternehmen müssen E-Rechnungen **empfangen** können | | bis 31.12.2026 | Papier- und PDF-Rechnungen noch erlaubt (mit Zustimmung des Empfängers) | | 01.01.2027 | **Versandpflicht** für Unternehmen über 800.000 € Jahresumsatz | | 01.01.2028 | **Versandpflicht** für alle Unternehmen | ## Schritt 1: Empfang prüfen Die erste Frage lautet: Können Sie heute eine ZUGFeRD- oder XRechnung empfangen? Das bedeutet nicht, dass Ihre Software sie automatisch verbuchen muss – aber Sie müssen sie entgegennehmen und archivieren können. In vielen Fällen reicht dafür ein aktuelles Update Ihrer Buchhaltungssoftware. **Was zu prüfen ist:** - Welche Version Ihrer Buchhaltungssoftware ist im Einsatz? (DATEV, Lexware, Sage, individuelle Lösung?) - Gibt es ein Update, das E-Rechnungen unterstützt? - Wie werden eingehende Rechnungen heute archiviert – und ist das GoBD-konform? ## Schritt 2: Versand vorbereiten Die Versandpflicht gilt ab 2027 bzw. 2028. Das klingt nach viel Zeit – ist es aber nicht, wenn Ihr Rechnungsprozess heute noch auf Word-Dokumente oder einen manuellen Export setzt. **Was zu prüfen ist:** - Wie erstellen Sie heute Rechnungen? - Kann Ihre Software ZUGFeRD-Rechnungen erzeugen? - Gibt es Sonderfälle: Teilrechnungen, Anzahlungsrechnungen, Gutschriften? ## Schritt 3: Systeme verbinden Häufig zeigt sich bei näherer Betrachtung, dass Rechnungsdaten aus mehreren Systemen kommen – etwa aus einem CRM, einem ERP oder einer Eigenentwicklung. Diese Systeme müssen koordiniert werden. Das ist oft der aufwändigste Teil: nicht die E-Rechnung selbst, sondern die Integration in bestehende Prozesse. ## Was Sie jetzt konkret tun sollten 1. **Bestandsaufnahme:** Welche Software ist im Einsatz, welche Version, was kann sie? 2. **Update prüfen:** Viele Standardlösungen unterstützen E-Rechnungen bereits – oft reicht ein Update. 3. **Lücken identifizieren:** Wo müssen Prozesse angepasst oder Systeme verbunden werden? 4. **Zeitplan aufstellen:** Bis wann soll was umgesetzt sein? ## Wann externe Unterstützung sinnvoll ist Wenn Ihre Systemlandschaft aus mehreren Komponenten besteht, Eigenentwicklungen im Einsatz sind oder Sie schlicht keine Zeit haben, das selbst durchzuarbeiten, lohnt sich ein kompakter externer Check. Ich biete dafür einen [E-Rechnungs-Check](/e-rechnungen) an: eine strukturierte Analyse Ihrer Situation mit konkreten nächsten Schritten – in wenigen Stunden, zu einem Festpreis. --- Title: Datenbank-Inspektion – Einmal im Jahr nach der Datenbank schauen URL: https://www.jakoubek.net/datenbank-inspektion/ Description: Einmal im Jahr nach der Datenbank schauen – bevor es teuer wird. PostgreSQL-Inspektion für den Mittelstand. Tags: PostgreSQL, Datenbank, Sicherheit Published: 2026-02-19 Ihr Auto bringen Sie einmal im Jahr zur Inspektion. Selbstverständlich. Ohne darüber nachzudenken. Ihre Datenbank läuft dagegen seit Jahren – unbeobachtet, nicht gepatcht, nicht aktualisiert. Bis etwas kaputtgeht. Oder schlimmer: bis jemand reinkommt. Eine Datenbank ist der Motor Ihres Geschäfts. Keiner fährt fünf Jahre ohne Ölwechsel. Warum sollte das bei Ihrer Datenbank anders sein? ## Das Problem: Niemand schaut hin Die meisten Unternehmen kümmern sich nicht um ihre Datenbank – bis es zu spät ist. Das System läuft ja. Die Software funktioniert. Alles gut. Bis es nicht mehr gut ist. > **Am 12. Februar 2026 hat das BSI eine hochkritische Warnung herausgegeben:** PostgreSQL-Versionen 14.21 bis 18.2 haben fünf gravierende Sicherheits-Lücken (CVE-2026-2003 bis CVE-2026-2007). CVSS-Score: 8,8 von 10. Angreifer können aus der Ferne auf Systeme zugreifen, Code ausführen, Daten offenlegen. Dieses konkrete Problem lässt sich durch ein Update lösen. Aber wer prüft regelmäßig, ob Ihre Datenbank auf dem aktuellen Stand ist? Wer schaut auf die Performance, die Indexe, die Datenkonsistenz? In den meisten Unternehmen: niemand. ## Drei Risiken, die Sie kennen sollten ### 1. Sicherheits-Lücken Neue Schwachstellen werden laufend entdeckt. Patches werden regelmäßig veröffentlicht. Aber nur, wenn Sie eine unterstützte Version betreiben. **PostgreSQL 13 ist seit November 2025 End-of-Life.** Keine Patches mehr. Keine Sicherheits-Updates. PostgreSQL unterstützt Major-Versionen nur fünf Jahre – wer noch auf einer abgelaufenen Version läuft, ist ungeschützt. ### 2. Performance-Degradation Datenbanken werden langsamer – schleichend, über Monate und Jahre. Indizes veralten, Statistiken stimmen nicht mehr, der Speicher wächst. Das fällt nicht auf. Bis Ihre Mitarbeiter sich beschweren, dass „alles so langsam ist". Eine jährliche Inspektion erkennt diese Probleme, bevor sie spürbar werden oder es zu Datenverlust kommt. ### 3. Die Sicherung, die keiner testet Irgendwann hat jemand ein Backup eingerichtet. Seitdem läuft es – vermutlich. Aber: Wann wurde zuletzt geprüft, ob sich die Sicherung tatsächlich zurückspielen lässt? Ob sie vollständig ist? Ob sie überhaupt noch läuft? Ein Backup, das im Ernstfall nicht funktioniert, ist schlimmer als kein Backup – weil Sie sich in falscher Sicherheit wiegen. ## Was eine Datenbank-Inspektion beinhaltet Eine jährliche Inspektion dauert etwa zwei Stunden und umfasst: - **Versions-Check:** Läuft eine unterstützte PostgreSQL-Version? - **Sicherheits-Status:** Sind alle Patches eingespielt? - **Performance-Analyse:** Wo wird es langsam? Welche Optimierungen sind sinnvoll? - **Backup-Test:** Wird Ihre Datenbank gesichert? Und die entscheidende Frage: Lässt sich die Sicherung auch tatsächlich zurückspielen? - **Speicher-Check:** Wie schnell wächst die Datenbank? Wann wird der Platz knapp? - **Protokoll-Prüfung:** Gibt es Fehler oder Warnungen, die niemand bemerkt hat? Am Ende bekommen Sie einen kompakten Bericht mit klaren Handlungs-Empfehlungen. Keine 50-Seiten-Dokumentation. Eine halbe Seite mit dem, was wichtig ist. ## Einmal im Jahr. Bevor es teuer wird. Sie würden nicht fünf Jahre ohne Inspektion fahren. Ihre Datenbank verdient dieselbe Aufmerksamkeit. **Vereinbaren Sie einen Termin** – wir schauen gemeinsam nach Ihrer Datenbank. Einmal im Jahr. Bevor etwas kaputtgeht. [Erstgespräch vereinbaren](/kontakt?ref=datenbank-inspektion) --- Title: quando – Intuitive Date Calculations for Go URL: https://www.jakoubek.net/open-source/quando/ Description: A Go library for intuitive date calculations with a fluent API. Immutable, zero dependencies, month-end aware, and DST-safe. Tags: Go, Open-Source, Library, Date, Time Published: 2026-02-12 **quando** is a Go library for intuitive date calculations with a fluent API. It provides a simple, chainable interface for date operations while being immutable, having zero external dependencies, and handling edge cases like month-end dates and daylight saving time transitions correctly. ## What is quando? Date calculations in Go's standard `time` package can be verbose and error-prone. Simple operations like "add 3 months" or "go to the last day of the month" require careful handling of edge cases. quando provides a fluent, immutable API that makes date operations more intuitive and less error-prone while maintaining full compatibility with Go's `time.Time`. ## Why this library? I frequently work with date calculations in business applications – subscription periods, billing cycles, report ranges, and scheduling tasks. The standard library's approach often leads to repetitive code and subtle bugs with month boundaries. The practical trigger was my existing [DatesAPI](https://www.datesapi.net/) web service – a small demo project that provides formatted date strings via a simple API. When I wanted to add more advanced date operations to it, I realized I needed a solid foundation for date calculations first. Rather than building that logic directly into the service, I extracted it into a standalone library. quando was born from the need for a simple, chainable API that handles edge cases correctly and makes the code more readable. ## Installation ```bash go get code.beautifulmachines.dev/jakoubek/quando ``` ## Quick Start ```go package main import ( "fmt" "time" "code.beautifulmachines.dev/jakoubek/quando" ) func main() { // Start with today's date today := quando.From(time.Now()) // Add 3 months and 5 days future := today.Add(3, quando.Months).Add(5, quando.Days) fmt.Printf("In 3 months and 5 days: %s\n", future.Time()) // Subtract 2 weeks past := today.Sub(2, quando.Weeks) fmt.Printf("2 weeks ago: %s\n", past.Time()) // Go to the last day of the month monthEnd := today.EndOf(quando.Months) fmt.Printf("End of this month: %s\n", monthEnd.Time()) // Chain operations result := today. Add(1, quando.Months). StartOf(quando.Months). Add(14, quando.Days) fmt.Printf("15th of next month: %s\n", result.Time()) } ``` ## Features ### Fluent API quando provides a chainable API that makes date calculations readable and expressive: ```go // Traditional approach with time package t := time.Now() t = t.AddDate(0, 3, 0) // Add 3 months t = t.AddDate(0, 0, 7) // Add 7 days // quando approach result := quando.From(time.Now()). Add(3, quando.Months). Add(7, quando.Days). Time() ``` ### Month-End Awareness quando handles month-end dates correctly, which is crucial for business calculations: ```go // January 31 + 1 month = February 28/29 (last day of Feb) jan31 := quando.From(time.Date(2024, 1, 31, 0, 0, 0, 0, time.UTC)) result := jan31.Add(1, quando.Months) fmt.Println(result.Time()) // 2024-02-29 (leap year) // February 29 + 1 year = February 28 (non-leap year) feb29 := quando.From(time.Date(2024, 2, 29, 0, 0, 0, 0, time.UTC)) result = feb29.Add(1, quando.Years) fmt.Println(result.Time()) // 2025-02-28 ``` ### Immutability All operations return new instances, making quando safe for concurrent use: ```go start := quando.From(time.Date(2024, 1, 15, 0, 0, 0, 0, time.UTC)) end := start.Add(3, quando.Months) // start is unchanged fmt.Println(start.Time()) // 2024-01-15 fmt.Println(end.Time()) // 2024-04-15 ``` ### Start and End of Period Navigate to the beginning or end of various time periods: ```go now := quando.Now() // Month boundaries monthStart := now.StartOf(quando.Months) monthEnd := now.EndOf(quando.Months) // Week boundaries (Monday-based) weekStart := now.StartOf(quando.Weeks) weekEnd := now.EndOf(quando.Weeks) // Year boundaries yearStart := now.StartOf(quando.Years) yearEnd := now.EndOf(quando.Years) // Quarter boundaries quarterStart := now.StartOf(quando.Quarters) quarterEnd := now.EndOf(quando.Quarters) ``` ### Day Navigation Find the next or previous occurrence of a weekday: ```go now := quando.Now() // Next Friday nextFriday := now.Next(time.Friday) // Previous Monday lastMonday := now.Prev(time.Monday) ``` ### Human-Readable Differences Calculate and display durations between dates: ```go start := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC) end := time.Date(2026, 3, 15, 0, 0, 0, 0, time.UTC) duration := quando.Diff(start, end) fmt.Println(duration.Human()) // "2 years, 2 months" fmt.Println(duration.Months()) // 26 fmt.Println(duration.Days()) // 804 ``` ### Parsing and Formatting Automatic format detection and multilingual formatting: ```go // Automatic format detection date, _ := quando.Parse("2026-02-09") // ISO format date, _ = quando.Parse("09.02.2026") // EU format // Relative dates via ParseRelative date, _ = quando.ParseRelative("+3 days") // 3 days from now date, _ = quando.ParseRelative("-1 week") // 1 week ago date, _ = quando.ParseRelative("tomorrow") // Tomorrow // Formatting date.Format(quando.ISO) // "2026-02-09" date.Format(quando.Long) // "February 9, 2026" // Multilingual dateDE := quando.Now().WithLang(quando.DE) fmt.Println(dateDE.Format(quando.Long)) // "9. Februar 2026" ``` ### Date Inspection ```go date := quando.Now() week := date.WeekNumber() // ISO 8601 week number quarter := date.Quarter() // 1-4 dayOfYear := date.DayOfYear() // 1-366 ``` ### Zero Dependencies quando uses only Go's standard library (`time` package). No external dependencies means: - Smaller binary size - Faster builds - No dependency conflicts - No supply chain security concerns ## Requirements - Go 1.22 or higher ## Links - **Forgejo:** [code.beautifulmachines.dev/jakoubek/quando](https://code.beautifulmachines.dev/jakoubek/quando) - **GitHub Mirror:** [github.com/jakoubek/quando](https://github.com/jakoubek/quando) - **Go Package:** [pkg.go.dev/code.beautifulmachines.dev/jakoubek/quando](https://pkg.go.dev/code.beautifulmachines.dev/jakoubek/quando) ## License MIT License – see [LICENSE](https://code.beautifulmachines.dev/jakoubek/quando/src/branch/main/LICENSE). --- Title: E-Rechnungen – Bereit für die Pflicht? URL: https://www.jakoubek.net/e-rechnungen/ Description: Ab 2025 müssen alle Unternehmen E-Rechnungen empfangen können. Ich helfe Ihnen bei der Umsetzung – von der Bestandsaufnahme bis zur Integration. Tags: E-Rechnung, ZUGFeRD, XRechnung, Digitalisierung Published: 2026-02-05 Seit dem 1. Januar 2025 müssen alle Unternehmen in Deutschland elektronische Rechnungen im B2B-Bereich empfangen können. Ab 2027 wird schrittweise auch der Versand zur Pflicht. Viele Unternehmen – gerade im Mittelstand – sind darauf noch nicht vorbereitet. ## Was bedeutet E-Rechnungspflicht konkret? Eine E-Rechnung ist nicht einfach ein PDF per E-Mail. Es handelt sich um ein strukturiertes Datenformat (XML), das nach der europäischen Norm EN 16931 aufgebaut ist. Die zwei gängigen Formate in Deutschland sind: - **ZUGFeRD** (ab Version 2.0.1) – ein hybrides Format: PDF mit eingebetteten XML-Daten - **XRechnung** – reines XML-Format, besonders im öffentlichen Sektor verbreitet ## Die Fristen | Ab wann | Was | |---------|-----| | 01.01.2025 | Alle Unternehmen müssen E-Rechnungen **empfangen** können | | Bis 31.12.2026 | Papier und PDF noch erlaubt (mit Zustimmung des Empfängers) | | 01.01.2027 | **Versandpflicht** für Unternehmen über 800.000 € Jahresumsatz | | 01.01.2028 | **Versandpflicht** für alle Unternehmen | ## Mein Angebot: E-Rechnungs-Check In einem kompakten Check analysiere ich Ihre aktuelle Rechnungsstellung und -verarbeitung: - **Bestandsaufnahme:** Wie erstellen und empfangen Sie heute Rechnungen? Welche Software ist im Einsatz? - **Analyse:** Kann Ihre bestehende Software E-Rechnungen verarbeiten? Wo gibt es Lücken? - **Handlungsempfehlung:** Konkreter Maßnahmenplan mit Prioritäten und Zeitrahmen - **Checkliste:** Dokumentation zum Abhaken – damit nichts vergessen wird ### Ablauf 1. Vorgespräch (15 Min, kostenfrei) – kurze Klärung Ihrer Situation 2. Analyse (ca. 60 Min) – Ihre Systeme, Prozesse und Anforderungen 3. Ergebnis – Schriftliche Handlungsempfehlung mit konkreten nächsten Schritten **Investition: 490 € zzgl. MwSt.** ## Darüber hinaus Wenn Ihre bestehende Software keine E-Rechnungen unterstützt, kann ich bei der Integration helfen – von der ZUGFeRD-Erzeugung bis zur Anbindung an Buchhaltungssysteme. [Sprechen Sie mich an](/kontakt?ref=e-rechnungen). ## Warum ich? Seit über 25 Jahren entwickle ich Geschäftssoftware für den Mittelstand. Ich kenne die typischen Systemlandschaften – von DATEV über individuelle Faktura-Lösungen bis hin zu ERP-Systemen. Mein Fokus liegt auf pragmatischen Lösungen, die zu Ihrem Unternehmen passen. --- Title: kanboard-api – Go-Client für die Kanboard-JSON-RPC-API URL: https://www.jakoubek.net/open-source/kanboard-api/ Description: Eine Go-Bibliothek für den Zugriff auf die Kanboard-API. Ermöglicht das Verwalten von Projekten, Tasks, Kommentaren und Tags mit einer fluent API. Tags: Go, API, Kanboard, Open-Source, Library Updated: 2026-02-03 **kanboard-api** ist eine Go-Bibliothek für den Zugriff auf die [Kanboard](https://kanboard.org/) JSON-RPC API. Die Library bietet eine fluent, verkettbare API für die Integration von Kanboard in Go-Anwendungen. ## Was ist Kanboard? [Kanboard](https://kanboard.org/) ist eine beliebte Open-Source-Projektmanagement-Software mit Fokus auf die Kanban-Methode. Mit über 9.000 GitHub-Stars ist es eine der meistgenutzten Self-Hosted-Lösungen für Aufgabenverwaltung. Die Software ist schlank, schnell und lässt sich gut automatisieren. ## Warum diese Library? Ich nutze Kanboard täglich für meine Projektverwaltung und wollte Tasks automatisiert erstellen, verschieben und aktualisieren können – zum Beispiel aus Automatisierungsplattformen oder eigenen Tools heraus. ## Installation ```bash go get code.beautifulmachines.dev/jakoubek/kanboard-api ``` ## Authentifizierung Die Library unterstützt zwei Authentifizierungsmethoden: ```go // API Token (empfohlen) client := kanboard.NewClient("https://kanboard.example.com"). WithAPIToken("your-api-token") // Basic Auth client := kanboard.NewClient("https://kanboard.example.com"). WithBasicAuth("admin", "password") ``` ## Schnellstart ```go package main import ( "context" "fmt" "log" "time" kanboard "code.beautifulmachines.dev/jakoubek/kanboard-api" ) func main() { ctx := context.Background() client := kanboard.NewClient("https://kanboard.example.com"). WithAPIToken("your-api-token"). WithTimeout(30 * time.Second) // Task mit der Fluent API erstellen task, err := client.Board(1).CreateTaskFromParams(ctx, kanboard.NewTask("Mein Task"). WithDescription("Beschreibung"). WithPriority(2). WithTags("urgent", "backend")) if err != nil { log.Fatal(err) } fmt.Printf("Task erstellt: %d\n", task.ID) } ``` ## Fluent API Die Fluent API ermöglicht verkettete, kontextbezogene Operationen: ```go // Board-Operationen board := client.Board(projectID) tasks, _ := board.GetTasks(ctx, kanboard.StatusActive) columns, _ := board.GetColumns(ctx) // Task-Operationen task := client.Task(taskID) task.Close(ctx) task.MoveToNextColumn(ctx) task.AddTag(ctx, "reviewed") task.AddComment(ctx, userID, "Kommentar") ``` ## Task-Erstellung Mit `TaskParams` lassen sich Tasks flexibel konfigurieren: ```go params := kanboard.NewTask("Task-Titel"). WithDescription("Detaillierte Beschreibung"). WithCategory(categoryID). WithOwner(userID). WithColor("red"). WithPriority(3). WithDueDate(time.Now().Add(7 * 24 * time.Hour)). WithTags("feature", "v2.0"). InColumn(columnID) task, err := client.Board(projectID).CreateTaskFromParams(ctx, params) ``` ## Task-Bewegung ```go // Zur nächsten/vorherigen Spalte client.Task(taskID).MoveToNextColumn(ctx) client.Task(taskID).MoveToPreviousColumn(ctx) // In bestimmte Spalte client.Task(taskID).MoveToColumn(ctx, columnID) // In anderes Projekt client.Task(taskID).MoveToProject(ctx, newProjectID) ``` ## Fehlerbehandlung Die Library bietet typisierte Fehler: ```go task, err := client.GetTask(ctx, taskID) if err != nil { if kanboard.IsNotFound(err) { // Task nicht gefunden } if kanboard.IsUnauthorized(err) { // Authentifizierung fehlgeschlagen } } ``` ## Thread-Sicherheit Der Client ist thread-safe und kann von mehreren Goroutines parallel genutzt werden. ## Links - **Forgejo:** [code.beautifulmachines.dev/jakoubek/kanboard-api](https://code.beautifulmachines.dev/jakoubek/kanboard-api) - **GitHub-Mirror:** [github.com/jakoubek/kanboard-api](https://github.com/jakoubek/kanboard-api) - **Go Package:** [pkg.go.dev/code.beautifulmachines.dev/jakoubek/kanboard-api](https://pkg.go.dev/code.beautifulmachines.dev/jakoubek/kanboard-api) ## Lizenz MIT License – siehe [LICENSE](https://code.beautifulmachines.dev/jakoubek/kanboard-api/src/branch/main/LICENSE). --- Title: bookstack-api – Go-Client für die BookStack-REST-API URL: https://www.jakoubek.net/open-source/bookstack-api/ Description: Eine Go-Bibliothek für den Zugriff auf die BookStack-API. Ermöglicht das Lesen, Erstellen und Aktualisieren von Büchern, Kapiteln, Seiten und Anhängen. Tags: Go, API, BookStack, Open-Source, Library Updated: 2026-02-03 **bookstack-api** ist eine Go-Bibliothek für den Zugriff auf die [BookStack](https://www.bookstackapp.com/) REST API. Die Library hat keine externen Abhängigkeiten und nutzt moderne Go-Features wie Iteratoren (Go 1.23+). ## Was ist BookStack? [BookStack](https://www.bookstackapp.com/) ist eine beliebte Open-Source-Plattform für Dokumentation und Wissensmanagement. Mit über 18.000 GitHub-Stars ist es eine der populärsten Self-Hosted-Wiki-Lösungen. Die Inhalte werden in einer dreistufigen Hierarchie organisiert: **Regale → Bücher → Kapitel → Seiten**. ## Warum diese Library? Ich nutze BookStack für interne Dokumentation und wollte Inhalte programmatisch erstellen und aktualisieren können – zum Beispiel für automatisierte Statusberichte oder die Synchronisation von Dokumentation aus anderen Quellen. ## Installation ```bash go get code.beautifulmachines.dev/jakoubek/bookstack-api ``` ## Authentifizierung BookStack verwendet Token-basierte Authentifizierung. Erstellen Sie einen API-Token in Ihrem BookStack-Benutzerprofil unter **API Tokens**. ```bash export BOOKSTACK_TOKEN_ID="your-token-id" export BOOKSTACK_TOKEN_SECRET="your-token-secret" ``` ## Schnellstart ```go package main import ( "context" "fmt" "log" "os" bookstack "code.beautifulmachines.dev/jakoubek/bookstack-api" ) func main() { client, err := bookstack.NewClient(bookstack.Config{ BaseURL: "https://docs.example.com", TokenID: os.Getenv("BOOKSTACK_TOKEN_ID"), TokenSecret: os.Getenv("BOOKSTACK_TOKEN_SECRET"), }) if err != nil { log.Fatal(err) } ctx := context.Background() // Alle Bücher auflisten books, err := client.Books.List(ctx, nil) if err != nil { log.Fatal(err) } for _, book := range books { fmt.Printf("%d: %s\n", book.ID, book.Name) } } ``` ## Weitere Beispiele ### Volltextsuche ```go results, err := client.Search.Search(ctx, "deployment guide", nil) for _, r := range results { fmt.Printf("[%s] %s\n", r.Type, r.Name) } ``` ### Seite als Markdown exportieren ```go md, err := client.Pages.ExportMarkdown(ctx, 42) fmt.Println(string(md)) ``` ### Neue Seite erstellen ```go page, err := client.Pages.Create(ctx, &bookstack.PageCreateRequest{ BookID: 1, Name: "Neue Seite", Markdown: "# Überschrift\n\nInhalt der Seite.", }) ``` ### Alle Bücher durchiterieren Die Library nutzt Go 1.23+ Iteratoren für speichereffiziente Pagination: ```go for book, err := range client.Books.ListAll(ctx) { if err != nil { log.Fatal(err) } fmt.Println(book.Name) } ``` ## Verfügbare Services | Service | Operationen | |---------|-------------| | `Books` | List, ListAll, Get | | `Pages` | List, ListAll, Get, Create, Update, Delete, ExportMarkdown, ExportPDF | | `Chapters` | List, ListAll, Get | | `Shelves` | List, ListAll, Get | | `Search` | Search | | `Attachments` | List, Get, Create, Update, Delete | | `Comments` | List, Get, Create, Update, Delete | ## Voraussetzungen - Go 1.23 oder höher - BookStack-Instanz mit aktivierter API ## Links - **Forgejo:** [code.beautifulmachines.dev/jakoubek/bookstack-api](https://code.beautifulmachines.dev/jakoubek/bookstack-api) - **GitHub-Mirror:** [github.com/jakoubek/bookstack-api](https://github.com/jakoubek/bookstack-api) - **Go Package:** [pkg.go.dev/code.beautifulmachines.dev/jakoubek/bookstack-api](https://pkg.go.dev/code.beautifulmachines.dev/jakoubek/bookstack-api) ## Lizenz MIT License – siehe [LICENSE](https://code.beautifulmachines.dev/jakoubek/bookstack-api/src/branch/main/LICENSE). --- Title: Unternehmensspezifisches CLI-Tool – Ihre Systeme, ein Befehl URL: https://www.jakoubek.net/projekt/enterprise-cli/ Description: Maßgeschneiderte Kommandozeilen-Tools für Unternehmen. Verbinden Sie ERP, CRM, Ticketsystem und interne Anwendungen in einer einheitlichen Schnittstelle – bereit für Automatisierung und KI-Agenten. Tags: CLI, Automatisierung, Integration, KI Published: 2026-01-23 In jedem Unternehmen wächst über die Jahre eine Landschaft aus verschiedenen Systemen: ERP, CRM, Ticketsystem, Zeiterfassung, Datenbanken, Monitoring. Mitarbeiter springen täglich zwischen zehn Browser-Tabs und fünf Anwendungen hin und her. Automatisierung scheitert, weil die Systeme nicht miteinander sprechen. **Was wäre, wenn all diese Systeme über einen einzigen, einheitlichen Befehl erreichbar wären?** ## Das Konzept: Ein CLI-Tool für Ihr Unternehmen Ein **Command Line Interface (CLI)** ist eine textbasierte Schnittstelle, über die Befehle direkt eingegeben werden. Was im ersten Moment nach Technik der 80er Jahre klingt, ist in Wirklichkeit die effizienteste Form der Mensch-Maschine-Interaktion – und die perfekte Grundlage für moderne KI-Integration. Stellen Sie sich vor: ```bash # Neues Ticket anlegen firma ticket erstellen --kunde "Müller GmbH" --priorität hoch --beschreibung "Server antwortet nicht" # Zeit buchen firma zeit buchen --projekt SAP-Migration --stunden 2.5 --notiz "Datenanalyse" # Umsatzreport erstellen firma report umsatz --quartal Q4 --format pdf # Kundendaten abrufen firma kunde suchen "Müller" --json ``` Ein einziges Tool, das alle Ihre internen Systeme verbindet. Kein Tab-Wechsel, kein Einloggen in verschiedene Oberflächen, keine manuellen Zwischenschritte. ## Warum CLI statt Web-Oberfläche? | Aspekt | Web-Oberfläche | CLI-Tool | |--------|----------------|----------| | **Entwicklungsaufwand** | Hoch (Frontend, UX, Responsive Design) | Gering (Backend + Befehlsstruktur) | | **KI-Integration** | Komplex (Screen-Scraping, RPA) | Trivial (Text rein, Text raus) | | **Automatisierung** | Erfordert spezielle Tools | Native Shell-Skripte | | **Geschwindigkeit** | Klick → Warten → Klick → Warten | Ein Befehl, sofortiges Ergebnis | | **Wartung** | App-Updates, Browser-Kompatibilität | Einfaches Binary-Update | | **Power-User** | Oft eingeschränkt | Volle Kontrolle | Das bedeutet nicht, dass Web-Oberflächen überflüssig werden. Aber für wiederkehrende Aufgaben, für Automatisierung und für die Integration von KI-Assistenten ist ein CLI-Tool die bessere Wahl. ## Der entscheidende Vorteil: KI-Ready Die großen Sprachmodelle (ChatGPT, Claude, Gemini) können Text verarbeiten, aber keine Maus bewegen. Ein CLI-Tool ist die **natürliche Schnittstelle für KI-Agenten**: - Der Agent erhält einen Befehl: *„Erstelle ein Ticket für den Server-Ausfall bei Kunde Müller"* - Er übersetzt das in: `firma ticket erstellen --kunde "Müller GmbH" --beschreibung "Server-Ausfall"` - Das Tool führt den Befehl aus und liefert strukturierte Rückmeldung - Der Agent verarbeitet das Ergebnis und antwortet dem Nutzer Damit wird Ihr internes Wissen und Ihre Prozesse für KI-Assistenten zugänglich – ohne dass sensible Daten das Unternehmen verlassen. ## Was ich für Sie entwickle Ich entwickle seit Jahren mein eigenes CLI-Tool für die tägliche Arbeit. Es verbindet Ticketsystem, Zeiterfassung, Checklisten, E-Mail und Datenbanken. Ich nutze es jeden Tag, auch in der Zusammenarbeit mit KI-Agenten. Diese Erfahrung bringe ich in Ihr Projekt ein: ### Analyse & Konzeption - Bestandsaufnahme Ihrer Systemlandschaft - Identifikation der wichtigsten Anwendungsfälle - Konzeption der Befehlsstruktur - Architektur-Empfehlungen ### Entwicklung - Entwicklung des CLI-Tools in Go (kompiliert zu einem einzigen Binary) - Anbindung an Ihre bestehenden Systeme (REST-APIs, Datenbanken, SOAP) - Implementierung von Authentifizierung und Berechtigungen - Strukturierte Ausgabe für Menschen (Tabellen) und Maschinen (JSON) ### Dokumentation & Schulung - Technische Dokumentation - Benutzerhandbuch mit Beispielen - Schulung Ihres Teams - Wissenstransfer für Weiterentwicklung ## Typische Anbindungen - **ERP-Systeme**: SAP, Microsoft Dynamics, Sage, DATEV - **CRM**: Salesforce, HubSpot, Pipedrive, interne Lösungen - **Ticketsysteme**: Jira, Kanboard, Redmine, ServiceNow - **Zeiterfassung**: Mite, Clockify, Toggl, SAP-Zeitwirtschaft - **Datenbanken**: PostgreSQL, MySQL, SQL Server, Oracle, SQL Anywhere - **Kommunikation**: E-Mail (IMAP/SMTP), Slack, Microsoft Teams - **Monitoring**: Prometheus, Grafana, Nagios, eigene Systeme Die Liste ist nicht abschließend. Wenn ein System eine API oder Datenbankzugriff bietet, kann es angebunden werden. ## Technologie Das CLI-Tool wird in **Go** entwickelt. Go ist eine moderne Programmiersprache von Google, die sich besonders für CLI-Tools eignet: - **Single Binary**: Ein einziges ausführbares Programm, keine Abhängigkeiten - **Cross-Platform**: Läuft auf Windows, macOS und Linux - **Performant**: Schnelle Ausführung, geringer Ressourcenverbrauch - **Wartbar**: Klarer, lesbarer Code für langfristige Pflege Das Tool gehört Ihnen: Der Quellcode liegt in Ihrem Repository, Ihr Team kann es weiterentwickeln, es gibt keine Lizenzkosten oder Vendor Lock-in. ## Ablauf eines Projekts 1. **Erstgespräch** (kostenlos): Wir besprechen Ihre Situation und prüfen, ob ein CLI-Tool für Sie sinnvoll ist. 2. **Workshop** (1 Tag): Gemeinsame Analyse Ihrer Systeme und Prozesse. Am Ende steht ein konkretes Konzept. 3. **Entwicklung** (4-12 Wochen): Iterative Entwicklung des Tools. Sie sehen regelmäßig Zwischenstände und können Feedback geben. 4. **Rollout**: Einführung im Team, Schulung, Dokumentation. 5. **Begleitung** (optional): Langfristige Unterstützung bei Erweiterungen und Wartung. ## Für wen ist das geeignet? Ein unternehmensspezifisches CLI-Tool lohnt sich besonders für: - **Unternehmen mit gewachsener IT-Landschaft**: Viele Systeme, die nicht gut zusammenspielen - **Teams mit technischer Affinität**: Entwickler, Admins, Power-User, die CLI gewohnt sind - **Unternehmen mit KI-Strategie**: Die KI-Agenten für interne Prozesse einsetzen wollen - **Firmen mit Automatisierungsbedarf**: Viele manuelle Schritte zwischen Systemen ## Interesse? Lassen Sie uns in einem unverbindlichen Gespräch herausfinden, ob ein CLI-Tool für Ihre Situation sinnvoll ist. [Kontakt aufnehmen](/kontakt?ref=enterprise-cli) --- Title: Einführung in Go-Webserver URL: https://www.jakoubek.net/posts/einfuehrung-in-go-webserver/ Description: Ein Überblick über Go-Webserver – Architektur, Frameworks und warum Go eine ausgezeichnete Wahl für Web-Backends ist. Tags: Go, Golang, Webserver Published: 2026-01-15 Go ist eine ausgezeichnete Wahl für den Betrieb von Webservern. Die Sprache bringt eine leistungsfähige Standard-Library mit, die HTTP-Server ohne externe Abhängigkeiten ermöglicht. ## net/http – die Standard-Library Das `net/http`-Paket der Go-Standard-Library bietet alles, was man für einen einfachen Webserver braucht: ```go package main import ( "fmt" "net/http" ) func main() { http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintln(w, "Hallo, Welt!") }) http.ListenAndServe(":8080", nil) } ``` ## Frameworks Für komplexere Anwendungen gibt es etablierte Frameworks: - **[Gin](https://gin-gonic.com/)** – schnelles HTTP-Framework mit Router, Middleware-Unterstützung und JSON-Rendering - **[Echo](https://echo.labstack.com/)** – minimalistisches Framework mit ähnlichem Ansatz - **[Chi](https://github.com/go-chi/chi)** – leichtgewichtiger Router, der eng an `net/http` bleibt ## Vorteile von Go-Webservern ### Kompilierte Binary Der Server wird als einzelne Binary ausgeliefert. Kein Interpreter, keine Runtime-Abhängigkeiten auf dem Zielsystem. ### Geringer Ressourcenverbrauch Go-Webserver benötigen typischerweise wenige Megabyte RAM im Leerlauf. Das ermöglicht den Betrieb auf kleinen VPS-Instanzen. ### Einfaches Deployment ```bash # Binary bauen go build -o server . # Server starten ./server ``` ### Eingebettete Ressourcen Mit dem `embed`-Paket lassen sich statische Dateien und Templates direkt in die Binary einbetten: ```go //go:embed static/* var staticFiles embed.FS ``` ## Fazit Für Web-Backends – vom kleinen Microservice bis zur vollständigen Website – bietet Go eine elegante Kombination aus Einfachheit, Performance und Wartbarkeit. --- Title: checkvist-api – Go-Client für die Checkvist-API URL: https://www.jakoubek.net/open-source/checkvist-api/ Description: Eine Go-Bibliothek für den Zugriff auf die Checkvist-API. Ermöglicht das Verwalten von Checklisten, Tasks und Notizen mit einer typsicheren, idiomatischen API. Tags: Go, API, Checkvist, Open-Source, Library Updated: 2026-02-03 **checkvist-api** ist eine typsichere, idiomatische Go-Bibliothek für den Zugriff auf die [Checkvist](https://checkvist.com/) API. ## Was ist Checkvist? [Checkvist](https://checkvist.com/) ist ein leistungsfähiger Outliner und Aufgabenmanager, der sich besonders für hierarchische Listen und komplexe Projekte eignet. Die Stärke liegt in der Tastatur-orientierten Bedienung und der Möglichkeit, Aufgaben beliebig tief zu verschachteln. ## Warum diese Library? Ich nutze Checkvist für meine persönliche Aufgabenverwaltung und wollte Tasks aus anderen Systemen synchronisieren oder automatisch erstellen können – zum Beispiel wiederkehrende Aufgaben oder Einträge aus Automatisierungsworkflows. ## Installation ```bash go get code.beautifulmachines.dev/jakoubek/checkvist-api ``` ## Authentifizierung Die Library übernimmt die Authentifizierung automatisch – inklusive Token-Refresh: ```go client := checkvist.NewClient("your-email@example.com", "your-api-key") ``` Bei aktivierter Zwei-Faktor-Authentifizierung: ```go err := client.AuthenticateWith2FA(ctx, "123456") ``` ## Schnellstart ```go package main import ( "context" "fmt" "log" "code.beautifulmachines.dev/jakoubek/checkvist-api" ) func main() { client := checkvist.NewClient("your-email@example.com", "your-api-key") ctx := context.Background() // Alle Checklisten auflisten checklists, err := client.Checklists().List(ctx) if err != nil { log.Fatal(err) } for _, cl := range checklists { fmt.Printf("Checkliste: %s (%d Tasks)\n", cl.Name, cl.TaskCount) } // Neuen Task erstellen task, err := client.Tasks(checklists[0].ID).Create(ctx, checkvist.NewTask("Einkaufen gehen"). WithDueDate(checkvist.DueTomorrow). WithPriority(1). WithTags("einkauf", "privat"), ) if err != nil { log.Fatal(err) } fmt.Printf("Task erstellt: %s (ID: %d)\n", task.Content, task.ID) } ``` ## Checklisten verwalten ```go // Alle Checklisten auflisten checklists, err := client.Checklists().List(ctx) // Einzelne Checkliste abrufen checklist, err := client.Checklists().Get(ctx, checklistID) // Neue Checkliste erstellen checklist, err := client.Checklists().Create(ctx, "Meine neue Liste") // Checkliste umbenennen checklist, err := client.Checklists().Update(ctx, checklistID, "Neuer Name") ``` ## Tasks verwalten ```go // Task mit Builder-Pattern erstellen task, err := client.Tasks(checklistID).Create(ctx, checkvist.NewTask("Task-Inhalt"). WithParent(parentID). // Als Subtask erstellen WithDueDate(checkvist.DueAt(time.Now().AddDate(0, 0, 7))). WithPriority(1). // 1 = höchste, 2 = hoch, 0 = normal WithTags("arbeit", "wichtig"), ) // Task abschließen/wiedereröffnen task, err := client.Tasks(checklistID).Close(ctx, taskID) task, err := client.Tasks(checklistID).Reopen(ctx, taskID) ``` ## Fälligkeitsdaten Die Library bietet praktische Helfer für Fälligkeitsdaten: ```go checkvist.DueToday // Heute checkvist.DueTomorrow // Morgen checkvist.DueInDays(5) // In 5 Tagen checkvist.DueAt(time.Time) // Bestimmtes Datum checkvist.DueString("friday") // Smart Syntax ``` ## Notizen (Kommentare) ```go // Notizen eines Tasks auflisten notes, err := client.Notes(checklistID, taskID).List(ctx) // Notiz hinzufügen note, err := client.Notes(checklistID, taskID).Create(ctx, "Mein Kommentar") ``` ## Fehlerbehandlung Die Library bietet typisierte Fehler: ```go task, err := client.Tasks(checklistID).Get(ctx, taskID) if err != nil { if errors.Is(err, checkvist.ErrNotFound) { fmt.Println("Task nicht gefunden") } else if errors.Is(err, checkvist.ErrUnauthorized) { fmt.Println("Ungültige Anmeldedaten") } else if errors.Is(err, checkvist.ErrRateLimited) { fmt.Println("Rate-Limit erreicht") } } ``` ## Konfiguration Der Client lässt sich anpassen: ```go client := checkvist.NewClient("email", "api-key", checkvist.WithTimeout(60 * time.Second), checkvist.WithRetryConfig(checkvist.RetryConfig{ MaxRetries: 5, BaseDelay: 2 * time.Second, }), ) ``` ## Thread-Sicherheit Der Client ist thread-safe und übernimmt automatisch die Token-Verwaltung. ## Links - **Forgejo:** [code.beautifulmachines.dev/jakoubek/checkvist-api](https://code.beautifulmachines.dev/jakoubek/checkvist-api) - **GitHub-Mirror:** [github.com/jakoubek/checkvist-api](https://github.com/jakoubek/checkvist-api) - **Go Package:** [pkg.go.dev/code.beautifulmachines.dev/jakoubek/checkvist-api](https://pkg.go.dev/code.beautifulmachines.dev/jakoubek/checkvist-api) ## Lizenz MIT License – siehe [LICENSE](https://code.beautifulmachines.dev/jakoubek/checkvist-api/src/branch/main/LICENSE). --- Title: PostgreSQL – Die führende Open-Source-Datenbank URL: https://www.jakoubek.net/postgresql/ Description: PostgreSQL-Entwicklung und Beratung: Datenbankdesign, Performance-Tuning, Migration. Über 20 Jahre Erfahrung mit relationalen Datenbanken. Tags: PostgreSQL, Datenbank, Open-Source Published: 2025-12-18 PostgreSQL ist eine leistungsstarke, objektrelationale Open-Source-Datenbank mit über 35 Jahren Entwicklungsgeschichte. Ich setze PostgreSQL seit vielen Jahren in Kundenprojekten ein – für Backend-Systeme, APIs und datenintensive Anwendungen. ## Warum PostgreSQL? * **Open Source**: Keine Lizenzkosten, auch für kommerzielle Nutzung * **Zuverlässigkeit**: ACID-konform, bewährt in kritischen Anwendungen * **Erweiterbarkeit**: JSON, Volltextsuche, PostGIS, eigene Datentypen * **Performance**: Komplexe Abfragen, große Datenmengen, parallele Verarbeitung * **Standards**: Hohe SQL-Konformität, einfache Migration ## Meine PostgreSQL-Leistungen * **Datenbankdesign**: Entwurf von Schemas, Normalisierung, Indexierung * **Entwicklung**: Stored Functions, Trigger, Views, komplexe Queries * **Performance-Optimierung**: EXPLAIN-Analyse, Index-Tuning, Query-Optimierung * **Migration**: Umstellung von MySQL, SQL Server, SQL Anywhere auf PostgreSQL * **Betrieb**: Backup-Strategien, Monitoring, Updates ## PostgreSQL in meinen Projekten Ich nutze PostgreSQL als Datenbank für: * **Go-Backend-Services**: REST-APIs mit Gin oder Echo * **Webanwendungen**: Datenhaltung für Web-Frontends * **Datenintegration**: Import/Export, ETL-Prozesse * **Reporting**: Komplexe Auswertungen und Analysen ## PostgreSQL vs. andere Datenbanken | Kriterium | PostgreSQL | MySQL | SQL Server | |-----------|------------|-------|------------| | Lizenz | Open Source | Open Source | Kommerziell | | JSON-Support | Sehr gut | Gut | Gut | | Erweiterungen | Exzellent | Begrenzt | Begrenzt | | Komplexe Queries | Sehr gut | Gut | Sehr gut | Für neue Projekte empfehle ich PostgreSQL als Default-Wahl – außer es gibt spezifische Gründe für eine andere Datenbank. --- Title: Diese Website ist ein Go-Webserver URL: https://www.jakoubek.net/go-webserver/ Description: Warum ich meine Website als Go-Webserver mit dem Gin-Framework betreibe - Vorteile von Go für Webprojekte. Tags: Go, Golang, Webserver Updated: 2025-12-24 Diese Website läuft als kompilierter Go-Webserver mit dem [Gin-Framework](https://gin-gonic.com/). Warum habe ich mich für diese Architektur entschieden? ## Vorteile eines Go-Webservers ### Performance Go-Webserver sind extrem schnell. Der kompilierte Code läuft ohne Interpreter oder Runtime direkt auf dem Server. Antwortzeiten sind oft 10–100× schneller als bei interpretierten Sprachen wie PHP oder Node.js. ### Einfaches Deployment Das Deployment besteht aus einer einzigen Binary-Datei. Keine Abhängigkeiten, keine Runtime-Installation, kein Package-Manager auf dem Server. Die Binary enthält alles - inklusive der statischen Dateien und Templates. ### Geringe Ressourcen Ein Go-Webserver benötigt minimal RAM und CPU. Diese Website läuft problemlos auf dem kleinsten verfügbaren VPS. Im Idle-Zustand verbraucht der Prozess nur wenige Megabyte Speicher. ### Sicherheit Weniger bewegliche Teile bedeuten weniger Angriffsfläche. Kein PHP, kein Node.js, keine Datenbank, kein CMS mit regelmäßigen Sicherheitsupdates. Die kompilierte Binary ist schwerer zu kompromittieren als interpretierter Code. ### Stabilität Go-Programme sind bekannt für ihre Langzeitstabilität. Der Server läuft monatelang ohne Neustart oder Memory-Leaks. Einmal deployt, läuft er einfach. ### Keine Datenbank erforderlich Content wird als Markdown-Dateien mit YAML-Frontmatter gepflegt und beim Kompilieren in das Binary-Programm eingebettet. Keine SQL-Queries, keine Datenbankverbindungen, keine ORM-Komplexität. ## Technologie-Stack - **[Go](https://go.dev/)** - Programmiersprache - **[Gin](https://gin-gonic.com/)** - HTTP-Framework - **[Templ](https://templ.guide/)** - Type-safe HTML-Templates - **[Goldmark](https://github.com/yuin/goldmark)** - Markdown-Parser ## Fazit Für eine persönliche Website oder ein Portfolio ist ein Go-Webserver eine elegante Lösung. Die initiale Entwicklung erfordert mehr Aufwand als ein CMS, aber das Ergebnis ist ein schneller, sicherer und wartungsarmer Server. --- Title: sendamatic – Go-Client für die Sendamatic-E-Mail-Delivery-API URL: https://www.jakoubek.net/open-source/sendamatic/ Description: Go-Bibliothek für den Versand von E-Mails über die Sendamatic-API mit Fluent Message Builder, Context-Support, HTML+Text, Attachments und mehr. Tags: Go, API, Sendamatic, Open-Source, Library, E-Mail Updated: 2026-02-11 **sendamatic** ist eine Go-Bibliothek für den Versand von E-Mails über die [Sendamatic](https://sendamatic.net)-E-Mail-Delivery-API. Die Library bietet einen Fluent-Message-Builder, Context-Support und automatische Base64-Kodierung von Attachments. ## Was ist Sendamatic? [Sendamatic](https://sendamatic.net) ist ein britischer E-Mail-Versanddienst mit Fokus auf Zuverlässigkeit und Zustellbarkeit. Der preisgünstige Service eignet sich besonders für transaktionale E-Mails wie Registrierungsbestätigungen, Bestellbestätigungen oder Passwort-Resets. Die API ist einfach zu nutzen und bietet alle notwendigen Features für professionellen E-Mail-Versand. ## Warum diese Library? Ich nutze Sendamatic für transaktionale E-Mails in meinen Go-Anwendungen und wollte eine typsichere, idiomatische Go-Library anstelle von manuellen HTTP-Aufrufen. Die Library macht den E-Mail-Versand durch die Fluent-API besonders komfortabel und reduziert Boilerplate-Code erheblich. ## Installation ```bash go get code.beautifulmachines.dev/jakoubek/sendamatic ``` ## Authentifizierung Sendamatic verwendet API-Keys für die Authentifizierung. Erstellen Sie einen API-Key im [Sendamatic-Dashboard](https://sendamatic.net) unter **Einstellungen → API-Keys**. ```bash export SENDAMATIC_API_KEY="your-api-key" ``` ## Schnellstart ```go package main import ( "context" "fmt" "log" "os" "code.beautifulmachines.dev/jakoubek/sendamatic" ) func main() { client := sendamatic.NewClient(os.Getenv("SENDAMATIC_API_KEY")) msg := sendamatic.NewMessage(). From("sender@example.com", "Sender Name"). To("recipient@example.com", "Recipient Name"). Subject("Test E-Mail"). TextBody("Dies ist eine Test-E-Mail."). HTMLBody("

Dies ist eine Test-E-Mail.

") ctx := context.Background() result, err := client.Send(ctx, msg) if err != nil { log.Fatal(err) } fmt.Printf("E-Mail gesendet: %s\n", result.MessageID) } ``` ## Features ### Fluent Message Builder Die Library verwendet einen Fluent-Builder für intuitive E-Mail-Erstellung: ```go msg := sendamatic.NewMessage(). From("sender@example.com", "Sender Name"). To("recipient@example.com", "Recipient Name"). ReplyTo("reply@example.com"). Subject("Wichtige Nachricht"). TextBody("Textversion der E-Mail"). HTMLBody("

HTML-Version der E-Mail

") ``` ### Mehrere Empfänger (CC/BCC) ```go msg := sendamatic.NewMessage(). From("sender@example.com", "Team"). To("recipient1@example.com", "Person 1"). To("recipient2@example.com", "Person 2"). CC("cc@example.com", "Copy"). BCC("bcc@example.com", "Blind Copy"). Subject("Rundschreiben") ``` ### Attachments mit automatischer Base64-Kodierung Die Library kodiert Attachments automatisch als Base64: ```go attachment, err := sendamatic.NewAttachment("dokument.pdf", pdfData) if err != nil { log.Fatal(err) } msg := sendamatic.NewMessage(). From("sender@example.com", "Sender"). To("recipient@example.com", "Recipient"). Subject("Dokument anbei"). TextBody("Siehe Anhang."). Attachment(attachment) ``` ### Custom Headers Fügen Sie eigene E-Mail-Header hinzu: ```go msg := sendamatic.NewMessage(). From("sender@example.com", "Sender"). To("recipient@example.com", "Recipient"). Subject("Mit Custom Header"). Header("X-Priority", "1"). Header("X-Mailer", "MyApp/1.0"). TextBody("E-Mail mit benutzerdefinierten Headern") ``` ### HTML + Text (Multipart) Senden Sie beide Versionen für optimale Kompatibilität: ```go msg := sendamatic.NewMessage(). From("sender@example.com", "Newsletter"). To("subscriber@example.com", "Abonnent"). Subject("Neuer Artikel verfügbar"). TextBody("Lesen Sie unseren neuen Artikel unter: https://example.com/artikel"). HTMLBody(`

Neuer Artikel verfügbar

Lesen Sie unseren neuen Artikel.

`) ``` ### Context-Support Alle API-Aufrufe unterstützen `context.Context` für Timeouts und Cancellation: ```go ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() result, err := client.Send(ctx, msg) if err != nil { if ctx.Err() == context.DeadlineExceeded { log.Println("Timeout beim E-Mail-Versand") } log.Fatal(err) } ``` ### Strukturierte Fehlerbehandlung Die Library gibt detaillierte Fehlerinformationen zurück: ```go result, err := client.Send(ctx, msg) if err != nil { log.Printf("Fehler beim E-Mail-Versand: %v", err) return } log.Printf("E-Mail erfolgreich gesendet: %s", result.MessageID) ``` ## Voraussetzungen - Go 1.21 oder höher - Sendamatic-Account mit API-Key ## Links - **Forgejo:** [code.beautifulmachines.dev/jakoubek/sendamatic](https://code.beautifulmachines.dev/jakoubek/sendamatic) - **GitHub-Mirror:** [github.com/jakoubek/sendamatic](https://github.com/jakoubek/sendamatic) - **Go Package:** [pkg.go.dev/code.beautifulmachines.dev/jakoubek/sendamatic](https://pkg.go.dev/code.beautifulmachines.dev/jakoubek/sendamatic) ## Lizenz MIT License – siehe [LICENSE](https://code.beautifulmachines.dev/jakoubek/sendamatic/src/branch/main/LICENSE). --- Title: Digitale Patientenaufnahme – Nahtlose Integration in Praxissoftware URL: https://www.jakoubek.net/projekt/gdt-import/ Description: Automatisierte Integration von Patient-Intake-Systemen in Praxisverwaltungssoftware über das GDT-Dateiformat. Tags: Go, PostgreSQL, Gesundheitswesen, Integration Published: 2025-07-01 Für einen Kunden aus dem Gesundheitswesen entwickelte ich ein Importtool, das moderne digitale Patientenaufnahme-Lösungen nahtlos mit bestehenden Praxisverwaltungssystemen verbindet. ## Die Herausforderung Viele Arztpraxen setzen auf digitale Patient-Intake-Tools (wie z.B. IDANA), um die Erstaufnahme zu modernisieren. Patienten erfassen ihre Stammdaten, Anamnese und Symptome bequem über Tablets im Wartezimmer. Diese modernen Lösungen nutzen den GDT-Standard (Geräte-Daten-Träger) – ein in Deutschland etabliertes Dateiformat für den Austausch von Patientendaten – um die erfassten Informationen an das Praxisverwaltungssystem (PVS) zu übergeben. ## Die Lösung Das entwickelte Tool automatisiert die vollständige Integration zwischen Patient-Intake-System und Praxisverwaltungssoftware: - **Datenerfassung**: GDT-Dateien werden zusammen mit den vom Patienten ausgefüllten PDF-Fragebögen aus dem Importverzeichnis abgeholt - **Patientenabgleich**: Anhand der Patientennummer aus der GDT-Datei erfolgt die eindeutige Zuordnung zum Patienten im Praxisverwaltungssystem - **Datenbankintegration**: Direkter Zugriff auf die PostgreSQL-Datenbank des PVS ermöglicht das sichere Auslesen der Patientenstammdaten - **Dokumentenverwaltung**: Die ausgefüllten PDF-Formulare werden automatisch in den patientenspezifischen Ablageordner sortiert - **Audit-Trail**: Jeder Importvorgang wird in der elektronischen Patientenakte protokolliert ## Das Ergebnis Das Tool ermöglicht Praxen, moderne digitale Patientenaufnahme-Systeme zu nutzen, ohne auf manuelle Datenübertragung oder Medienbrüche angewiesen zu sein. Die Patientendaten fließen automatisch vom Tablet in die Praxissoftware – sicher, fehlerfrei und dokumentiert. --- Title: Vornamencheck – API zur Geschlechtszuordnung URL: https://www.jakoubek.net/projekt/geschlechtszuordnung-api/ Description: Kostenfreie REST-API zur automatischen Geschlechtsbestimmung aus Vornamen für die Qualitätssicherung von Adressdatenbanken. Tags: API, Datenqualitaet, SaaS Published: 2025-03-01 Nichts schadet der Kundenbeziehung mehr als eine falsche Anrede im Geschäftsbrief. „Sehr geehrter Herr Schmidt", wenn Andrea Schmidt eine Frau ist – solche Fehler entstehen schnell bei der manuellen Dateneingabe und fallen oft erst auf, wenn der Brief schon versendet wurde. Bei großen Adressdatenbanken wird die manuelle Prüfung unpraktikabel. ## Die Lösung: Vornamencheck-API Der **Vornamencheck** ist eine frei verfügbare REST-API, die ich entwickelt habe, um genau dieses Problem zu lösen. Die API ermittelt aus einem Vornamen das statistische Geschlecht und kann damit Adressdatenbanken automatisch prüfen und korrigieren. ### Vorteile - **Einfache Integration**: Standard-HTTP-Anfragen, kompatibel mit allen gängigen Programmier- und Skriptsprachen - **Keine Installation**: Direkter API-Zugriff über das Web - **Kostenfrei**: Keine Lizenzkosten für Unternehmen jeder Größe ## Typische Einsatzszenarien - Automatische Qualitätsprüfung beim Import neuer Adressdaten - Korrektur bestehender Adressdatenbanken - Integration in CRM- und ERP-Systeme - Validierung bei der manuellen Dateneingabe Die API wird produktiv in verschiedenen Kundenprojekten eingesetzt und steht unter [vornamencheck.de](https://vornamencheck.de/) zur freien Verfügung. ## Hinweis zur Nutzung Die API arbeitet auf Basis statistischer Zuordnungen von Vornamen. Bei geschlechtsneutralen Namen oder wenn keine geschlechtsspezifische Anrede gewünscht wird, sollten entsprechende Fallback-Lösungen im Anwendungskontext vorgesehen werden. --- Title: Verteilspiegel-Manager URL: https://www.jakoubek.net/projekt/verteilspiegel-manager/ Description: Zeitsparende Auftragsanlage für eine Warenwirtschafts-Anwendung. Tags: Lazarus, SQL-Anywhere, Desktop Published: 2024-06-30 Dieses Desktop-Programm wurde als Ergänzung zu einem bestehenden Warenwirtschafts-Programm entwickelt. Es dient dazu, Auftragsdefinitionen für Kundenaufträge (sogenannte Verteilspiegel) so effizient und arbeitssparsam wie möglich anzulegen. ## Das Problem Im eigentlichen Warenwirtschafts-Programm musste die Auftragsanlage kleinteilig erfolgen – die Nutzer mussten immer wieder, für jeden neuen Kunden und jeden neuen Auftrag, Auftragsdefinitionen aus den gleichen Bestandteilen zu den gleichen Auftragspositionen zusammenbauen. Zudem musste man wissen (oder nachschlagen), welche Bestandteile in welche Auftragsposition gehören. ## Die Lösung Im Verteilspiegel-Manager erfolgt die Suche der passenden Bestandteile automatisch – die Nutzer müssen lediglich die Vorlage der gewünschten Auftragsposition auswählen. Im Hintergrund erfolgt dann der Zusammenbau der notwendigen Bestandteile und die Speicherung in der Datenbank. Zusätzliche Funktionen: - **Export**: Per Knopfdruck kann die Auftragsdefinition in einem kundenfreundlichen Format als Excel-Datei exportiert werden - **E-Mail-Versand**: Die Excel-Datei kann auf Wunsch direkt per E-Mail an den Kunden versendet werden --- Title: Automatisierte Datenbank-Updates – Sicherer Rollout ohne Ausfallzeiten URL: https://www.jakoubek.net/projekt/datenbank-migrationen-goose/ Description: Von manuellen SQL-Skripten zu versionskontrollierten Datenbank-Migrationen mit einem Go-basierten Migrations-Framework. Tags: MySQL, DevOps, Automatisierung, Go Published: 2024-05-16 Für einen Kunden mit einem MySQL/MariaDB-Cluster implementierte ich ein modernes Migrationssystem, das manuelle Datenbankänderungen durch automatisierte, nachvollziehbare Migrationen ersetzt. ## Ausgangssituation Der Kunde betrieb vier Datenbanken auf zwei Servern (Produktiv- und Testumgebung). Strukturänderungen wurden manuell durch direktes Einspielen von SQL-Skripten vorgenommen – ohne systematische Versionskontrolle oder automatische Nachverfolgung. Um herauszufinden, welche Änderungen in welcher Datenbank bereits angewendet waren, musste der zuständige Mitarbeiter die Datenbankstruktur manuell prüfen. Dieser Prozess war fehleranfällig, zeitaufwändig und erschwerte die Synchronisation zwischen Test- und Produktivumgebung erheblich. ## Die Lösung mit Goose Durch die Einführung von [Goose](https://pressly.github.io/goose/) als Migrations-Framework weiß nun jede Datenbank selbst, welche Migrationen bereits angewendet wurden und welche noch ausstehen: - **Versionierte Migrationen**: Alle Strukturänderungen werden als nummerierte SQL-Migrationsskripte verwaltet und in Git versioniert - **Automatische Statusverfolgung**: Goose protokolliert in einer dedizierten Tabelle, welche Migrationen bereits durchgeführt wurden - **Einheitliche Skriptbasis**: Test- und Produktivserver nutzen den identischen Bestand an Migrationsskripten - **Benutzerfreundliche Automatisierung**: PowerShell-Wrapper-Skripte ermöglichen die einfache Ausführung über die Kommandozeile ## Besonderer Fokus: Einfache Bedienung Damit die Mitarbeiter beim Kunden keine tiefgreifenden technischen Kenntnisse besitzen müssen, wurden die PowerShell-Skripte bewusst so gestaltet, dass Datenbank-Updates mit einfachen Befehlen sicher und zuverlässig durchgeführt werden können. ## Ergebnis Das neue System eliminiert manuelle Fehlerquellen, schafft vollständige Transparenz über den Zustand jeder Datenbank und ermöglicht schnelle, reproduzierbare Deployments – ohne dass tiefes Datenbank-Know-how erforderlich ist. --- Title: ProspektDevice – mein eigenes Softwareprodukt URL: https://www.jakoubek.net/prospektdevice/ Description: Wie aus jahrelanger Projektarbeit für Verteilunternehmen ein eigenes Produkt wurde. Die Software selbst steht auf prospektdevice.de. Tags: PHP, Laravel, PostgreSQL, SaaS, Prospektverteilung Updated: 2026-08-29 Seit über 25 Jahren entwickle ich Software für Unternehmen aus der Prospektverteilung. Aus dieser Arbeit ist ProspektDevice entstanden, ein eigenes Produkt für die Prozesse, die in fast jedem Verteilunternehmen ähnlich aussehen. Technisch läuft es als Webanwendung auf Basis von PHP und Laravel mit PostgreSQL als Datenbank. Betrieben wird es als gehostete Lösung, auf Wunsch auch im eigenen Rechenzentrum. ## Zur Produkt-Website Was die Software kann, für wen sie gedacht ist und wie ein Einstieg aussieht, ist auf der eigenen Website beschrieben: **[prospektdevice.de](https://www.prospektdevice.de)** Dort finden Sie eine ausführliche Beschreibung der einzelnen Funktionsbereiche, eine Benutzer-Dokumentation sowie den direkten Kontakt. --- Title: Automatisierte Versandsteuerung für FERAG-Anlagen URL: https://www.jakoubek.net/projekt/versandsteuerung-ferag-automatisierung/ Description: Automatische Erzeugung von FERAG-Strings aus bestehenden Logistiksystemen für vollautomatisierte Versandsteuerung. Tags: FERAG, Go, PHP, Laravel, PostgreSQL, Druckerei Published: 2023-12-31 ## Die Herausforderung Nach der Ablösung einer älteren Software fehlte Unternehmen eine zentrale Komponente ihrer Produktionskette. Sie benötigten eine Möglichkeit, aus ihren Logistik- und Auftragsdaten automatisch Steuerdateien (FERAG-Strings) für ihre Versandanlagen zu erzeugen. Eine manuelle Erstellung dieser hochkomplexen Dateien ist praktisch nicht möglich. Die bestehenden Logistiksysteme lieferten jedoch keine FERAG-Ausgabe. Die Herausforderung lag darin, eine nahtlose Integration in die vorhandene IT-Infrastruktur zu schaffen. Dabei musste die Lösung mit unterschiedlichen Datenquellen arbeiten können. ## Die Lösung Ich entwickelte für mehrere Kunden individuelle Integrationslösungen zur automatisierten Erzeugung von FERAG-Steuerdateien. Der Fokus lag auf der Analyse der bestehenden Systemarchitektur und der Konzeption einer passenden Integrationsstrategie. **Unterschiedliche Architekturen erforderten unterschiedliche Ansätze:** Bei einem Kunden erfolgt der direkte Zugriff auf die Datenbank mit den Logistikdaten. Das System erzeugt daraus automatisch die benötigten TSL-Dateien. Ein anderer Kunde nutzt eine API-basierte Anbindung an sein Logistiksystem. In einem weiteren Fall wurde ein eigenständiger Webserver konzipiert. Dieser liest Excel-Dateien mit Logistikdaten von einem FTP-Server ein. Er erzeugt daraus die Steuerdateien und legt diese auf einem anderen FTP-Server ab. Diese Architektur ermöglichte die Integration ohne Eingriffe in bestehende Systeme. **Wichtig bei allen Lösungen:** Die Systeme arbeiten vollautomatisiert und zeitgesteuert. Es sind keine manuellen Eingriffe erforderlich. Für die technische Umsetzung nutze ich eine selbst entwickelte [Open-Source-Bibliothek](/ferag-string-erzeugen/). Sie ist für Go und PHP verfügbar und ermöglicht flexible Anpassungen an kundenspezifische Anforderungen. ## Das Ergebnis Die Kunden profitieren von einer **vollautomatischen Erzeugung** der Steuerdateien ohne manuelle Eingriffe. Dies führt zu deutlicher **Zeitersparnis** im Tagesgeschäft. Die automatisierte Erzeugung reduziert Fehler drastisch. Die Produktionsprozesse laufen **zuverlässiger** ab. Die Integration in bestehende Infrastrukturen (Datenbanken, APIs, FTP-Server) erfolgte nahtlos. Bestehende Systeme konnten weitergenutzt werden. --- Ähnliche Lösungen entwickle ich auch für andere Versandförderanlagen wie Sitma, Müller Martini oder Duplo. Je nach Anlage werden dabei unterschiedliche Dateiformate erzeugt (z.B. XML-basierte Formate). --- Title: Transportlogistik mit XTL-Integration URL: https://www.jakoubek.net/projekt/transportlogistik-xtl/ Description: Automatisierte Tourenoptimierung durch Integration von Warenwirtschaft und Transportlogistik-System. Tags: Go, SQL-Anywhere, API, Logistik, Integration Published: 2023-11-01 ## Die Herausforderung Ein Logistik-Unternehmen stand vor mehreren Herausforderungen in der täglichen Tourenplanung: Es gab keine automatisierte Tourenoptimierung – die Reihenfolge der Stopps wurde manuell festgelegt, was weder Zeit noch Kosten optimierte. Die Fahrer arbeiteten mit ausgedruckten Tourenlisten auf Papier, wodurch zusätzlicher Verwaltungsaufwand entstand und Statusaktualisierungen in Echtzeit nicht möglich waren. Das Unternehmen wollte die Transportlogistik-SaaS-Lösung [XTL](https://www.xtl-gmbh.de/) nutzen, um von deren Tourenoptimierungs-Algorithmen und Fahrer-App zu profitieren. Die zentrale Frage war: Wie lässt sich XTL nahtlos in die bestehende Warenwirtschaft integrieren, sodass alle Systeme optimal zusammenspielen? ## Die Lösung In enger Zusammenarbeit wurde eine bidirektionale Integration zwischen Warenwirtschaftssystem und XTL konzipiert und umgesetzt. Dabei lag der Fokus auf einer robusten Architektur, die zuverlässige Datensynchronisation gewährleistet: Die Transportaufträge werden automatisch aus der Warenwirtschaft an die XTL-API übertragen. Dort optimiert XTL die Tourenreihenfolge nach Zeit- und Kostenkriterien. Die optimierte Reihenfolge fließt zurück ins Warenwirtschaftssystem, wo sie für die weitere Abwicklung zur Verfügung steht. Gleichzeitig nutzen die Fahrer die XTL-App, um jeden Abladepunkt digital abzuhaken – der Status wird in Echtzeit ins System übertragen. ## Das Ergebnis Durch die automatisierte Tourenoptimierung konnte das Unternehmen Transportkosten messbar senken – kürzere Wege bedeuten weniger Kraftstoffverbrauch und Zeitaufwand. Die Automatisierung der Datenübertragung spart täglich administrative Zeit ein, die vorher für manuelle Planung und Übertragung aufgewendet werden musste. Der Verzicht auf papierbasierte Tourenlisten reduziert nicht nur Druckkosten, sondern ermöglicht auch eine durchgängig digitale Prozesskette mit Echtzeit-Transparenz über den Lieferstatus. --- Title: CRM-System für Unternehmensgruppe mit 100.000+ Kontakten URL: https://www.jakoubek.net/projekt/performantes-crm-system/ Description: Performantes Kontaktmanagement für eine Unternehmensgruppe mit mehreren hunderttausend Adressdaten. Tags: Ninox, API, Low-Code, CRM Published: 2022-08-01 Eine Unternehmensgruppe stand vor der Herausforderung, ihre umfangreichen Kundenkontakte zentral zu verwalten – über mehrere hunderttausend Adressdatensätze, die für die tägliche Arbeit schnell durchsuchbar und filterbar sein mussten. ## Die Herausforderung Bei dieser Datenmenge stoßen Standard-CRM-Lösungen oft an Performance-Grenzen. Die Anforderung war ein System, das trotz der großen Datenmengen flüssig bedienbar bleibt und gleichzeitig den spezifischen Workflows der Unternehmensgruppe gerecht wird. ## Die Lösung Auf Basis der Lowcode-Plattform Ninox entwickelte ich eine maßgeschneiderte CRM-Lösung mit folgenden Kernfunktionen: - **Performance-optimierte Architektur** für schnellen Zugriff auf mehrere 100.000 Datensätze - **Intelligente Datenaufbereitung**: Automatische Geschlechtszuordnung über die [Vornamencheck-API](/projekt/geschlechtszuordnung-api/) bei neuen Kontakten - **Geografische Zuordnung**: Automatisierte Verknüpfung mit Postleitzahlengebieten sowie Bundestags- und Landtagswahlkreisen - **Umfangreiche Such- und Filterfunktionen** für effizientes Arbeiten mit der Adressdatenbank - **On-Premise-Installation** für maximale Datenkontrolle ## Das Ergebnis Das System ermöglicht der Unternehmensgruppe, ihre Kontaktdatenbank effizient zu nutzen – mit der Performance eines maßgeschneiderten Systems und der Flexibilität einer Lowcode-Plattform. --- Title: Effiziente Mitarbeiter-Kommunikation auf Knopfdruck URL: https://www.jakoubek.net/projekt/sammelbenachrichtigung-mitarbeiter/ Description: Hunderte Mitarbeiter in Minuten informieren – per E-Mail oder SMS. Tags: Go, Xojo, SQL-Anywhere, API, E-Mail, SMS Published: 2022-01-01 Wie ein mittelständisches Unternehmen hunderte Mitarbeiter in Minuten statt Stunden erreicht – mit einem maßgeschneiderten Benachrichtigungssystem. ## Ausgangssituation Das Unternehmen stand regelmäßig vor der Herausforderung, große Mitarbeitergruppen zeitkritisch informieren zu müssen – etwa bei Schichtänderungen, dringenden Betriebsmitteilungen oder Notfällen. Die manuelle Benachrichtigung per E-Mail oder Telefon band erhebliche Personalressourcen und war fehleranfällig. ## Die Herausforderung - **Zeitdruck**: Hunderte Mitarbeiter mussten innerhalb kürzester Zeit erreicht werden - **Zielgenaue Auswahl**: Nicht alle Mitarbeiter, sondern spezifische Gruppen nach Abteilung, Standort oder Funktion - **Erreichbarkeit sicherstellen**: E-Mail genügt nicht immer – SMS als Fallback notwendig - **Integration**: Mitarbeiterdaten lagen bereits in der bestehenden Warenwirtschaft vor ## Die Lösung Ich entwickelte ein datenbankbasiertes Benachrichtigungssystem, das nahtlos an die vorhandene Unternehmenssoftware andockt: ### Benutzerfreundliche Bedienung Über eine intuitive Anwendung können Mitarbeiter mit wenigen Klicks Zielgruppen auswählen – basierend auf den Strukturen aus der Warenwirtschaft. Eine Nachricht formulieren, Versandkanal wählen (E-Mail, SMS oder beides) – fertig. ### Intelligente Zustellung Das System arbeitet mit einer Warteschlange: Benachrichtigungsaufträge werden in die Datenbank geschrieben und von einem Hintergrunddienst zuverlässig abgearbeitet. E-Mails gehen über die vorhandene Infrastruktur raus, SMS werden über einen professionellen Dienstleister versendet. Bei E-Mail-Zustellproblemen greift automatisch der SMS-Fallback. ### Das Ergebnis - **Zeitersparnis**: Benachrichtigungen, die früher Stunden dauerten, sind in Minuten erledigt - **Treffsicherheit**: Nur relevante Mitarbeiter werden angesprochen - **Zuverlässigkeit**: Automatische Fallback-Mechanismen garantieren Zustellung - **Nachvollziehbarkeit**: Alle Benachrichtigungen werden protokolliert und sind nachweisbar --- Title: feragstring – Go-Bibliothek für FERAG-Strings URL: https://www.jakoubek.net/open-source/ferag-string/ Description: Go-Bibliothek zur Erstellung von FERAG-Strings für Versandanlagen in Druckereien. Open-Source, produktiv im Einsatz bei Zeitungsverlagen. Tags: FERAG, Go, Golang, Druckerei, Open-Source Updated: 2026-02-06 Druckereien benötigen zur Steuerung ihrer FERAG-Versandanlagen einen sogenannten *FERAG-String* (auch TSL-Datei genannt). Mit meiner Open-Source-Bibliothek **feragstring** können Sie selbst FERAG-String-Dateien aus Ihren Logistikdaten erzeugen. Die Bibliothek ist in Go geschrieben. Sie benötigen nur Grundkenntnisse in Go und Ihre produktionsrelevanten Daten. Damit können Sie ein Programm schreiben, das FERAG-Strings entweder aus CSV-Dateien oder durch direkten Datenbankzugriff generiert. Die Bibliothek wird bereits produktiv bei mehreren Zeitungsverlagen eingesetzt. ## Installation Die Installation erfolgt mit dem Go-Paketmanager: ``` go get -u github.com/jakoubek/feragstring ``` ## Verwendung Hier ein Beispiel für die Erstellung eines FERAG-Strings: ```go // FERAG-String-Objekt erstellen fs := feragstring.NewFeragString() fs.SetTitleName("EDITION1") // Titelparameter setzen fs.TitleInfo.SetPrintObjectName("EDITION1A") fs.TitleInfo.SetPublicationDate("2020-05-31") fs.TitleInfo.SetCountryCode("13") fs.TitleInfo.SetPrintObjectColor("00000000") // Produkt hinzufügen pr1 := feragstring.NewProductReference() pr1.SetProductName("MAIN") pr1.SetCopiesAssigned(25000) pr1.SetSupervision(1) pr1.SetOverlap(5) mp := feragstring.NewMissingParameter(1, 1) pr1.SetMissingParameter(mp) pr1.SetIssueReference("MAIN01") fs.AddProductReference(pr1) // Route hinzufügen rt := feragstring.NewRoute() rt.SetRouteName("ROUTE001") rt.SetRouteCode(fs.NextRouteCode()) rt.SetRampNumber(0) rt.SetCopiesInRoute(1500) rt.SetLimit(1) rt.SetMaxStack(13) rt.SetStandard(40) rt.SetParameterN(4) rt.SetMaxBundle(40) rt.SetTopsheetMarker(5) rt.SetEaMarker(0) rt.SetTopsheetTemplateDirectory(20) rt.AddProductReferenceNumber(1) fs.AddRoute(rt) // FERAG-String ausgeben feragString := fs.PrintOut() ``` ## Ausgabe-Beispiel Das obige Code-Beispiel erzeugt folgenden FERAG-String: ``` %2440+93EDITION1A +40EDITION1+95200531+9713+9400000000! %2450+4101+42MAIN +5501+350000+0200025000+3600000+4401+4505+9910100+99102000000+99105000100000001+99195MAIN01 ! %2401+11ROUTE001 +7900001+2500+23001500! %2402+11ROUTE001 +300001+310013+320040+330004+340040+350000+595+690+56020+4101! %2406+11ROUTE001 ! %2441+40EDITION1! ``` --- Title: Software für Prospektverteilung – Individuelle Lösungen URL: https://www.jakoubek.net/software-fuer-prospektverteilung/ Description: Seit über 20 Jahren Softwarelösungen für Verteilunternehmen und Verlage. Individuelle Entwicklung, Schnittstellenentwicklung, Beratung und Modernisierung. Tags: Prospektverteilung, Zustellung, Logistik Updated: 2026-01-29 Seit über 25 Jahren entwickle ich Softwarelösungen für Verteilunternehmen und Verlage. Von Tourenplanung über Zustellerabrechnung bis hin zu Schnittstellen in bestehende ERP-Systeme – ich kenne die Prozesse und Herausforderungen der Branche. ## Meine Leistungen für Verteilunternehmen - **Individuelle Softwarelösungen** für Logistik- und Abrechnungsprozesse - **Schnittstellenentwicklung** zwischen Verlagssystemen, Zustellersoftware und kaufmännischen Anwendungen - **Beratung & Modernisierung** bestehender Systeme (z.B. Migration von Legacy-Datenbanken) - **Datenanalyse & Reporting** für Verteilgebiete, Auflagen und Zustellerleistung ## Meine Erfahrung Zu meinen langjährigen Kunden zählen Unternehmen, die wöchentlich Millionen von Prospekten und Zeitungen zustellen. Ich verstehe die Besonderheiten der Branche – von der saisonalen Schwankung der Beilagenmengen bis zur komplexen Zustellerabrechnung mit Mindestlohn-Thematik. Auch wenn sich die Branche im Wandel befindet: Gerade jetzt ist effiziente Software entscheidend, um mit schlankeren Prozessen wettbewerbsfähig zu bleiben. ## Referenzprojekte aus der Branche Eine Auswahl von Projekten, die ich für Unternehmen aus der Prospektverteilung und verwandten Branchen umgesetzt habe:
**[ProspektDevice](https://www.prospektdevice.de)** – Webbasierte Branchensoftware für Prospektverteilung und Anzeigenblatt-Verteilung *Meine webbasierte Komplettlösung für Tourenplanung, Disposition und Zustellerabrechnung. Funktionen und Dokumentation stehen auf der Produkt-Website [prospektdevice.de](https://www.prospektdevice.de). Wie das Produkt entstanden ist, steht [hier](/prospektdevice/).*
- **[Verteilspiegel-Manager](/projekt/verteilspiegel-manager/)** – Zeitsparende Auftragsanlage für eine Warenwirtschafts-Anwendung - **[Effiziente Lohnvorbereitung für große Belegschaften](/projekt/personalabrechnung-automatisierung/)** – Automatisierte Lohnvorbereitung, die dem Abrechnungsteam mehrere Arbeitstage pro Zyklus spart - **[Mindestlohn-Ermittlung](/projekt/mindestlohn-ermittlung/)** – Automatische Mindestlohnprüfung für variable Arbeitszeitmodelle in der Zustellung - **[Automatisierter Versandpapierdruck](/projekt/versandpapierdruck/)** – Massenweises Erzeugen von PDF-Versandpapieren aus einer Warenwirtschaft - **[Automatisierte Versandsteuerung für FERAG-Anlagen](/projekt/versandsteuerung-ferag-automatisierung/)** – Vollautomatisierte Versandsteuerung durch Anbindung an bestehende Logistiksysteme - **[Reklamationsdaten-Webserver](/projekt/rekladaten-webserver/)** – Webbasierte Erfassung und Verwaltung von Reklamationsdaten - **[Effiziente Mitarbeiter-Kommunikation auf Knopfdruck](/projekt/sammelbenachrichtigung-mitarbeiter/)** – Hunderte Mitarbeiter in Minuten informieren per E-Mail oder SMS --- Title: DatesAPI - Datums-Webservice für Automatisierungsplattformen URL: https://www.jakoubek.net/projekt/datesapi/ Description: Ein kostenfrei nutzbarer Webservice, der Datumswerte bereitstellt und einfach in Make oder Zapier eingebunden werden kann. Tags: Go, API, Automatisierung, SaaS Published: 2020-11-25 **DatesAPI** ist ein in Go geschriebener Webservice, der Informationen zu Datumswerten bereitstellt. Ich habe diesen Dienst entwickelt, weil Datumsmanipulationen in den üblichen Automatisierungsplattformen (Zapier, Make, ...) umständlich zu realisieren sind – insbesondere wenn man Datumsangaben wie Monatsnamen auf Deutsch weiterverwenden möchte. ## Das Problem In mehreren meiner Make-Szenarien laufen zeitgesteuerte Workflows, die gegen Ende des Monats neue Tickets in meinem Ticketsystem anlegen. Diese Tickets heißen dann beispielsweise *Monatsabschluss Juli 2024*. Die dynamische Erzeugung des Strings "Juli 2024" – mit deutschem Monatsnamen – war in Make nur aufwändig möglich und hätte für jedes Szenario neu angelegt werden müssen. ## Die Lösung Stattdessen greife ich aus diesen Automatisierungsplattformen direkt über das eingebaute HTTP-Modul auf meinen Datums-Webservice zu: ``` GET https://api.datesapi.net/today GET https://api.datesapi.net/tomorrow GET https://api.datesapi.net/next-month?lang=de ``` ## Verfügbarkeit Die Landing-Page für den Dienst ist über [datesapi.net](https://datesapi.net/) erreichbar. Anfragen können über Curl oder Skripte direkt an die Endpunkte unter **api.datesapi.net** gesendet werden. Der Service ist kostenfrei nutzbar. --- Title: Xojo – Cross-Platform-Entwicklung URL: https://www.jakoubek.net/xojo/ Description: Xojo-Entwicklung und Projektübernahme. Ich entwickle Cross-Platform-Anwendungen und übernehme bestehende Xojo- und RealStudio-Projekte. Über 20 Jahre Erfahrung. Tags: Xojo, Entwicklung, Cross-Platform Updated: 2025-12-18 Xojo ist eine Entwicklungsumgebung für Cross-Platform-Anwendungen. Mit einer einzigen Codebasis lassen sich native Apps für Windows, macOS, Linux und das Web erstellen. Ich arbeite seit vielen Jahren mit Xojo und seinem Vorgänger RealStudio – sowohl für neue Projekte als auch für die Übernahme bestehender Anwendungen. ## Bestehende Projekte übernehmen Viele Unternehmen haben Xojo- oder RealStudio-Anwendungen im Einsatz, die über Jahre gewachsen sind. Der ursprüngliche Entwickler ist nicht mehr verfügbar, interne Ressourcen fehlen, oder das Projekt wurde lange nicht angefasst. Trotzdem läuft die Software produktiv und muss weiterentwickelt oder an neue Anforderungen angepasst werden. Genau hier unterstütze ich: Ich übernehme bestehende Xojo- und RealStudio-Projekte, arbeite mich in den Code ein und führe die Entwicklung fort. Das umfasst Bugfixes, neue Features, Anpassungen an aktuelle Betriebssysteme und die Migration auf neuere Xojo-Versionen. Wenn Sie eine Anwendung haben, die niemand mehr anfassen will oder kann – sprechen Sie mich an. ## Neue Projekte mit Xojo Für neue Vorhaben ist Xojo eine gute Wahl, wenn Sie eine Desktop-Anwendung benötigen, die auf mehreren Plattformen laufen soll. Die Entwicklung geht schnell, die resultierenden Apps sind nativ und performant. Typische Einsatzgebiete sind Datenbank-Frontends, interne Tools, Berichtswesen und Anwendungen, die eng mit lokaler Hardware oder Dateisystemen arbeiten müssen. ## Was ich mit Xojo umsetze **Desktop-Anwendungen**: Native Apps für Windows, macOS und Linux aus einer Codebasis. Datenbankanbindung, Reportgenerierung, Schnittstellen zu anderen Systemen. **Web-Anwendungen**: Browserbasierte Anwendungen mit Xojo Web. Geeignet für interne Tools, die ohne Installation im Browser laufen sollen. **Migrationen**: Umstellung von älteren RealStudio- oder Xojo-Versionen auf aktuelle Releases. Anpassung an neue API-Änderungen und Betriebssystem-Anforderungen. **Datenbankintegration**: Anbindung an [SQL Anywhere](/sql-anywhere/), [PostgreSQL](/postgresql/), MySQL, SQLite und andere Datenbanken. ## Xojo und RealStudio Xojo hieß früher RealStudio (bis 2013) und davor REALbasic. Wenn Sie noch ein Projekt aus dieser Zeit haben, das aktualisiert werden muss, kenne ich auch die älteren Versionen und deren Eigenheiten. --- Title: Ninox – Individuelle Datenbank-Lösungen URL: https://www.jakoubek.net/ninox/ Description: Individuelle Ninox-Datenbanken für Ihr Unternehmen. Beratung, Entwicklung und Support vom erfahrenen Datenbank-Spezialisten. Erstgespräch kostenfrei. Tags: Ninox, Datenbank, Low-Code Updated: 2025-12-18 Ninox ist eine flexible Datenbank-Software für Unternehmen, die ihre Geschäftsprozesse individuell abbilden möchten – ohne die Einschränkungen klassischer Standardsoftware. Als erfahrener Ninox-Entwickler unterstütze ich Sie bei Konzeption, Entwicklung und Betrieb Ihrer Ninox-Datenbank. ## Was ist Ninox? Ninox ist eine Low-Code-Plattform, mit der Sie eigene Datenbankanwendungen erstellen können. Die Software läuft auf Mac, iPad, iPhone und im Browser. Daten werden wahlweise lokal oder in der Ninox-Cloud gespeichert. Im Gegensatz zu Standardsoftware passen Sie Ninox exakt an Ihre Prozesse an – nicht umgekehrt. ## Typische Einsatzgebiete * **Kundenverwaltung (CRM)**: Kontakte, Aktivitäten, Verkaufschancen * **Projektverwaltung**: Aufgaben, Zeiten, Ressourcen * **Warenwirtschaft**: Artikel, Bestellungen, Lagerbestände * **Dokumentenmanagement**: Verträge, Rechnungen, Belege * **Branchenlösungen**: Handwerk, Agenturen, Vereine ## Meine Leistungen als Ninox-Berater * **Beratung**: Analyse Ihrer Anforderungen, Konzeption der Datenbankstruktur * **Entwicklung**: Tabellen, Formulare, Berichte, Skripte * **Schnittstellen**: Anbindung an E-Mail, APIs, andere Systeme * **Migration**: Übernahme bestehender Daten aus Excel oder anderen Systemen * **Schulung**: Einweisung Ihrer Mitarbeiter in die Ninox-Bedienung * **Support**: Laufende Betreuung und Weiterentwicklung ## Warum ein externer Ninox-Entwickler? Ninox ist bewusst einfach gehalten – komplexere Anforderungen erfordern jedoch Erfahrung mit der Skriptsprache und dem Datenmodell. Als Datenbank-Spezialist mit über 20 Jahren Erfahrung bringe ich das Know-how mit, um auch anspruchsvolle Lösungen sauber umzusetzen. ## Kosten und Preise Ninox selbst kostet ab 11 EUR pro Nutzer/Monat (Starter-Tarif). Meine Beratungs- und Entwicklungsleistungen rechne ich auf Stundenbasis oder als Festpreis pro Projekt ab. Ein erstes Gespräch zur Einschätzung Ihres Vorhabens ist kostenfrei. --- Title: Effiziente Lohnvorbereitung für große Belegschaften URL: https://www.jakoubek.net/projekt/personalabrechnung-automatisierung/ Description: Automatisierte Lohnvorbereitung spart dem Abrechnungsteam mehrere Arbeitstage pro Zyklus. Tags: SQL-Anywhere, Lazarus, Automatisierung, SAP Published: 2020-01-01 ## Die Herausforderung Ein Logistikunternehmen beschäftigte mehrere tausend Mitarbeiter mit komplexen, stunden- und leistungsabhängigen Lohnmodellen. Die manuelle Vorbereitung der Bruttolohndaten aus dem Warenwirtschaftssystem kostete das Abrechnungsteam jeden Monat wertvolle Zeit und war fehleranfällig. Besonders die korrekte Mindestlohnberechnung bei wechselnden Arbeitszeiten stellte eine wiederkehrende Herausforderung dar. ## Die Lösung Ich habe eine maßgeschneiderte Schnittstelle entwickelt, die lohnrelevante Daten automatisch aus der bestehenden Warenwirtschaft ausliest, prüft und für die Lohnabrechnung aufbereitet. Die Software berechnet automatisch: - Stundenbasierte Bruttolöhne unter Berücksichtigung variabler Arbeitszeiten - Mindestlohnprüfungen mit automatischer Korrektur - Leistungsbezogene Zuschläge und Sonderzahlungen Die aufbereiteten Daten werden fehlerfrei an das SAP-Abrechnungssystem übergeben – vollautomatisch und ohne manuelle Nacharbeit. ## Das Ergebnis Die monatliche Lohnvorbereitung, die zuvor mehrere Arbeitstage beanspruchte, läuft nun weitgehend automatisiert. Das Abrechnungsteam spart pro Abrechnungszyklus mehrere Personentage ein und kann sich auf Sonderfälle und Beratung konzentrieren. Durch die automatische Mindestlohnprüfung sind rechtliche Risiken minimiert. --- Title: Middleware für Lagerverwaltung und Produktionssteuerung URL: https://www.jakoubek.net/projekt/middleware-lager-produktion/ Description: Middleware-Lösung für Echtzeit-Transparenz zwischen Lagerverwaltung und Produktion ohne Änderungen an Bestandssystemen. Tags: Xojo, SQL-Anywhere, Integration, Logistik Published: 2019-12-01 Eine datenbankbasierte Middleware-Anwendung zur Verknüpfung von Lagerverwaltung und Produktionssteuerung. Die Lösung schafft Echtzeit-Transparenz über die Materialverfügbarkeit und optimiert den Informationsfluss zwischen zwei bestehenden Systemen. ## Die Herausforderung Das Unternehmen betrieb zwei getrennte Systeme: Eine Software für den Wareneingang im Lager und eine separate Anwendung für die Produktionssteuerung. Zwischen diesen Systemen bestand ein Medienbruch – Informationen über eingelagerte Waren waren nicht in Echtzeit für die Produktion verfügbar. Produktionsmitarbeiter wussten nicht, welche Materialien bereits im Produktionsbereich verfügbar waren. Manuelle Prozesse und fehlende Integration führten zu Wartezeiten und erschwerten die Produktionsplanung. Der Informationsfluss musste verbessert werden, ohne dass die beiden bewährten Bestandssysteme grundlegend geändert werden konnten. ## Die Lösung Die Konzeption sah eine schlanke Middleware-Anwendung vor, die als Bindeglied zwischen Lagerverwaltung und Produktionssteuerung fungiert. Die zentrale Architekturentscheidung: Integration durch datenbankbasierte Echtzeit-Synchronisation, ohne Änderungen an den Bestandssystemen vorzunehmen. Die Anwendung wird an einem strategisch platzierten Arbeitsplatz zwischen Lager und Produktionsbereich eingesetzt. Mitarbeiter erfassen dort die physische Warenbewegung – das System aktualisiert automatisch beide angebundenen Systeme und schafft konsistente Informationen über Materialverfügbarkeit und Lagerorte. ## Das Ergebnis Die Produktionssteuerung verfügt nun über Echtzeit-Transparenz zur Materialverfügbarkeit. Produktionsplanung erfolgt auf Basis aktueller Daten, Wartezeiten durch fehlende Informationen wurden eliminiert. Der durchgängige digitale Informationsfluss zwischen Lagerverwaltung und Produktion verbessert die Planbarkeit und Effizienz der Produktionsprozesse. Die pragmatische Middleware-Lösung ermöglichte die Integration ohne aufwändige Anpassungen der Bestandssysteme – ein Ansatz, der sich auch in anderen Szenarien mit gewachsenen IT-Landschaften bewährt. --- Title: Produktionssteuerung mit Live-Dashboard URL: https://www.jakoubek.net/projekt/produktionssteuerung/ Description: Echtzeit-Steuerungssystem für die Produktion mit Live-Dashboard auf großem TV-Display. Tags: Xojo, SQL-Anywhere, Dashboard Published: 2019-07-01 Für ein Unternehmen aus der Medienlogistik wurde ein Echtzeit-Steuerungssystem für die Produktion entwickelt. ## Funktionen Das Programm greift lesend und schreibend auf die Auftragsdaten der Warenwirtschaft zu und stellt Funktionen zur Produktionssteuerung bereit: - **Auftragssteuerung**: Direkter Zugriff auf aktuelle Produktionsaufträge - **Datenerfassung**: Die eigentlichen Produktionsdaten werden abschließend erfasst und stehen für Auswertungen zur Verfügung - **Live-Dashboard**: Während der Produktion zeigt ein großer TV in der Produktionshalle den aktuellen Status in Echtzeit an Das Dashboard ermöglicht allen Mitarbeitern in der Produktionshalle, den aktuellen Fortschritt und anstehende Aufträge auf einen Blick zu erfassen. --- Title: SAP SQL Anywhere-Schulung für Administratoren URL: https://www.jakoubek.net/projekt/sql-anywhere-schulung/ Description: Mehrtägige Schulung für IT-Administratoren zur Administration von SAP SQL Anywhere-Datenbanken. Tags: SQL-Anywhere, Schulung, Datenbank Published: 2019-05-01 In einem metallverarbeitenden Unternehmen wird eine SAP SQL Anywhere-Datenbank als zentrale und unternehmenskritische Datenbank eingesetzt. Die IT-Administratoren dieses Unternehmens habe ich in einer mehrtägigen Schulung begleitet. ## Schulungsinhalte - **Backup und Wiederherstellung**: Strategien für zuverlässige Datensicherung und schnelle Recovery-Szenarien - **Validierung von Backups**: Prüfung der Backup-Integrität und Wiederherstellungstests - **Hochverfügbarkeit**: Konzepte für unterbrechungsfreien Betrieb ohne Wartungsfenster - **Updatestrategien**: Sichere Updates auf SUSE Linux Enterprise Server im laufenden Betrieb Da diese Datenbank rund um die Uhr im Einsatz ist und es keine Wartungsfenster gibt, lag ein besonderer Fokus auf Hochverfügbarkeitsaspekten und Strategien für Updates ohne Betriebsunterbrechung. --- Title: Wareneingangs-Software URL: https://www.jakoubek.net/projekt/wareneingang/ Description: Wareneingang mit Integration in bestehende Warenwirtschaft. Tags: Xojo, SQL-Anywhere, Logistik Published: 2018-06-30 Für ein Unternehmen aus dem Bereich Medienlogistik wurde eine Wareneingangs-Software konzipiert und erstellt. ## Integration Die Software wurde direkt mit der bestehenden Warenwirtschafts-Software integriert: - **Erwartete Anlieferungen**: Die anhand der Aufträge aus der Warenwirtschaft zu erwartenden Anlieferungen werden direkt angezeigt - **Buchung**: Erfolgte Anlieferungen können direkt "gebucht" werden - **Rückimport**: Zusätzlich erfasste Angaben (z.B. angelieferte Mengen) werden in die Warenwirtschaft rückimportiert Diese bidirektionale Integration ermöglicht einen durchgängigen Datenfluss ohne manuelle Datenübertragung. --- Title: SQL Anywhere: Hilfe bei Performance, Upgrades und alten Versionen URL: https://www.jakoubek.net/sql-anywhere/ Description: SQL-Anywhere-Beratung seit über 25 Jahren. Performance-Tuning, Upgrades, Migration und Entwicklung. Auch für Version 11, 12 und 16. Tags: SQL-Anywhere, Datenbank, SAP Updated: 2026-08-31 Ihre Branchensoftware läuft auf SQL Anywhere, aber die Abfragen werden von Jahr zu Jahr langsamer und beim Hersteller landen Sie in der Warteschlange. Oder ein Upgrade steht an und im Haus kann niemand einschätzen, was dabei schiefgehen kann. Oder zwei Systeme sollen Daten austauschen und es fehlt jemand, der die Datenbank von innen kennt. Ich unterstütze Unternehmen bei Performanceproblemen, Upgrades und technischen Fragen rund um SAP SQL Anywhere. **Seit über 25 Jahren arbeite ich mit SQL Anywhere.** ## Auch für ältere Versionen Viele SQL-Anywhere-Installationen laufen seit Jahren stabil auf älteren Versionen. Ein Upgrade ist deshalb manchmal technisch oder wirtschaftlich auch nicht sinnvoll. Ich unterstütze auch Systeme mit SQL Anywhere 11, 12 oder 16. Gerade dann, wenn Softwarehersteller oder allgemeine IT-Dienstleister bei einer alten Installation nicht mehr weiterhelfen können oder wollen. ## Womit ich helfe **Performance-Tuning**: Analyse langsamer Abfragen, Index-Optimierung, Konfigurationsanpassungen. Oft lassen sich mit überschaubarem Aufwand deutliche Verbesserungen erzielen. **Migration und Upgrades**: Umstellung von älteren Versionen (SQL Anywhere 11, 12, 16) auf aktuelle Releases. **Entwicklung**: Stored Procedures, Trigger, Views und komplexe SQL-Abfragen. Ich kenne die Eigenheiten von SQL Anywhere und weiß, wo es sich von anderen Datenbanken unterscheidet. **Beratung und Architektur**: Analyse bestehender Datenbanken, Empfehlungen zur Optimierung, Planung von Erweiterungen. **Administration und Backup**: Einrichtung von Backup-Strategien, Automatisierung von Wartungsaufgaben, Unterstützung bei Problemen. ## Wo SQL Anywhere im Einsatz ist SQL Anywhere findet sich häufig in mittelständischen Unternehmen, die seit Jahren zuverlässig damit arbeiten, oft als Datenbank hinter einer Branchensoftware oder Eigenentwicklung. Typische Einsatzgebiete sind Warenwirtschaft, Außendienst-Lösungen mit Offline-Fähigkeit, Kassensysteme und Embedded-Anwendungen mit geringen Ressourcenanforderungen. Diese Systeme laufen meist unauffällig im Hintergrund und werden erst zum Thema, wenn ein Versionsupgrade ansteht, die Performance nachlässt oder Schnittstellen zu anderen Systemen gebraucht werden. Schreiben Sie mir kurz, welche SQL-Anywhere-Version Sie einsetzen und was bei Ihnen gerade nicht funktioniert. Ich sage Ihnen, ob ich der richtige Ansprechpartner dafür bin. --- Title: Automatisierter Versandpapierdruck URL: https://www.jakoubek.net/projekt/versandpapierdruck/ Description: Massenweises Erzeugen von PDF-Versandpapieren aus einer Warenwirtschaft. Tags: SQL-Anywhere, Xojo, Go, PDF, Automatisierung Published: 2018-04-30 Für ein Unternehmen aus dem Bereich Medienlogistik wurde die Möglichkeit geschaffen, auf Basis von Auftragsdaten in der Warenwirtschafts-Software wöchentlich PDF-Versandpapiere massenweise erzeugen zu können. ## Die Lösung Das System ermöglicht dem Unternehmen, seine Versandpapiere für verschiedene Adressaten gezielt anzupassen – ohne dafür aufwändige Änderungen an der Kern-Warenwirtschaftsanwendung vornehmen zu müssen. Der Ablauf: 1. **Daten festschreiben**: Die Auftragsdaten werden zu einem gegebenen Zeitpunkt festgeschrieben 2. **Flexible Auswahl**: Über ein Frontend-Programm können alle oder Teile der zum Druck verfügbaren Datensätze als PDF-Dokument ausgegeben werden 3. **Automatische Ablage**: Die PDFs werden direkt in einer sinnvollen Verzeichnisstruktur abgelegt 4. **Gezielter Druck**: Jeder PDF-Typ wird auf dem passenden Drucker ausgegeben ## Weiterentwicklung Bei einer späteren Fortentwicklung wurde ein Kommandozeilen-Programm für den automatisierten Einsatz auf einem Server geschaffen. Dieses Programm übernimmt mittlerweile die Festschreibung der Auftragsdaten und die automatisierte Erzeugung der PDF-Dateien völlig autonom und zeitgesteuert. Diese Lösung führte zu einer erheblichen weiteren Zeitersparnis. --- Title: Automatisierte Fakturierung und Forecasting-Schnittstelle URL: https://www.jakoubek.net/projekt/sap-schnittstelle-fakturierung/ Description: Automatisierte Schnittstelle zwischen Warenwirtschaft und SAP für fehlerfreie Fakturierung und tagesaktuelle Forecasting-Daten. Tags: Go, SQL-Anywhere, SAP, API, Automatisierung Published: 2018-01-01 ## Die Herausforderung Ein Unternehmen der Verteillogistik stand vor mehreren Herausforderungen beim Datenaustausch zwischen dem Warenwirtschaftssystem und SAP: Die manuelle Übertragung von Auftrags- und Fakturadaten war zeitaufwendig und fehleranfällig. Mitarbeiter mussten regelmäßig Daten zwischen den Systemen transferieren. Das führte zu Verzögerungen in der Rechnungsstellung. Gleichzeitig fehlte eine zeitnahe Datengrundlage für das Forecasting. Die Planungsdaten waren nicht aktuell genug. Der Kunde benötigte eine Lösung, die sowohl die Fakturierung beschleunigt als auch eine verlässliche Basis für die Unternehmensplanung schafft. ## Die Lösung Ich habe eine automatisierte Schnittstellenlösung konzipiert und entwickelt. Sie automatisiert den Datenfluss zwischen Warenwirtschaft und SAP vollständig: Das System exportiert täglich die relevanten Auftragsdaten für das Forecasting. Diese werden automatisch an die SAP-Schnittstelle übermittelt. Parallel dazu werden die abgeschlossenen Fakturadaten kontinuierlich übertragen. So kann die Rechnungserstellung direkt aus SAP heraus erfolgen. Eine wöchentliche Bereinigung storniert automatisch abgelaufene Aufträge und hält die Datenbestände aktuell. Die Architektur wurde so konzipiert, dass sie zuverlässig im Hintergrund läuft und die Fehleranfälligkeit manueller Prozesse eliminiert. ## Das Ergebnis Die Automatisierung brachte dem Kunden spürbare Verbesserungen: - **Zeitersparnis**: Die manuelle Datenübertragung entfällt vollständig. Mitarbeiter können sich auf wertschöpfende Tätigkeiten konzentrieren. - **Schnellere Fakturierung**: Rechnungen können zeitnah erstellt werden. Die Daten sind automatisch in SAP verfügbar. - **Verbesserte Planungsgrundlage**: Das Forecasting basiert nun auf tagesaktuellen Daten. Das ermöglicht fundiertere Geschäftsentscheidungen.