13/60 ## WS Notification Service -Made a socket service for customer & provider between bidding communication - Socket.io is really exciting for real-time communication @lftechnology #60daychallenge #Socketio #WebSocket #Backend #NotificationService

Dependency Inversion Principle (DIP) is a design principle. This design principle is basically saying that High-level modules should not depend on low-level modules. They should both depend on abstractions. Example: NotificationService depends on NotificationSender interface, not EmailSender or SMSNotificationSender. Inversion of Control (IoC) is a broader architectural concept. The control of object creation and workflow is inverted from your code to a framework or container. Example: In Spring, the framework creates objects and calls your code and not the other way around. Dependency Injection (DI) is a technique for implementing IoC and supporting DIP. Dependencies are provided from the outside instead of being created internally. Example: class NotificationService { private final NotificationSender sender; NotificationService(NotificationSender sender) { this.sender = sender; } } Basically, Dependency Injection is a technique used to achieve Inversion of Control, while Dependency Inversion is a design principle that encourages depending on abstractions rather than concrete implementations.

新メンバーが既存プロジェクトに入った時、最初の数日は 「このサービスクラスの設計どうなってる？」 「テストの書き方、規約に合ってる？」 で消える。 既存コードのキャッチアップ、想像以上に重い。 チームに馴染むより先に、コードに馴染まないといけない。 うちのチームはここの一部をAI同僚にやらせてる。 リポジトリを接続するだけで、AIがコードベース全体を読み込んで、既存アーキテクチャに沿った実装をやってくれる。 セットアップ（一度だけ） ①リポジトリを接続（GitHub / GitLab / 自前のGit） ②AIワーカーの設定（プロバイダ、認証、自動起動） 普段の使い方 ①課題を作成 ②担当者に「AIユーザー」を設定 ③AIがコードベース読み取り→実装プランを提示 ④プランを確認・ワンクリックで承認 ⑤AIが実装、進捗はリアルタイムでストリーム表示 ⑥差分をレビューしてマージ 「いきなり変なコードを入れられる」心配は、プラン承認モードで防げる。 新人より、プロジェクトのルールに忠実な実装が返ってくる感覚。 課題の書き方のコツ。 件名: ユーザー一覧ページにページネーションを追加 説明: 現在 /users は全件表示。1ページ20件にしてください。 ・/issues のページネーション実装を参考に ・既存の Pagination コンポーネントを再利用 ・ページ数は ?page=2 のURLパラメータ ポイント：「参考にするファイル」を明示。 AIはコードベースを読むけど、参考箰所を指定するとさらに精度が上がる。 効くポイント ・プロジェクト固有のコーディングパターンを学習して合わせる ・AIメモリ機能で「同じ失敗を繰り返さない」 ・ファイル操作・Wiki参照・課題更新までAIが一通りやる ・使うほどプロジェクトに詳しくなる 実際にやらせている例 ・バグ修正：「ログインのメールバリデーションが効かない、テストも更新して」 ・新機能：「プロフィールにアバター画像アップロード（PNG/JPG 2MBまで）」 ・リファクタリング：「UserServiceの通知ロジックをNotificationServiceに分離」 エンジニアの仕事が「書く」から「設計と承認」にシフトする感覚。 「コードレビューする側」が増えると、チームの速度はかなり変わる。 （これ実現してるのはうちの作ってるHARVASKってツール。気になればDMください）

One class is doing: • business logic (generate) • persistence (saveToDb) • communication (sendEmail) Better split: • ReportService → generate • ReportRepository → DB • NotificationService → email One class = one reason to change.

Code Review Time 👇 class NotificationService { void send(String type) { if ("EMAIL".equals(type)) sendEmail(); else if ("SMS".equals(type)) sendSMS(); else if ("PUSH".equals(type)) sendPush(); } } Which SOLID principle is quietly suffering here? 😅

This class is doing too much. • generate → business logic • saveToDb → persistence • sendEmail → communication Split it using Single Responsibility Principle: ReportGenerator ReportRepository NotificationService Smaller classes = easier to test, change, and scale. One class → one reason to change.

6️⃣ Multi-file Refactors Find all usages of sendEmail and migrate to NotificationService. Perfect for large repositories.

2️⃣ Safe Refactoring Refactor this service to extract email logic into NotificationService. Constraints: - No API changes - Preserve behavior - Maintain tests AI becomes a high-speed refactoring assistant.

