Messenger Check ·

Rolle: Entwickler
Domäne: Kommunikation

                           - Stack -

Python3, Threading, AsyncIO, Telethon lib

                      - Projektübersicht -

Messenger Check ist ein Python-basiertes Programm, das eine Liste von Telefonnummern verarbeitet, ihre Existenz auf Messaging-Plattformen wie Telegram und WhatsApp überprüft und die Ergebnisse in einer strukturierten JSON-Datei speichert. Bei einem großen Datensatz von Telefonnummern verarbeitet das Programm die Daten inkrementell, ohne übermäßigen Speicherverbrauch. Ursprünglich wurde dieses Programm als Komponente eines größeren OSINT-basierten Projekts entwickelt. Als sich jedoch die Anforderungen des Kunden weiterentwickelten, wurde es zu einem Hilfstool für ein Spammer-Programm. In einer Wendung der Ereignisse hat der Entwickler diese neue Richtung eingeschlagen. Die Funktion ist unkompliziert: Sie durchsucht den potenziellen Datensatz für den Spammer und stellt die Inhaltsübermittlung sicher, indem sie die Existenz der beabsichtigten Empfänger bestätigt.

               - Herausforderungen & Lösungen -

Eine der wichtigsten Herausforderungen bestand darin, eine hohe Modularität beizubehalten, sodass Benutzer bei Bedarf mehrere Messenger-APIs (sowohl synchrone als auch asynchrone) integrieren können, ohne sich Gedanken über die Vermischung von synchronem und asynchronem Code machen zu müssen. Das ist zwar nicht die ideale Vorgehensweise, erreicht aber das Ziel.

Pipeline- und Observer-Muster:

Pipeline Muster: Der Code erstellt eine Verarbeitungspipeline: Der Reader speist Daten an Beobachter, die wiederum verarbeitete Daten an die Handler weitergeben. Diese Struktur ermöglicht einen effizienten und skalierbaren Workflow, indem Aufgaben je nach Bedarf asynchron oder synchron verteilt werden.
Observer Muster: Mit Beobachtermuster, bei dem Daten basierend auf dem Beobachtertyp an relevante Handler verteilt werden.

Threading und asynchrone Ausführung:

Thread Management: Asynchrone Aufgaben werden in einem separaten Thread ausgeführt, während andere synchrone Aufgaben innerhalb des Hauptthreads verwaltet werden.
Async Task Queue verwaltet eine Aufgabenwarteschlange für asynchrone API-Aufrufe und verwendet eine Ereignisschleife, um Daten zu verarbeiten, ohne andere Threads zu blockieren.

Insgesamt beinhaltet der Code mehrere OOP-Prinzipien und -Muster sowie SOLID-Prinzipien, es besteht jedoch noch Raum für Verbesserungen.

                  - Reflexionen & Erkenntnisse -

Architektonische Wahl:

Reflexion: Die Designentscheidung beinhaltete keine Multiprocessing-Architektur. Nach gründlicher Evaluierung wurde festgestellt, dass ein Multiprocessing-Ansatz möglicherweise eine bessere Leistung oder Effizienz gebracht hätte.
Fazit: Eine sorgfältige Prüfung der Architekturmuster ist entscheidend, da die Wahl des richtigen Musters erhebliche Auswirkungen auf Leistung und Skalierbarkeit haben kann. Eine Neubewertung der ursprünglichen Entscheidungen und die Offenheit für Verbesserungen können auf lange Sicht zu optimaleren Lösungen führen.

Flexibilität:

Reflexion: Die entkoppelten Beobachter und Handler der Architektur ermöglichten eine erhebliche Anpassungsfähigkeit. Diese Flexibilität ermöglichte die Einbindung verschiedener APIs und die Änderung der Kommunikationsmodi ohne umfangreiches Refactoring.
Fazit: Ein Design, bei dem die Entkopplung im Vordergrund steht, vereinfacht die zukünftige Entwicklung und Integration und unterstreicht den Wert wartungsfreundlicher und anpassbarer Systeme.

Effizienz:

Reflexion: Die Verwendung asynchroner Verarbeitung erwies sich bei der Handhabung zahlreicher E/A-Aufgaben als effizient, während Multithreading zur allgemeinen Leistungsoptimierung beitrug. Dieser Ansatz gewährleistete einen reibungslosen Systembetrieb ohne Engpässe.
Fazit: Durch das Ausbalancieren asynchroner und Multithread-Ansätze können Leistungsziele äußerst effektiv erreicht werden, insbesondere in Szenarien mit umfangreichen E/A-Vorgängen und Datenverarbeitung.

Skalierbarkeit:

Reflection: Der modulare Aufbau des Systems unterstützt zukünftiges Wachstum, indem er das Hinzufügen neuer Dienste und Funktionen mit minimaler Störung der bestehenden Konfiguration ermöglicht.
Fazit: Wenn die Skalierbarkeit von Anfang an berücksichtigt wird, ist eine nahtlose Erweiterung möglich, was bei Systemen, die wachsen oder sich weiterentwickeln sollen, von entscheidender Bedeutung ist. Diese strategische Voraussicht kann später erhebliche Umbaukosten vermeiden.