Deepak Kamboj

⚙️ Tired of manually checking your UI5 version? With ui5-version-check, you can: ✅ Instantly verify your current UI5 version ⬆️ Know when updates are available 🔄 Even trigger automatic updates (if you want to) Perfect for keeping your SAP BTP apps up-to-date and consistent. Simple. Smart. Reliable. #SAPUI5 #OpenUI5 #SAPBTP #npm #DevTools #VersionCheck #WebDevelopmenp #sapcommunity #sapdevelopers #fiori

6

1 Comment

Implementing the Singleton pattern in C# using the .NET Framework hosted on IIS ensures that your class is instantiated only once per application domain and shared across requests. Since IIS creates an application domain for each web application, a well-designed singleton will persist as long as the application pool is alive. Here’s an example of a singleton class: public sealed class AppStateManager { private static readonly Lazy<AppStateManager> instance = new Lazy<AppStateManager>(() => new AppStateManager()); // Private constructor prevents external instantiation private AppStateManager() { } public static AppStateManager Instance => instance.Value; // Example shared state public int GlobalCounter { get; set; } } This implementation leverages the Lazy<T> type to ensure that the instance is created only when it is accessed for the first time, providing thread safety and lazy initialization.

1

I’ve been working with REST APIs for quite some time, and over the years, I’ve seen how APIs have evolved far beyond basic design principles — incorporating new capabilities that make them truly distributed, scalable, and integral to modern architectures. Hence in my latest article, I’ve shared some practical insights on how to approach API discovery in modern distributed architectures. It covers real-world practices around centralizing API metadata, automating registration through CI/CD, and integrating observability for live visibility. The goal is to help teams build scalable, secure, and developer-friendly API ecosystems that actually work in production. https://lnkd.in/dZnK-rri

19

2 Comments

Why a “Non-Systems Programmer” Decided to Write a Systems & Application Programming Book in Zig - in Public - A Long Journey I am writing a #Zig Book for Non Systems Programmer(It's for me but all are welcome to join the journey). (Of-course systems programmers are welcome to review for constructive feedback as that will help everybody). Most people are aware that I work with web apps, mobile apps, enterprise systems, and large-scale backend/fullstack engineering. 30 years in software (27 years professionally), across C#, Node.js, Elixir, Python, React, Vue, Angular, Databases, you name it. I am still an experienced beginner!! But very few know this: - I originally entered programming in the 90s to build games and systems software in C. - No CS degree, almost no resources, and real-world responsibilities shifted me permanently into application development. Now, after three decades, I'm coming back to the path I never got to walk. 🎯 Why Zig, and why now? Zig is a rare language — clean, predictable, low-level, but beginner-friendly. It’s also evolving rapidly, which means: ❌ LLMs can’t keep up. ❌ Auto-generated Zig code breaks frequently. ✔️ The only way to learn Zig is to read, break, fix, repeat. And honestly, that’s exactly what I need. This book will: - force me to deeply study Zig, not just pattern-match syntax - push me back into systems-level thinking - help bridge my 30 years of app experience with low-level fundamentals - allow me to reconnect with my pre-1998 C roots and will also explore Rust as this is one another systems programming language I am always curious about. - become a long-term “learn in public” project that benefits others too 🔧 My first Zig tool (already built!) To avoid the usual “code in the book gets outdated” problem, - I wrote a Zig utility that: - reads markdown chapters - injects real .zig code into markers - treats code files as the single source of truth - automatically syncs all examples for Zig 0.15.2 (and later versions) This means the book evolves with Zig — not against it. Already a huge win. ✍️ Writing this book in public - Everything will be open: - the book - all the code - the code-sync tool - examples, experiments, failures - version bumps - all the notes and drafts Anyone can fork it, fix it, learn from it, or build on top of it. Some topics will be - Fundamentals of Systems Programming and Zig - Tools and Utilities - HTTP Servers - Server/Infra Utilities - AI/LLM applications For everyone who felt systems programming was “not for people like them.” PS: I will embrace LLM's for documentations, formatting, icons/emojis and also try out code ideas to see how much it is broken and how much LLM's learn as zig code evolves. But eventually, everything will be fixed manually. PSS: I will soon post the github link(some backlogs of previous posts will be pushed first) and website details in coming days/weeks. The best way to keep in touch and follow is to actively participate in it.

18

Don’t treat caching like old ISR Next.js 16’s new caching APIs (use cache, revalidateTag(), etc.) are explicit — using old ISR assumptions leads to stale data & confusion. 

10

3 Comments