This class is violating the Single Responsibility Principle (SRP); it's handling report generation, database persistence, and email notifications all in one place. I suggest breaking it into separate components: -> ReportGenerator (core logic) -> ReportRepository (data layer) -> NotificationService (email/communication)

Cara eu uso swift. Mas com certeza deve ter. Tem que ver na doc da apple. Se chama Extended Notifications / Rich Notifications. Vc cria um service e uma extension de notificationService e outra de notificationContent, sao bundles separados do app principal, com seus proprios info.plist. Eles rodam a parte do fluxo do app. Nao é complicado, só parece.

Saga Pattern for Java/backend interviews: When a user places an order, you need to withdraw money, reserve the product, and notify the warehouse. All in different services. What to do if one of them crashes? A regular transaction won't help here. Welcome to Saga. The idea is simple: break a large distributed transaction into a chain of small local ones. Each step is its own transaction in its own service. If something goes wrong, we launch compensating transactions in reverse order. [Two approaches]:- 1. Choreography Services communicate via events. Each one knows what to do next. OrderService → [OrderCreated] → PaymentService PaymentService → [PaymentDone] → InventoryService InventoryService → [Reserved] → NotificationService - Simple, no single point of failure - Hard to track the entire flow, spaghetti of events 2. Orchestration There's a conductor — the Saga Orchestrator. It knows the entire script and commands the services. (code eg. in the image) - The flow is visible in one place, easy to debug - The orchestrator can become a bottleneck [Important to understand]: a compensating transaction ≠ a DB rollback. This is a business operation. If the money has already been withdrawn, we don't roll back the DB row, we issue a refund. In the Java ecosystem, Saga is used with: → Apache Kafka / RabbitMQ - for events between services → Axon Framework - built-in Saga support out of the box → Spring State Machine - for managing the orchestrator's state → Temporal / Conductor - infrastructure-level workflow orchestration [When to use] :- ✔️ Microservice architecture ✔️ Multiple DBs, no possibility to use 2PC ✔️ Long-lived business transactions ❌ A monolith with one DB, just use @Transactional Saga isn't a silver bullet, it's a compromise. You sacrifice isolation for scalability. Data can be temporarily inconsistent, and that's okay if the business is fine with it.

NoSuchBeanDefinitionException at startup when AlertManager fails to inject any NotificationService instance.

Running Kafka on GCP? You either: • Spin up a VM, install & manage Kafka yourself • Or use GCP’s managed Kafka (and watch your bill scale 🥲) Both aren’t exactly “side-project friendly”. Cheap & smart tip💡: Use Redpanda (Kafka-compatible) on a small e2-micro VM or Use Confluent Cloud’s free tier for dev/testing. Same Kafka APIs. Way less cost. Build smart. Scale later. 🚀 #kafka #notificationservice

Notifications look simple, until they’re not. 📳 In my latest blog, I share how to build a scalable, reliable notification service with the industry’s best practices (Kafka vs RabbitMQ, orchestrator patterns, retries & DLQs, idempotency, observability). Worth a read if you’re into robust backend systems 🔗 medium.com/@kunal_yelne/desi… #NotificationService #ScalingSystem

