Jonah Andersson

New episode: Mattias Karlsson on Cake Build—escaping YAML chaos for C# clarity 🎯 This conversation explored Cake (C# Make), a build orchestration framework offering an alternative to traditional YAML-based build pipelines. The key insight: using a strongly-typed language like C# for build definition provides greater clarity, debuggability, and consistency. 𝗪𝗵𝗮𝘁 𝗖𝗮𝗸𝗲 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗱𝗼𝗲𝘀: It doesn't replace MSBuild, the .NET CLI, or your CI/CD system. It orchestrates them, simplifying complex workflows and offering a more developer-friendly experience. You write workflows in C# instead of YAML, PowerShell, or Bash. Cross-platform, works identically on Mac, Windows, Linux, or in containers 💭 𝗧𝗵𝗲 𝗱𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴 𝗮𝗱𝘃𝗮𝗻𝘁𝗮𝗴𝗲 𝘁𝗵𝗮𝘁 𝗰𝗵𝗮𝗻𝗴𝗲𝘀 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴: Unlike YAML pipelines requiring push-to-runner cycles to identify issues, Cake allows loading scripts into Visual Studio or Code, setting breakpoints, and stepping through the build process locally. This dramatically speeds up development and troubleshooting. Test everything locally before pushing. 𝗣𝗹𝗮𝘁𝗳𝗼𝗿𝗺 𝗮𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻𝘀 𝗵𝗮𝗻𝗱𝗹𝗲 𝗰𝗼𝗺𝗽𝗹𝗲𝘅𝗶𝘁𝘆: Cake handles file path differences between Windows and Linux. Forward slash versus backslash? Handled. Environment variable separators? Handled. Path construction that works everywhere? Handled. You write once, run anywhere. The heavy lifting for cross-platform compatibility is done for you. 𝗦𝘁𝗿𝗼𝗻𝗴𝗹𝘆-𝘁𝘆𝗽𝗲𝗱 𝗺𝗲𝗮𝗻𝘀 𝗰𝗼𝗺𝗽𝗶𝗹𝗲𝗿-𝘃𝗲𝗿𝗶𝗳𝗶𝗲𝗱: Fully typed classes for tool arguments. You don't need to remember if parameters are integers or strings. You don't need to memorise which arguments can be combined. If it compiles, it runs. The compiler catches errors before you push. 𝗧𝗵𝗲 𝗖𝗮𝗸𝗲 𝗦𝗗𝗞 𝗮𝗱𝘃𝗮𝗻𝘁𝗮𝗴𝗲: Introduced in November 2025, Cake SDK enables single-file executables, smooth .NET ecosystem integration, and leverages .NET 10's file-based applications. Full Visual Studio Code support out of the box. Works with C# Dev Kit. Publish as containers, .NET tools, or platform-specific executables. Mattias on the learning curve: "Start with something really simple and then evolve. You don't need to replace everything at once." Available now: https://lnkd.in/ek45HzT3 #DotNet #DevOps #BuildAutomation

2

In this session, Ana Maria Mihalceanu and Moritz Halbritter show how you can take advantage of Leyden’s optimizations using Java 25 and Spring Boot. https://lnkd.in/eh-bDBEj

180

The only vendor properly addressing the "API Mesh" layer scenarios: - Service Provider <> Consumer - Service Provider <> Service Provider - Consumer <> Consumer So it's 100% Self-Service experience, no matter what is your role in organization. Example implementations: - Platform Mesh: https://platform-mesh.io - High Level Architecture: https://apeirora.eu - kcp: https://www.kcp.io With 100% API First approach. (no Terraform, no OpenTofu, K8s Operators used instead)

Good API documentation with proper OpenAPI spec is essential not only for human developers, but even more important when it comes to agentic AI

19

Ready to get your hands dirty? 💻 GitHub just launched the public preview of the remote MCP server. Time to dive in and start building your AI Agents. Check out the announcement: https://lnkd.in/eDkUJUMB What is MCP Server ? An MCP (Model Context Protocol) server is a important new technology that acts as a bridge, enabling artificial intelligence (AI) agents and large language models (LLMs) to securely and efficiently interact with external data sources and tools in real time. This standardized approach is transforming how AI applications are built and used across various industries. #GitHub #MCP #AIAgents #LetsAIsTalkEachOther #LLM #WhatsIsMCP