Type safe high-speed (bitstreams) application side "Relational Join" over 7NF. ~ Array<T> implementation serves as the foundational infrastructure for applying Natural Transformations from Category Theory to physical memory layouts.  Your vision of "type-safe, arbitrary-length tuples via application-side relational algebraic joins after sorting" perfectly reconciles logical type safety with the physical efficiency of SoA (Structure of Arrays), thanks to Valhalla's Recursive Flattening of value classes. 1. Mapping and Joins as Natural Transformations  In Category Theory, if we view functors as data containers (Array) or structures (View), a Natural Transformation is a mapping that transforms one functor into another while preserving its internal structural integrity. Array.sort: This is the step that transforms a container into a canonical state based on a specific domain key (long) while preserving the relationships (morphisms) between the elements. Relational Join: The operation of joining two sorted functors, Array<View<C1>> and Array<View<C2>>, into a Pair<L, R> can be viewed as a natural transformation from the product of two functors into a new higher-order functor (a tuple). 2. Type-Safe Arbitrary-Length Tuples and Flattening  Even if arbitrary-length tuples (Triple, Quadruple, etc.) are defined as nested structures like Pair<L, Pair<M, R>>, Valhalla ensures "zero physical penalty." Physical Flattening: Since Pair is a value class, the JVM dissolves the nesting and flattens all fields into a single, contiguous memory block. Maintenance of SoA: Regardless of how long the tuple becomes, they are laid out as a sequence of primitives within the Array. This maintains a high-density SoA memory layout. 3. Sort-Merge Join (Relational Algebraic Join) By utilizing sorted Array instances, joining at the application level can be executed in linear time, O(N+M).   Type-Safe Projection: The 3-argument sort method (taking toView) allows you to extract a specific View from an already joined Pair, sort it by another attribute, and re-join it—all under the protection of compile-time type checking. Dense Matrix Operations: This process, which sequentially compares sorted attributes (long) without pointer chasing, enables Java code to achieve the throughput of a columnar database engine. Conclusion  Three core paradigms into the Java 2026 type system: 1. 7NF / Null-free: Decomposition into atomic units of data and representing absence through the "absence of a record." https://lnkd.in/g5JcGbzK 2. Natural Transformation: Type-safe, structure-preserving transformations via sort and join. https://lnkd.in/gsJKm5GB 3. Ultimate Flat Modeling: A physical optimization where Valhalla "crushes" tuples—no matter how long—into a single, dense SoA matrix. https://lnkd.in/gb7ThWb2 Programming with beautiful, Category-Theoretic abstractions (AoS interface) while reaping the rewards of flat, high-speed bitstreams that the hardware loves (SoA execution). ~

1

BTP Generative-AI-Hub-SDK Software Development Kits (SDKs) for LLMs-- Developer can use SDK for creating software applications for specific platforms or frameworks . SDK is a collection of tools, libraries, and documentation. Developers can find APIs, sample code, and other resources in SDK for building and integrate their own applications with the platform or framework. As of now many organization trying to use generative AI hub in SAP AI Launchpad to create basic prompts. Just basic prompt to generate a structured response for the prompt. However, the business need is to streamline this process to handle large scale queries and enhance the performance of LLMs for the problem. Going forward, we want to create a customized solution and integrate this output in applications. WE can achieve this using SDKs for LLMs. Use of SDKs 1.Developers can use prebuilt tools, libraries, and APIs for simplifying the development workflow using SDKs. This eliminates the need to implement complex infrastructure or low-level details when accessing LLMs. 2. SDKs facilitate easier integration of LLMs into applications, improving development efficiency. Developers can concentrate on creating solutions instead of managing model deployment and maintenance. 3. SDKs often offer customization features, such as generative-ai-hub-sdk, to leverage the power of large language models available in generative AI hub. Customization enables developers to tailor foundation LLMs for specific use cases. 4. SDKs optimize LLMs for particular hardware (for example, GPUs) and cloud platforms. Google's API, for instance, delivers state-of-the-art on-device latency for LLMs on Android and iOS devices. Naveen Jain AtosAtos SyntelEvidenSAP

24