🧹 Clean Coding – Part 1 Clean code is about writing software that is easy to read, easy to maintain, and easy to extend. It prioritizes clarity, simplicity, consistency, and intent over clever tricks. Clean code doesn’t just reduce bugs — it improves collaboration, speeds up debugging, and makes systems future-ready. “Clean code always looks like it was written by someone who cares.” — Robert C. Martin (Uncle Bob) 🧭 Core Principles of Clean Code 📌 Meaningful Names Use descriptive, intention-revealing names for variables, methods, and classes. 👉 Variables → Nouns ❌ count ✅ totalProductCount 👉 Methods → Verbs ❌ productCount() ✅ getProductCount() 👉 Classes → Nouns ❌ SendMessage ✅ MessageSender 📌 Small & Focused Methods 👉 Keep methods short (ideally < 20 lines) ❌ processOrder() with 50 lines ✅ processOrder() with 8–12 lines 👉 Limit arguments (≤ 3) ❌ processOrder(user, product, discount, logger, config) ✅ processOrder(order) 👉 Single Responsibility, no side effects ❌ processOrderAndSendNotification(order) ✅ processOrder(order) ✅ sendNotification(order) 👉 Same level of abstraction If a method mixes high- and low-level logic, break it into smaller functions. 📌 Comments 👉 Prefer self-explanatory code over comments. ❌ // get total price of products double t = 0; for(Product p : products) { t = p.price; } ✅ double totalPrice = products.stream() .mapToDouble(Product::getPrice) .sum(); 👉 Use comments only for context or assumptions ✅ // Applying legacy discount rule until v2 API is live 📌 Formatting 👉 Use proper indentation 👉 Keep formatting consistent across the codebase 👉 Rely on IDE auto-formatting tools 📌 Classes 👉 SRP (Single Responsibility Principle) A class should have one reason to change. ❌ class Report { void generate() {} void saveToDB() {} void sendEmail() {} } ✅ class ReportGenerator {} class ReportRepository {} class ReportNotifier {} 👉 Encapsulation – hide internals ❌ order.items.add(newItem); ✅ order.addItem(newItem); 👉 High Cohesion – related responsibilities only ❌ UserService handling login payments notifications ✅ UserService, PaymentService, NotificationService 👉 Low Coupling – depend on abstractions ❌ PaymentService directly creating PaypalClient ✅ PaymentService depending on PaymentClient #CleanCode #CodingBestPractices #TDD #Refactoring #SoftwareDevelopment

👀Day 22 Studied Hours: 3h ✅ Backend -Made more progress on the email notifications in NotificationService. Also added app password so now it can actually send email notifications.

The single most expensive mistake I made as an engineer was not designing with Abstraction Layers from Day 1 🛑 I used to hard-code vendor SDKs to ship faster but that speed was an illusion. It cost me months of progress because: 💰 Vendors hike prices 300% without warning 📉 Services go bust or get acquired 🛠️ Breaking "overnight upgrades" kill production 🔌 Functionality you rely on gets deprecated I was effectively held hostage by my own dependencies. Every time a vendor changed I had to rewrite my core logic 😫 The Gift of Abstraction 🎁 If I could go back I would tell myself to build for "Plug and Play" from the very first commit. Instead of calling a specific vendor directly you should: 1️⃣ Define your own Interface (e.g. NotificationService) 2️⃣ Build an Adapter that wraps the vendor code to fit that Interface 3️⃣ Inject the dependency so your core app never knows who is providing the service When a vendor fails you it turns a catastrophic refactor into a simple morning task. You just write a new Adapter and swap it out 🔄 Don't let your roadmap be dictated by a third party. Own your architecture 🏗️ Merry Christmas Eve to everyone still shipping today! 🎅✨ Stay decoupled and stay fast. Btw, for people in the UK, I highly recommend Waddesdon Manor at this time of the year 🏰

Day 115 – Onboarding Upgrade, Notification Enhancements & UI Fixes 🚀 🔹 New Onboarding Flow – Full Documentation Ready Prepared a complete Notion document covering the entire slide-by-slide experience for the new onboarding journey. Shared with Bhavana for design alignment and content refinement. 🔹 Notification & Filter Icons Revamped Removed old Lottie animations for Notification & Filter icons. Replaced with clean static SVGs sourced directly from the official Figma file. Fixed alignment issues that appeared after swapping their positions earlier. Result: A sharper and more stable UI component set. 🔹 Personalized Notifications for Common-Like Matches Updated NotificationService to dynamically insert usernames. Users now receive messages like: “You and Rahul liked the same meme! 🎉” Adds a more human, personal touch to the experience. 🔹 Automated Notifications for Common Like Matches Upgraded CommonLikesMatchService to automatically trigger notifications when two users share 5 common liked memes. Builds richer engagement and encourages quicker user interaction. #MemeMates #FlutterDev #ProductUpdate #MobileAppDevelopment #CleanArchitecture #UIUXDesign #AppDesign #FlutterCommunity #StartupLife #BuildingInPublic #NotificationSystem #UserEngagement #Onboarding #FigmaToFlutter #DailyProgress #IndiaStartups #TechFounder #IndieHacker #StateManagement #MemeApp

(D) 5️⃣ Dependency Inversion Principle (DIP) Los módulos de alto nivel deben depender de abstracciones, no de implementaciones concretas. Ejemplo: NotificationService no debe depender directamente de “Gmail”. Debe depender de una interfaz EmailProvider. Así podemos cambiar o agregar un proveedor sin reescribir toda la lógica.