8

1 Comment

What happens when your Vaadin component needs to go beyond what the server-driven model offers — but you really don't want to write JavaScript? You write Java for the browser instead. In the new blog post, Matti Tahvonen explores four different approaches to running Java directly in the browser and integrating them with Vaadin Flow: 🟦 GWT (the classic source-to-JS transpiler), 🟦 TeaVM (bytecode-to-JS/WASM), 🟦 CheerpJ (a full JVM running in the browser), 🟦 and the experimental GraalVM-to-WebAssembly pipeline shipping with GraalVM 25. To make the comparison concrete, Matti rebuilt a Tetris game with each approach — same game logic in Java, same Vaadin Flow wrapper, four very different toolchains. The result is a practical look at how each one handles artifact size, startup time, code reuse, JS interoperability, and developer experience. The takeaway isn't that you should abandon Vaadin's server-side model. It's that when you need to push specific components or views to the client — for offline support, reduced latency, or less server traffic — you now have real options to do it without leaving Java. All four implementations, including the demo app and source code, are available to try. Read the full comparison 👇 https://lnkd.in/d9rkZTAn #Java #Vaadin #WebDevelopment #WebAssembly

37

3 Comments

New episode of The Modern .NET Show!🎙️ Jamie talks with Mattias about .NET Foundation project Cake, and escaping YAML chaos by defining CI/CD in C#. Strong typing, local debugging, and true cross-platform clarity make this a great listen. https://hubs.li/Q046hPTn0 #dotnet #csharp

19

2 Comments

Build and release configuration as code has become the de facto approach for most continuous build and release solutions today. Most commonly, this is done through a custom task-based, debug-resistant domain-specific language using YAML or JSON files. But what if, instead of using a markup language, you could use a proper programming language with well-defined and documented control structures, flow statements like for, while, and do, and the full expressive power of C#? In this session, we will go step-by-step through how you can orchestrate your GitHub Actions build and release pipelines using C#, powered by the Cake SDK and the latest features of .NET 10. You will see how to test and debug your pipeline locally without the slow push-and-wait cycle for CI to fail or succeed. Using standard developer tools like VS Code, you can reuse the language skills your team already has, reducing friction and unnecessary context switching. https://lnkd.in/eRcSjrTm

4

After a busy Thanksgiving, I jumped back in and finished Part 1 of "Microservices with Spring Boot and Spring Cloud" (Fourth Edition) by Magnus Larsson https://lnkd.in/eNW5QSwr and (as promised) here's my summary: Chapter 5 covers API documentation with OpenAPI and specifically the springdoc-openapi project which makes it possible to keep the documentation together with the source - which is really great, because it is much more likely to be kept up to date than if it is maintained separately to the source code. This works like most things in Spring - annotations and configuration. When you run your application, a Swagger UI endpoint will be exposed, and you can access the API documentation and test the APIs right there in the web UI. In Chapter 6, we meet persistence - something all applications need. In this chapter we learn about Spring Data JPA and create REST APIs to create and delete data in a database. We learn about structuring services in protocol, service and persistence layers. Then we meet the Entity annotation and learn how to model data for JPA using annotated POJOs, we even see how to create indexes from annotations! Then we learn about slice testing, one of my personal favorite things in Spring - it lets us test just the persistence layer in isolation, without needing to start up the rest of the context and application. And of course, we can run our favorite database using Testcontainers so that our tests actually interact with a real database, not mocks. I'm sure you know that Oracle AI Database 26ai (and earlier versions) is directly supported and with the lite images, you can start up a full Oracle database in just a few seconds. We learn how to write persistence tests and how to use JPA's great method name conventions for creating queries. Finally, we learn how to connect up the persistence layer to the service layer, update those tests, and how to expose REST services that use persistence. As a bonus, there's a tour of the Docker compose support in Spring which makes it really easy to fire up a bunch of services (like databases) that your application needs during testing. There is a lot of testing coverage in this chapter, which is fantastic. I am a big fan of automated tests, as you may know if you have read my articles before. So that brings me to the end of Part 1. Next, I am going to dive into Part 2: Leveraging Spring Cloud to Manage Microservices, which includes topics like service discovery, resilience, external configuration, and tracing. Can't wait! See you next time!

13