A great two-part article series from Pavel Gelver, where he methodically compared with benchmarks, diagrams, and all, the performance differences in the execution of a typical data-copy request (multiple selects and inserts) between the EF Core ORM approach and the MSSQL Store Procedure approach. The difference in performance, and particularly in memory consumption, is staggering off the charts. Of course, doing something much simpler, like a simple select, the difference would be much smaller, if any. But to understand why that is so, you need to know how databases work. Now, imagine using this approach on a long-running background task. In an Azure Function or AWS Lambda, which are, of course, charging you by execution time. We are talking here about many thousands of $$$ difference. Yes, people do this regularly because, as the article says, "I hate stored procedures," and managers are oblivious. I used to do this kind of optimization at my regular job, and there was a huge professional envy from colleagues. Later, I started doing this as a consultant, bringing the client's expenses down significantly this way. No one has money to burn just because Uncle Bob or Erica Evans or Martin Fowler or whoever said so. And no, "I hate stored procedures" is not an argument. Now, regarding concerns that the author may have: - Simplicity: SP is simpler, just compare the amount of code. - Debugging: Yes, you can debug them locally. - Portability: most of the SP code is an actual ISO standard SQL. - Testability: Easy and doable on PostgreSQL, somewhat harder on MSSQL, but still possible. - Source control: easy. Each of these points is a broader subject that deserves an article of its own, but it's very hard or even impossible if you don't know how. Here is part one: https://lnkd.in/dbqPyZHx Part two: https://lnkd.in/dyq49kc9 And if you don't prefer Medium, here is his blog: https://lnkd.in/dxRqF3RM

19

4 Comments

Product Management has changed for good with AI. Product/feature Validation used to be very dificult due to limited data, limited industry knowledge, or customer problems. Now this all has changed leading to build better products. Exciting times!

13

1 Comment

This is a very informative blog to learn when to use the 3 different embeddings that is mostly used in Elasticsearch and why. What a good read - highly recommended. https://lnkd.in/gUxET7fv

4

Distributed System Pattern: Leader and Followers in .NET – One Decision Maker, Many Replicas, Fewer Outages #distributedsystems #designpatterns #leaders #followers #dotnet #csharp https://lnkd.in/eyUdVYKT

7

📂 Free Download – Top 25 Core System Design Q&A Over the last few weeks, I have been compiling and refining a list of 25 Core System Design Questions & Answers — explained in clear, simple terms with real-world microservices examples.   This isn’t just another theory dump. Here’s what you’ll find inside: ✅ Plain-language definitions anyone can understand ✅ Concise answers to show depth ✅ Relatable examples from real-life systems ✅ Topics covering scaling, caching, APIs, queues, consistency and more   Whether you’re preparing for architectural discussions, building scalable systems or simply curious about how things work behind the scenes, this guide is a handy go-to.   would love to hear which question or example you found most insightful after going through it. Follow me if you like this post...!   #SystemDesign #Microservices #Architecture #Scalability #TechLearning #BackendDevelopment #Java #SpringBoot

68

20 Comments

Shared buffers and memory allocation best practices in PostgreSQL shared_buffers control how much of PostgreSQL’s data is cached in memory for faster access. When tuned correctly, performance improves noticeably. When over-allocated, it can cause the system to run out of memory. We have seen cases where oversized shared_buffers left little room for the OS cache, forcing the Linux kernel to issue a SIGKILL -9 and terminate PostgreSQL. A good rule of thumb is to keep shared_buffers between 25% and 40% of total system memory; closer to 25% for mixed workloads and up to 40% for dedicated database servers. PostgreSQL and the OS both rely on memory caching. When PostgreSQL takes too much, the OS cannot function efficiently. If you would like to review your memory settings for stability and performance, our PostgreSQL Health Check can help: https://lnkd.in/dtiibRce

54

🎓 Free Tool: Claude Certified Architect – Foundations Study App  Preparing for the Claude Certified Architect – Foundations exam? I built a free, interactive study app to help you get there.  What's inside:  → 45 scenario-based questions across all 5 exam domains  → Quiz Mode for quick practice with instant feedback & explanations  → Domain Focus Mode to target your weak areas  → Full Exam Simulation — 40 questions, 60-minute timer, scored out of 1000  → Progress tracking that remembers your accuracy, streaks, and domain mastery  The 5 domains covered:  1. Agentic Architecture Design  2. Tool & Integration Design  3. Claude Code & Developer Tooling  4. API & Model Configuration  5. Testing, Evaluation & Optimization  Every question includes a real-world scenario and a detailed explanation of why each answer is correct (or not). This isn't just memorization — it's designed to build the practical reasoning the exam tests.  Completely free. No signup. No email required.  Just open it and start practicing: https://lnkd.in/gAuExdju  Built this as part of our work at HY Analytics, where we help organizations design and implement AI-powered solutions. If you're building with Claude and need help with architecture, agent design, or AI strategy — let's talk.  ---  #ClaudeAI #Anthropic #AICertification #AIArchitect #GenerativeAI #LLM #AIAgents #ClaudeCode #StudyTool #FreeResource  #HYAnalytics

4

Really useful lens on MCP, A2A, ACP, and ANP. The layered view makes it so much easier to understand where each protocol fits in building agent-driven system

7

1 Comment