Bicep v0.35.1 was released last week. 💡Finally you can use @secure() decorator on module outputs! 💡New functions: parseUri() and buildUri() 💡New linter rule to catch more unsafe passing of non-secure values (use-secure-value-for-secure-inputs) Read more from the release note. #azure #bicep

22

⭐ Book Review: Learn Model Context Protocol with TypeScript by Christoffer Noring “Learn Model Context Protocol with TypeScript” is one of the most practical and forward-looking technical guides available today for developers building AI-powered applications. Christoffer Noring does an exceptional job explaining why MCP (Model Context Protocol) matters, how it evolved, and how it solves real engineering challenges in modern AI systems. The book starts by grounding the reader in the historical background and purpose of MCP, clearly showing why standardized context, structured tool integration, and safe capability execution are essential for today’s LLM-driven applications. From there, it transitions into a deep but accessible breakdown of the MCP architecture, protocol design, hosts, servers, clients, capabilities, and communication layers (STDIO & SSE). The real value shines in the hands-on chapters: Building and testing STDIO servers, including resource and tool development Implementing real-time SSE servers for streaming interactions Streamable HTTP techniques to scale MCP servers for web and cloud consumption Clean architecture patterns for production-ready server design Developing bespoke clients/agents, including LLM-integrated clients Consuming MCP servers through IDEs like Claude Desktop and VS Code The advanced chapters elevate this book beyond a basic tutorial. Topics such as elicitation techniques, sampling strategies, secure communication, authentication/authorization, and production deployment help readers understand how to design robust, scalable, and safe AI workflows — not just prototypes. By the end, the reader gains a complete mental model of MCP and a practical blueprint for building enterprise-strength AI systems that are maintainable, modular, and secure. Some areas could be strengthened with more end-to-end real-world examples and architectural diagrams to tie concepts together. More guidance on common pitfalls, debugging, and error handling would benefit beginners. TypeScript best practices around MCP patterns could be expanded further. And while production topics are covered, deeper deployment examples would make the book even more practical. Verdict: This is a must-read for AI engineers, TypeScript developers, and architects who want to build reliable, extensible, and future-proof agent-based systems. Christoffer delivers both conceptual clarity and hands-on implementation detail — making this one of the strongest resources available for developers working with MCP today. Thanks to Anamika Singh getting this on my radar! Thanks #packt# for this book 😀 #ModelContextProtocol #MCP #TypeScript #AIEngineering #AIDevelopment #LLMTools #AgentDevelopment #StreamingAPIs #Claude #OpenAI #SoftwareArchitecture #AIWorkflowDesign #ServerDevelopment #TechLeadership #AIStandards #ChristofferNoring #BookReview #Developers #LearningJourney #ModernAI #FutureOfDevelopment

11

Kubernetes is powerful. But YAML? Not so much. Here’s Harpoon in 60 seconds: No steep learning curve No YAML No security gaps Just drag, drop & deploy Visit the site & try free demo.

4

Hard Fact: If 15 people have the "System Administrator" profile, nobody is the System Administrator. Growing up as an only child, I learned a very specific kind of accountability. If a vase broke in the living room, I couldn't point to a brother or sister and say, "He or She did it." There was nowhere to hide. The evidence always pointed to one person, Me :-) I had total accountability because I had total ownership. In recent years, when I’m brought in to evaluate an Salesforce Org, I usually find the exact opposite. I pull up their user list and see dozens of people - from middle management to external consultants - with full admin privileges. They are all making changes directly in Production. Some reading the post may wonder if such orgs exist. Absolutely Yes! And what happens when a critical Flow fails on the last day of the quarter? Everyone points fingers. "Marketing adjusted the lead routing logic" "An admin updated a validation rule that impacted downstream processes" "The new developer deployed a broken package." Not trying to sound harsh or rude - But, a healthy Salesforce environment cannot function by committee. It requires an "Only Child" governance model. You need one Center of Excellence. You need one single source of truth for deployments. To all leaders in the ecosystem - Please consider stopping from handing out Admin profiles like candy just because an executive asked for it. It might sound like you are being helpful, but you are actually destroying your Org's integrity. And, like it or not - True accountability requires a bottleneck. No?

10

2 Comments

Compare Serverless vs Containerized Deployments for Web Teams. Practical how-to, tools, performance tips, NZ context, and ROI for web projects.

5