<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[YounitedTech - Medium]]></title>
        <description><![CDATA[Le blog Tech de Younited, où l’on parle de développement, d’architecture, de microservices, de cloud, de data… Et de comment on s’organise pour faire tout ça. Ah, et on recrute aussi, on vous a dit ? https://careers.younited-credit.com/ - Medium]]></description>
        <link>https://medium.com/younited-tech-blog?source=rss----b5e215f370b0---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>YounitedTech - Medium</title>
            <link>https://medium.com/younited-tech-blog?source=rss----b5e215f370b0---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 07:52:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/younited-tech-blog" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Building a Generative AI Chatbot for Loan Accounting with .NET and Azure]]></title>
            <link>https://medium.com/younited-tech-blog/building-a-generative-ai-chatbot-for-loan-accounting-with-net-and-azure-058d73ccb0ea?source=rss----b5e215f370b0---4</link>
            <guid isPermaLink="false">https://medium.com/p/058d73ccb0ea</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[chatbots]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Xavier Solau]]></dc:creator>
            <pubDate>Mon, 31 Mar 2025 15:45:48 GMT</pubDate>
            <atom:updated>2025-03-31T15:45:48.751Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building a Generative AI Chatbot for Loan Accounting with .NET</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KNpUtRwYPI2zlA3M" /><figcaption>Photo by <a href="https://unsplash.com/@askkell?utm_source=medium&amp;utm_medium=referral">Andy Kelly</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>A chatbot to help</h3><p>Lately, I have been experimenting with generative AI to explore how it can help in answering user inquiries about accounting and loan management while minimizing interruptions to the development team.</p><p>The idea is to develop a chatbot that can load all data it needs from the API to answer questions about the accounting situation of a loan.</p><p>So, for example, the user would ask the chatbot about a contract with its reference. The chatbot would then automatically load the contract data directly from the APIs and would answer the user analyzing the loaded data.</p><p>Since I already have C# business code and dotnet client to load data from the APIs, I decided to create the POC using .NET.</p><h3>Multiple AI services</h3><p>From the infrastructure point of view, it was easy to use an <a href="https://azure.microsoft.com/products/ai-services/openai-service">Azure OpenAI Service</a> and to set up a model that I can use from the chatbot.</p><p>Additionally, I wanted the flexibility to work offline with a local model running on a container or directly on my computer. To achieve this, I installed <a href="https://ollama.com/">Ollama</a> which is a really active and fast-moving project that can run LLM on CPU and or GPU (well if your GPU is compatible…. If you have got a Nvidia it’s likely to be usable).</p><p>Note that using a local solution ensures you won’t be charged for tokens but it will be significantly slower and you won’t be able to perform inference on large models.</p><p>Unfortunately, Azure OpenAI and Ollama use different client interfaces. This raises the question: should we create an abstraction layer to unify them?</p><p>Fortunately, with <strong>.NET abstractions</strong> for AI services and the <a href="https://learn.microsoft.com/dotnet/ai/ai-extensions"><strong>Microsoft.Extensions.AI</strong></a> package, integrating both infrastructures becomes seamless.</p><p>In other words, I declared several package references for my project:</p><ul><li>The abstraction: Microsoft.Extensions.AI.</li><li>The Ollama implementation: Microsoft.Extensions.AI.Ollama.</li><li>The OpenAI version: Microsoft.Extensions.AI.OpenAI.</li><li>And finally, the Azure OpenAI client: Azure.AI.OpenAI.</li></ul><p>From here, it is easy to register the services in your startup code and to make it available through service injection:</p><pre>using Azure.AI.OpenAI;<br>using Microsoft.Extensions.AI;<br><br>services.AddChatClient(provider =&gt;<br>{<br>    if (usingOpenAI)<br>    {<br>        var credential = new AzureKeyCredential(openAIKey);<br>        var azureClient = new AzureOpenAIClient(<br>            new Uri(openAIEndpoint),<br>            credential);<br>        return azureClient.AsChatClient(modelId: modelId);<br>    }<br>    else<br>    {<br>        return new OllamaChatClient(<br>            new Uri(&quot;http://localhost:11434/&quot;),<br>            modelId);<br>    }<br>}).UseFunctionInvocation();</pre><h3>Chat session history</h3><p>For this article, I need a method to request the AI service for a response. As I said, I am using the <strong>Microsoft.Extensions.AI</strong> package that contains an implementation for <strong>IChatClient</strong>. It provides several methods but there is one that serves perfectly the purpose of this article: <strong>CompleteAsync</strong>. The method returns an AI response given the provided arguments. Let’s focus on one of those arguments in particular: <strong>chatMessages</strong>.</p><pre>//<br>// Summary:<br>//     Sends chat messages to the model and returns the response messages.<br>//<br>// Parameters:<br>//   chatMessages:<br>//     The chat content to send.<br>//<br>//   options:<br>//     The chat options to configure the request.<br>//<br>//   cancellationToken:<br>//     The System.Threading.CancellationToken to monitor for cancellation<br>//     requests.<br>//     The default is System.Threading.CancellationToken.None.<br>//<br>// Returns:<br>//     The response messages generated by the client.<br>//<br>// Remarks:<br>//     The returned messages aren&#39;t added to chatMessages. However, any<br>//     intermediate messages generated implicitly by the client, including<br>//     any messages for roundtrips to the model as part of the<br>//     implementation of this request, are included.<br>Task&lt;ChatCompletion&gt; CompleteAsync(<br>    IList&lt;ChatMessage&gt; chatMessages,<br>    ChatOptions? options = null,<br>    CancellationToken cancellationToken = default(CancellationToken));</pre><p>It is the full history of the conversation with the chatbot. Since the AI services are stateless, the chat messages are stored on client side and the full history is transferred on each request. This is important to keep in mind because depending on the session size, this can have performance and cost implications.</p><p>Note that you can implement some strategy to control the size of the session history like for example using AI to summarize it.</p><p>In the history you give to the chat client, you can use messages with different roles:</p><ul><li><strong>User</strong>: for user input.</li><li><strong>Assistant</strong>: for AI model response.</li><li><strong>System</strong>: for the instructions given to the model to control the behavior of the assistant.</li><li><strong>Tool</strong>: provide additional information to the model.</li></ul><p>Here is a basic <strong>ChatSession </strong>implementation to use the <strong>IChatClient </strong>and to build the history:</p><pre>/// &lt;summary&gt;<br>/// Class to perform request on the IChatClient with a session message<br>/// history.<br>/// &lt;/summary&gt;<br>public class ChatSession<br>{<br>    private readonly List&lt;ChatMessage&gt; history = new List&lt;ChatMessage&gt;();<br>    private readonly ChatOptions? options;<br>    private readonly IChatClient client;<br><br>    /// &lt;summary&gt;<br>    /// Set up a chat session with the given IChatClient.<br>    /// &lt;/summary&gt;<br>    public ChatSession(IChatClient client, ChatOptions? options = null)<br>    {<br>        this.options = options;<br>        this.client = client;<br>    }<br><br>    /// &lt;summary&gt;<br>    /// Send a message with system role.<br>    /// &lt;/summary&gt;<br>    public Task&lt;string&gt; SendAsSystemAsync(string message)<br>    {<br>        return SendAsync(ChatRole.System, message);<br>    }<br><br>    /// &lt;summary&gt;<br>    /// Send a message with user role.<br>    /// &lt;/summary&gt;<br>    public Task&lt;string&gt; SendAsync(string message)<br>    {<br>        return SendAsync(ChatRole.User, message);<br>    }<br><br>    private async Task&lt;string&gt; SendAsync(ChatRole role, string message)<br>    {<br>        // Append the message to the history.<br>        history.Add(new ChatMessage(role, message));<br><br>        // Get the AI response.<br>        var response = await client.CompleteAsync(<br>            history,<br>            options);<br><br>        // Append the response to the history.<br>        history.Add(response.Message);<br><br>        return response.Message.Text ?? string.Empty;<br>    }<br>}</pre><h3>Enhancing Functionality with Tools</h3><p>Ok, we can chat with the chatbot, but it’s limited regarding the objective to help a user answering question about a loan contract. We could eventually put the loaded data in the system instructions, but it would be better if the chatbot could load the loan data by itself before responding to a question. This is where tools come in because this is exactly what AI can do with them.</p><p>A tool is basically a described method. By “described” I mean that the method, its arguments and its return value must be documented otherwise the IA wouldn’t understand what the tool is to use for and how to handle it.</p><p>Let’s see how we can describe a method that calculates the sum of a data vector, for example:</p><pre>[Description(&quot;Calculate the sum of the values provided as parameters.&quot;)]<br>[return: Description(&quot;The sum of the values.&quot;)]<br>public decimal ComputeSum(<br>    [Description(&quot;The array of values to be summed.&quot;)]<br>    IEnumerable&lt;decimal&gt; values)<br>{<br>    // compute the sum…<br>}</pre><p>Note that depending on the model you use, generative AI can quickly get lost with this kind of arithmetic operation, so it is sometime useful to help the model to do the computation preventing any hallucinations.</p><p>Now we can just provide the <strong>ChatSession</strong> with the tool through the options like this:</p><pre>var chatSession = new ChatSession(<br>    chatClient,<br>    new ChatOptions()<br>    {<br>       Tools = [AIFunctionFactory.Create(ComputeSum)]<br>    });</pre><p>Since the tool is available to the model, it can be used by the AI transparently. The AI will select and call the tool that matches its needs. It will also provide the correct values as arguments according to the provided argument descriptions.</p><p>If a tool is used when calling <strong>IChatClient.CompleteAsync</strong>, its response will be automatically inserted into the message history list. This is where the chat messages are used with the role: Tool.</p><h3>The support chatbot</h3><p>Well, now we have a way to use a generative AI that can use tools! Unfortunately, we are not ready to help our users yet. Depending on the prompt you give, a generative AI can behave in different ways from “satisfying and helpful” to “completely hallucinating and irrelevant”. In other words, I would say that the hardest part is still to be done.</p><p>First, we need to define the global behavior of the chatbot using a system message like this:</p><pre>You are the Support Bot and you will answer questions in English.<br>You act as a chartered accountant and manage contracts and accounting for<br>bank loans.<br>You will invite your interlocutor to ask you about a contract for which you<br>will make a small description and you will provide assistance.<br>All loans are managed in euros (EUR).</pre><p>Then we need to implement the tool that will load the loan accounting data from the API. At first, I tried to directly use the JSON data from the API in the tool with a textual explanation on where to get the data in the system prompt. Unfortunately, I couldn’t get anything interesting out of the chatbot.</p><p>I then took another approach. I defined the tool in a way it could load the data as in the first try but instead of returning the JSON data directly, I returned a textual and detailed description of the loan accounting data. With this approach, I got a much better chatbot behavior.</p><p>When I say a textual and detailed description, I mean a human readable text explaining the initial condition of the loan and all accounting transactions and operations applied on the contract. Here is an example of the contract description returned by the tool:</p><pre>The contract is referenced as CDE2022ABC123456 in the business unit DE.<br><br>Here is its history:<br><br>On the Friday, February 25, 2022:<br>The loan has an upfront interest fee of 568.57 EUR.<br>The loan borrowed amount is 26000.00 EUR.<br>The new remaining capital amount is 26568.57<br><br>On the Monday, April 4, 2022:<br>An installment movement 11180743 is registered with a total amount of<br>394.66 EUR dispatched as follow:<br> - interest: 63.84 EUR;<br> - amortization: 330.82 EUR;<br>The movement 11180743 is assigned with a total amount of 394.66 EUR<br>dispatched as follow:<br> - interest: 63.84 EUR;<br> - amortization: 330.82 EUR;<br>The new remaining capital amount is 26237.75<br><br>....<br><br>On the Tuesday, March 4, 2025:<br>An installment movement 61061552 is registered with a total amount of<br>394.66 EUR dispatched as follow:<br> - amortization: 376.71 EUR;<br> - interest: 17.95 EUR;<br>The movement 61061552 is assigned with a total amount of 394.66 EUR<br>dispatched as follow:<br> - interest: 17.95 EUR;<br> - amortization: 376.71 EUR;<br>The new remaining capital amount is 9336.09<br><br>On the Friday, April 4, 2025:<br>Upcoming term with a total amount of 394.66 EUR dispatched as follow:<br> - amortization: 377.41 EUR;<br> - interest: 17.25 EUR;<br>The new remaining capital amount will be 8958.68<br><br>....<br><br>On the Sunday, April 4, 2027:<br>Upcoming term with a total amount of 83.31 EUR dispatched as follow:<br> - amortization: 83.16 EUR;<br> - interest: 0.15 EUR;<br>The new remaining capital amount will be 0.00</pre><p>Here is a sample of the chatbot in action:</p><pre># The Bot :<br>Hello! I&#39;m here to assist you with your debt-collection and loan-related<br>queries.<br>If you have a specific contract in mind, please provide the contract<br>reference number. With this information, I can give you a detailed<br>description of the loan and offer further help if needed.<br>Feel free to ask any questions regarding a contract or loan!<br><br># You :<br>What can you tell me about the loan CDE2022ABC123456?<br><br># The Bot :<br>The loan referred to as CDE2022ABC123456 in the business unit DE has a<br>lengthy historical record. Here are the highlights:<br><br>1. **Initial Details**:<br>   - Borrowed Amount: 26,000 EUR<br>   - Upfront Interest Fee: 568.57 EUR<br>   - New Remaining Capital Amount after upfront interest: 26,568.57 EUR<br><br>2. **Installments**:<br>   - The installments began on Monday, April 4, 2022, with a monthly amount<br>     of 394.66 EUR distributed for interest and amortization.<br>   - The initial installments saw interest and amortization portions<br>     varying each month, reducing the remaining capital progressively.<br>   - On Monday, July 18, 2022, a partial refund of 4,152.39 EUR was done,<br>     changing the remaining capital.<br><br>3. **Partial Payments**:<br>   - Various installments continued at the monthly rate of 394.66 EUR.<br>   - Partial refunds and compensation movements were noted, impacting the<br>     future terms.<br><br>4. **Unpaid Fees**:<br>   - Several installments registered unpaid fees movements. These were<br>     recorded and followed up.<br>   - Each unpaid fee has an amount of 3 EUR.<br><br>5. **Upcoming Terms**:<br>   - Future terms are projected, showing monthly installments reducing the<br>     remaining capital until Sunday, April 4, 2027, when the final payment<br>     of 83.31 EUR (amortization of 83.16 EUR and interest of 0.15 EUR) will<br>     set the remaining capital to 0.<br><br>**Current Loan Status as of Tuesday, March 25, 2025**:<br>- Remaining Capital Amount: 9,336.09 EUR<br>- Next up installment due on Friday, April 4, 2025 amounting to 394.66 EUR.<br><br>If you need more specific assistance regarding this loan contract, or<br>further details on any of the points mentioned, feel free to ask!<br><br># You :<br>What was the unpaid balance on November 10, 2023?<br><br># The Bot :<br>To determine the unpaid balance of the contract CDE20220219Q17RNN5 as of<br>November 10, 2023, I&#39;ll review the historical data pertaining to the<br>contract.<br><br>Here&#39;s a summary of the recent events leading up to November 10, 2023:<br>- On November 4, 2023, an installment was registered amounting to<br>  394.66 EUR,  which consists of 365.75 EUR as amortization and 28.91 EUR<br>  as interest.<br>- On November 8, 2023, an unpaid fees movement was registered with an<br>  amount of 3.00 EUR, causing the installment movement of November 4, 2023<br>  to become unpaid, making a total unpaid balance of 397.66 EUR consisting<br>  of:<br>  - Interest: 28.91 EUR<br>  - Amortization: 365.75 EUR<br>  - Unpaid fee: 3.00 EUR<br>- On November 30, 2023, the unpaid balance was cleared, leading to a total<br>  unpaid balance of 0 EUR.<br><br>Therefore, the unpaid balance on November 10, 2023 was still the total<br>amount of 397.66 EUR.<br><br>Let me know if there&#39;s anything else you need help with regarding this<br>contract or any other accounting details!</pre><h3>Last words</h3><p>Building a generative AI-powered chatbot to assist with loan accounting inquiries is both a viable and highly beneficial solution. By leveraging <strong>Azure OpenAI</strong>, <strong>Ollama</strong>, and <strong>.NET</strong>, we can create a chatbot that seamlessly integrates with existing APIs, retrieves relevant data, and enhances user support without disrupting developers.</p><p>While the foundation is in place, optimizing the chatbot’s behavior remains an ongoing challenge. Careful prompt engineering, effective session history management, and well-defined tool integration are essential to ensure accuracy and prevent AI hallucinations. By continuously refining these aspects, we can improve the chatbot’s reliability and usefulness.</p><p>As AI technology evolves, future enhancements could include more advanced reasoning capabilities, better summarization of historical data, and improved natural language understanding. Whether running in the cloud or locally, this approach provides a scalable and adaptable way to assist users in navigating complex financial data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=058d73ccb0ea" width="1" height="1" alt=""><hr><p><a href="https://medium.com/younited-tech-blog/building-a-generative-ai-chatbot-for-loan-accounting-with-net-and-azure-058d73ccb0ea">Building a Generative AI Chatbot for Loan Accounting with .NET and Azure</a> was originally published in <a href="https://medium.com/younited-tech-blog">YounitedTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Easy .NET Web App Integration Testing with Playwright]]></title>
            <link>https://medium.com/younited-tech-blog/easy-net-web-app-integration-testing-with-playwright-9769f1f5b8e3?source=rss----b5e215f370b0---4</link>
            <guid isPermaLink="false">https://medium.com/p/9769f1f5b8e3</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[playwrights]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Xavier Solau]]></dc:creator>
            <pubDate>Tue, 29 Oct 2024 10:14:36 GMT</pubDate>
            <atom:updated>2024-10-29T10:14:36.335Z</atom:updated>
            <content:encoded><![CDATA[<h3>Easy .NET Web App Integration Testing with Playwright</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MOvxRV8PCrwYcqZ8" /><figcaption>Photo by <a href="https://unsplash.com/@cgower?utm_source=medium&amp;utm_medium=referral">Christopher Gower</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Integration Testing between Frontend and BFF</h3><p>In many web applications, the frontend relies on a Backend-for-Frontend (BFF) layer to manage data, handle API calls, and streamline communication with backend services. Integration testing between the frontend and the BFF ensures that these components work seamlessly together, helping to catch issues with data flow and user interactions early on.</p><p>However, integration testing can be complex, especially when frontend and backend are built on different technology stacks. Often, testing requires starting the host, mocking backend services, and ensuring that all components communicate properly.</p><p><a href="https://playwright.dev/dotnet/">Playwright</a> offers a streamlined solution that is both cross-platform and compatible with various development environments, including JavaScript, TypeScript, Python, Java, and .NET. Yet, even with Playwright, the setup process can be a challenge, potentially consuming hours before you even begin writing your first test. I am not even talking about integrating it into your CI/CD pipeline.</p><p>This article focuses on a scenario where a .NET backend supports your web application, and you want to perform integration tests across both the frontend and the backend.</p><h3>The Playwright test builder</h3><p>With the <a href="https://github.com/xaviersolau/CodeQuality">Playwright test builder</a>, testing your .NET hosted web application has never been easier. The builder automates the setup process, handling host startup, Playwright engine configuration, and dependency installation, so you can focus on writing your tests.</p><p>In addition, if you need to run your tests in parallel, the Playwright Test Builder configures network resources to ensure isolated and concurrent test execution.</p><p>This automation allows you to write tests with minimal setup, reducing friction and enhancing productivity.</p><p>In the following sections, I’ll guide you through setting up Playwright for a <a href="https://dotnet.microsoft.com/apps/aspnet/web-apps/blazor">Blazor</a> application. I’ll then explain how these principles apply to other frameworks, especially <a href="https://react.dev/">React</a>.</p><blockquote>Note that the process is similar for <a href="https://angular.dev/">Angular</a>.</blockquote><h3>Set up the solution</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fpky6c_iy2gb31Xy" /><figcaption>Photo by <a href="https://unsplash.com/@bradencollum?utm_source=medium&amp;utm_medium=referral">Braden Collum</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Now, we will set up the solution with a Web Application and a test project for the purposes of this article.</p><p>First create the solution with the Blazor Web Application project using those commands:</p><pre>dotnet new sln --output DemoTestBuilder<br>cd DemoTestBuilder<br>dotnet new blazor --output AppBlazor<br>dotnet sln add AppBlazor</pre><p>Now we can create the test project. Here, I am going to use an xUnit project but you can use any other testing framework.</p><pre>dotnet new xunit --output AppBlazorTests<br>dotnet sln add AppBlazorTests</pre><p>Finally, we can add a reference to the Web Application project in the created test project.</p><pre>dotnet add AppBlazorTests/AppBlazorTests.csproj reference AppBlazor/AppBlazor.csproj</pre><h3>Install PlaywrightTestBuilder package</h3><p>In order to use the <a href="https://www.nuget.org/packages/SoloX.CodeQuality.Playwright">PlaywrightTestBuilder</a> we need to install the Nuget package:</p><pre>cd AppBlazorTests<br>dotnet add package SoloX.CodeQuality.Playwright</pre><p>The namespace of the PlaywrightTestBuilder is SoloX.CodeQuality.Playwright, so don&#39;t forget to add it to the default namespace. Alternatively, you can use the using statement in your test files.</p><h3>Create a production service</h3><p>For the purpose of this article, we are going to add a “<em>Production</em>” service that will provide the welcome message displayed in the home page of the Web application.</p><p>First, we add the service interface IWelcomeMessageService in a Services folder created in the application project:</p><pre>namespace AppBlazor.Services<br>{<br>    /// &lt;summary&gt;<br>    /// Service interface that will be injected and used in the application Home page.<br>    /// &lt;/summary&gt;<br>    public interface IWelcomeMessageService<br>    {<br>        /// &lt;summary&gt;<br>        /// Get the production welcome message.<br>        /// &lt;/summary&gt;<br>        string GetMessage();<br>    }<br>}</pre><p>Then, we can add the production service implementation WelcomeMessageService that will be replaced in the tests:</p><pre>namespace AppBlazor.Services<br>{<br>    /// &lt;summary&gt;<br>    /// Production service implementation that will be replaced in the test project.<br>    /// &lt;/summary&gt;<br>    public class WelcomeMessageService : IWelcomeMessageService<br>    {<br>        /// &lt;summary&gt;<br>        /// Get the production welcome message.<br>        /// &lt;/summary&gt;<br>        public string GetMessage()<br>        {<br>            return &quot;Welcome to your new app in Production.&quot;;<br>        }<br>    }<br>}</pre><p>Let’s register it in the Program.cs file:</p><pre>// Register the production service.<br>builder.Services.AddTransient&lt;IWelcomeMessageService, WelcomeMessageService&gt;();</pre><p>Finally, we can use it in the home page in the file Components/Pages/Home.cs removing the hardcoded welcome message and using the service instead:</p><pre>@page &quot;/&quot;<br><br>@inject Services.IWelcomeMessageService welcomeMessageService<br><br>&lt;PageTitle&gt;Home&lt;/PageTitle&gt;<br><br>&lt;h1&gt;Hello, world!&lt;/h1&gt;<br><br>@((MarkupString)welcomeMessageService.GetMessage())</pre><h3>Write the tests</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6n5g_Vwi0UJmqgHt" /><figcaption>Photo by <a href="https://unsplash.com/@whatyouhide?utm_source=medium&amp;utm_medium=referral">Andrea Leopardi</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Now that we have the solution ready, we can start writing a test.</p><p>For this example, we are going to replace the IWelcomeMessageService production implementation with the test implementation TestWelcomeMessageService.</p><pre>using AppBlazor.Services;<br><br>namespace AppBlazorTests<br>{<br>    /// &lt;summary&gt;<br>    /// Test service implementation that will replace the one in the application.<br>    /// &lt;/summary&gt;<br>    public class TestWelcomeMessageService : IWelcomeMessageService<br>    {<br>        /// &lt;summary&gt;<br>        /// Get the test welcome message.<br>        /// &lt;/summary&gt;<br>        public string GetMessage()<br>        {<br>            return &quot;&lt;p data-test=\&quot;test-message\&quot;&gt;Welcome to your Test.&lt;p&gt;&quot;;<br>        }<br>    }<br>}</pre><p>Now, let’s create a basic test class WebAppTests that is going to test that the Web Application is working and serving the main page using different browsers.</p><pre>// Don&#39;t forget to specify the test builder namespace.<br>using SoloX.CodeQuality.Playwright;<br><br>namespace AppBlazorTests<br>{<br>    public class WebAppTests<br>    {<br>        /// &lt;summary&gt;<br>        /// Since we want to run the test with different browsers we can use a Theory and inline<br>        /// the list of browsers.<br>        /// &lt;/summary&gt;<br>        /// &lt;param name=&quot;browser&quot;&gt;The browser we are going to use in the test.&lt;/param&gt;<br>        [Theory]<br>        [InlineData(Browser.Chromium)]<br>        [InlineData(Browser.Firefox)]<br>        [InlineData(Browser.Webkit)]<br>        public async Task IsShouldStartTheApplicationAndServeTheMainPage(Browser browser)<br>        {<br>            // The test implementation...<br>        }<br>    }<br>}</pre><p>The first step to write the test is to define the way you want to run the host with the builder. In this step we need to tell where to find the Application entry point assembly specifying a Type (like Program or App for example) and we will be able to override some app settings and/or some app services.</p><blockquote>Behind the scene, the PlaywrightTestBuilder is using a <a href="https://learn.microsoft.com/aspnet/core/test/integration-tests?view=aspnetcore-8.0">WebApplicationFactory</a> so we can access the IWebHostBuilder to customize and/or override settings and services.</blockquote><pre>// Get a PlaywrightTestBuilder instance.<br>var builder = PlaywrightTestBuilder.Create()<br>    // Tells that we run a local host.<br>    .WithLocalHost(localHostBuilder =&gt;<br>    {<br>        localHostBuilder<br>            // It tells that we use a local application and we provide a type<br>            // defined in the application entry point assembly (like Program, App<br>            // or any type defined in the host assembly).<br>            .UseApplication&lt;AppBlazor.Components.App&gt;()<br>            // Since the test builder is using the WebApplicationFactory, we can<br>            // use the IWebHostBuilder.<br>            .UseWebHostBuilder(webHostBuilder =&gt;<br>            {<br>                // Specify some settings<br>                webHostBuilder.UseSetting(&quot;MySettingKey&quot;, &quot;MySettingValue&quot;);<br><br>                // Specify some service mocks<br>                webHostBuilder.ConfigureServices(services =&gt;<br>                {<br>                    // Replace the IWelcomeMessageService implementation.<br>                    services.AddTransient&lt;IWelcomeMessageService, TestWelcomeMessageService&gt;();<br>                });<br>            });<br>    });</pre><p>Additionally, it is possible to specify the Playwright options like:</p><ul><li><strong>Headless</strong> to tell if we want the browser to be displayed on the screen;</li><li><strong>SlowMo</strong> to slow down the test actions;</li></ul><p>And the PlaywrightNewContext options like:</p><ul><li><strong>ViewportSize</strong> to specify the viewport size;</li><li><strong>StorageStatePath</strong> to specify the json file location where to load the storage from;</li></ul><blockquote>Note that running your test on CI, the Headless option must not be set to false.</blockquote><pre>builder = builder<br>    // Allows you to set up Playwright options.<br>    .WithPlaywrightOptions(opt =&gt;<br>    {<br>        // Tells that we want the browser to be displayed on the screen.<br>        opt.Headless = false;<br>    })<br>    // Allows you to set up Playwright New Context options.<br>    .WithPlaywrightNewContextOptions(opt =&gt;<br>    {<br>        // Tells that the viewport size will be 1000x800<br>        opt.ViewportSize = new Microsoft.Playwright.ViewportSize()<br>        { Width = 1000, Height = 800 };<br>    });</pre><p>We can also configure the builder to enable trace generation, which can be helpful in debugging and understanding the behavior of your tests:</p><pre>builder = builder<br>    // Enable traces.<br>    .WithTraces(tracesConfiguration =&gt;<br>    {<br>        // Save traces in the given file.<br>        tracesConfiguration.UseOutputFile($&quot;traces_{browser}.zip&quot;);<br>    });</pre><blockquote>For more information about using traces, check out the <a href="https://playwright.dev/dotnet/docs/trace-viewer-intro">Playwright trace viewer introduction</a>. You can also explore the <a href="https://trace.playwright.dev/">online trace viewer</a> for an interactive experience.</blockquote><p>Once the builder is configured, we can instantiate the PlaywrightTest and run the test. In this example, we are simply opening the browser to target the host index and verifying that we can locate the body element within the page. We can also verify that the home page displays the message provided by the IWelcomeMessageService checking the text set in the service mock.</p><blockquote>Don’t forget the await using since IPlaywrightTest is a IAsyncDisposable.</blockquote><pre>// Create the playwright test.<br>await using var playwrightTest = await builder.BuildAsync();<br><br>// Now we can use the PlaywrightTest and navigate to the page to test.<br>await playwrightTest.GotoPageAsync(string.Empty, async page =&gt;<br>{<br>    var body = page.Locator(&quot;body&quot;);<br><br>    await body.WaitForAsync();<br><br>    var message = page.Locator(&quot;//*[@data-test=\&quot;test-message\&quot;]&quot;);<br>    <br>    var txt = await message.TextContentAsync();<br>    <br>    txt.Should().Be(&quot;Welcome to your Test.&quot;);<br>});</pre><h3>Run the tests</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HRLR570fnor8dgC_" /><figcaption>Photo by <a href="https://unsplash.com/@rockthechaos?utm_source=medium&amp;utm_medium=referral">Kolleen Gladden</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>The first time you run the tests, it may take several minutes as Playwright needs to deploy all its tooling and dependencies. It is only processed once and it will detect the platform it is running on.</p><p>You can run the test as usual using the dotnet test command and it will also work on your CI!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A9iatyITgFAXF2kBcbni8A.png" /><figcaption>Running tests with <strong>Headless</strong> false</figcaption></figure><p>Finally, you can run your tests in parallel. The PlaywrightTestBuilder will set up the host so that it will be specific to the test and it will use a dedicated network port isolating all tests to prevent conflicts.</p><h3>Apply to other frameworks</h3><p>Now I will adapt the Blazor example using React and it would be the same for Angular.</p><p>First, add the React projects. I assume all React required tooling (like node.js, npm…) are installed on your environment and that you are in the solution folder DemoTestBuilder:</p><pre>dotnet new react --output AppReact<br>dotnet sln add AppReact<br><br>dotnet new xunit --output AppReactTests<br>dotnet sln add AppReactTests<br><br>dotnet add AppReactTests/AppReactTests.csproj reference AppReact/AppReact.csproj<br><br>cd AppReactTests<br>dotnet add package SoloX.CodeQuality.Playwright</pre><p>From this point, with all React project ready, we can write our test like in the Blazor example. Unfortunately, it won’t work directly because the React template is using a SpaProxy while running your application from your development environment.</p><p>In order to be able to test it, we need to build the React application package in a dedicated build step in the test project.</p><p>Here is the target we need to add to the AppReactTests.csproj:</p><pre>&lt;Target Name=&quot;BuildReactWebApp&quot; BeforeTargets=&quot;Build&quot;&gt;<br>   &lt;!-- Use npm run build to generate the React application package. --&gt;<br>   &lt;Exec WorkingDirectory=&quot;../AppReact/ClientApp&quot; Command=&quot;npm run build&quot;&gt;&lt;/Exec&gt;<br><br>   &lt;!-- Select all files form the package. --&gt;<br>   &lt;ItemGroup&gt;<br>      &lt;BuildItems Include=&quot;../AppReact/ClientApp/build/**/*.*&quot; /&gt;<br>   &lt;/ItemGroup&gt;<br><br>   &lt;!-- And Copy the package in the test output folder. --&gt;<br>   &lt;Copy SourceFiles=&quot;@(BuildItems)&quot; DestinationFolder=&quot;$(OutputPath)\build\%(RecursiveDir)&quot;&gt;&lt;/Copy&gt;<br>&lt;/Target&gt;</pre><p>Now in the test builder we need to set up the host to base its WebRoot folder to the one we have just generated.</p><pre>localHostBuilder<br>    // It tells that we use a local application and we provide a type<br>    // defined in the application assembly entry point (like Program, App<br>    // or any type defined in the host assembly).<br>    .UseApplication&lt;AppReact.WeatherForecast&gt;()<br>    // Since the test builder is using the WebApplicationFactory, we can<br>    // use the IWebHostBuilder.<br>    .UseWebHostBuilder(webHostBuilder =&gt;<br>    {<br>        // Get the current project output.<br>        var webAppPath = Path.GetDirectoryName(typeof(WebAppTests).Assembly.Location);<br><br>        // Tells the web host the path where to read the web root static assets.<br>        webHostBuilder.UseWebRoot(Path.Combine(webAppPath!, &quot;build&quot;));<br><br>        // Apply as previously the settings and/or services overrides.<br>        // ...<br>    });</pre><p>You can now run the test using React!</p><h3>Final Thoughts</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mpDNjHvdzHNuuUSN" /><figcaption>Photo by <a href="https://unsplash.com/@itscakefortea?utm_source=medium&amp;utm_medium=referral">david Griffiths</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>As you can see, it is really easy to set up a Playwright test for your .NET hosted Web Application. It streamlines the entire testing process by managing dependencies, configuring the test environment, and supporting parallel execution. Whether you’re using Blazor, Angular, or React, PlaywrightTestBuilder offers a versatile solution that allows you to focus on writing tests, not on managing infrastructure.</p><p>I encourage you to give a try to the PlaywrightTestBuilder and I hope that you will find it very useful. If you want to find out more, you can take a look at the <a href="https://github.com/xaviersolau/CodeQuality">project repository</a>.</p><p>Additionally, to view the full code for this example, visit the <a href="https://github.com/xaviersolau/DevArticles/tree/demo_test_builder">examples repository</a>.</p><p>Happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9769f1f5b8e3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/younited-tech-blog/easy-net-web-app-integration-testing-with-playwright-9769f1f5b8e3">Easy .NET Web App Integration Testing with Playwright</a> was originally published in <a href="https://medium.com/younited-tech-blog">YounitedTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Code first Json localization on Blazor Web App]]></title>
            <link>https://medium.com/younited-tech-blog/code-first-json-localization-on-blazor-web-app-a1b18352dd67?source=rss----b5e215f370b0---4</link>
            <guid isPermaLink="false">https://medium.com/p/a1b18352dd67</guid>
            <category><![CDATA[localization]]></category>
            <category><![CDATA[blazor]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[dotnet]]></category>
            <dc:creator><![CDATA[Xavier Solau]]></dc:creator>
            <pubDate>Thu, 18 Apr 2024 12:40:56 GMT</pubDate>
            <atom:updated>2024-04-18T12:40:56.762Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1IJXkeVpt21XqlhI" /><figcaption>Photo by <a href="https://unsplash.com/@alschim?utm_source=medium&amp;utm_medium=referral">Alexander Schimmeck</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Have you ever used localization with dotnet and Blazor? If so, you’ve probably noticed that it can be quite verbose in some way because you have to use textual keys to access localized string values in the code that you have to repeat in the Json files and that you have to maintain manually. In this article, I will demonstrate how to simplify all this writing almost only C# interfaces.</p><blockquote>Note that we will see a practical use case of the localization tooling in a Blazor Web App but it can be used in any kind of dotnet projects.</blockquote><h3>Create a Blazor Web App</h3><p>First, we are going to set up a project with the new Blazor Web App template that was released with .Net 8.0 and we are going to enable Json localization.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/803/1*hqwb8UxYzyAJsXcdMVt6Tg.png" /></figure><p>The Blazor Web App project provides both support for server-side and client-side web assembly rendering.</p><blockquote>Note that you can learn more about Blazor Hybrid Web Application on this <a href="https://learn.microsoft.com/aspnet/core/blazor/hybrid/?view=aspnetcore-8.0">page</a>.</blockquote><p>To create a new Blazor hybrid web application, we can run the dotnet command:</p><pre>dotnet new blazor --name MyWebApp -o MyWebApp -int WebAssembly</pre><p>This is resulting in the creation of 2 projects:</p><ul><li>One for web hosting and server-side rendering:<br>MyWebApp\MyWebApp.csproj</li><li>And another one for the web assembly client:<br>MyWebApp.Client\MyWebApp.Client.csproj</li></ul><h3>Enable Json localization</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_sa8yjnk97hreOXl" /><figcaption>Photo by <a href="https://unsplash.com/@homajob?utm_source=medium&amp;utm_medium=referral">Scott Graham</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Now that our web application is created, we can upgrade our projects with Json localization support. To do so we will update both projects adding some dependencies and some services provided by this <a href="https://github.com/xaviersolau/BlazorJsonLocalization">library</a>.</p><p>In this example we are going to host the Json localization files as HTTP static assets in the application.</p><h4>Set up server-side project</h4><p>First, update the server project to add the Nuget package that enables the Json localization features:</p><pre>dotnet add MyWebApp/MyWebApp.csproj package SoloX.BlazorJsonLocalization.ServerSide<br>dotnet add MyWebApp/MyWebApp.csproj package SoloX.BlazorJsonLocalization.Attributes</pre><blockquote>Note that the SoloX.BlazorJsonLocalization.Attributes package is only required for the code first tooling.</blockquote><p>Update the MyWebApp/Program.cs file to register the localization services like this:</p><pre>using SoloX.BlazorJsonLocalization.ServerSide;<br><br>// [...]<br><br>// Add services to enable Json localization.<br>builder.Services<br>  .AddServerSideJsonLocalization(builder =&gt;<br>  {<br>    builder<br>      .UseHttpHostedJson(options =&gt;<br>      {<br>        // Set up the HTTP main static assets contributor assemblies.<br>        // Here we need both the Host assembly and the Client because the<br>        // host can render components from both the host side or the client<br>        // side.<br>        options.ApplicationAssemblies =<br>        [<br>          typeof(MyWebApp.Client._Imports).Assembly,<br>          typeof(MyWebApp.Components.App).Assembly<br>        ];<br>      });<br>  });</pre><h4>Set up client-side project</h4><p>Then update the client project to add the Nuget package to enable Json localization features dedicated to WebAssembly:</p><pre>dotnet add MyWebApp.Client/MyWebApp.Client.csproj package SoloX.BlazorJsonLocalization.WebAssembly<br>dotnet add MyWebApp.Client/MyWebApp.Client.csproj package SoloX.BlazorJsonLocalization.Attributes</pre><p>Update the MyWebApp.Client/Program.cs file to register the localization services like this:</p><pre>using SoloX.BlazorJsonLocalization.WebAssembly;<br><br>// [...]<br><br>// Since our localization files are HTTP assets, we need to inject the Host<br>// HttpClient.<br>builder.Services<br>  .AddScoped(sp =&gt; new HttpClient<br>  {<br>    BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)<br>  });<br><br>// Add services to enable Json localization.<br>builder.Services<br>  .AddWebAssemblyJsonLocalization(builder =&gt;<br>  {<br>    builder<br>      .UseHttpHostedJson(options =&gt;<br>      {<br>        // Setup the HTTP main static assets contributor assemblies.<br>        // Here we only need the Client assembly because the Client won&#39;t<br>        // use any localization from the server side.<br>        options.ApplicationAssembly =<br>          typeof(MyWebApp.Client._Imports).Assembly;<br>      });<br>  });</pre><h3>Install the localization generator tool</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4DY8fXUL-q_9orgl" /><figcaption>Photo by <a href="https://unsplash.com/@sigmund?utm_source=medium&amp;utm_medium=referral">Sigmund</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Code First Localization feature requires to use a dotnet tool to generate all localization code and the default Json files. We are going to register the tool within the current solution.</p><p>We need to create a dotnet tool manifest file within the solution:</p><pre>dotnet new tool-manifest</pre><p>Once the manifest is created, we can register the tool:</p><pre>dotnet tool install SoloX.BlazorJsonLocalization.Tools.Command</pre><p>The LocalizationGen tool is now ready to be used and you can use it with the dotnet command:</p><pre>dotnet localizationgen</pre><h3>Create our localized messages</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZLCW-t-_WzcLhStM" /><figcaption>Photo by <a href="https://unsplash.com/@bekkybekks?utm_source=medium&amp;utm_medium=referral">Bekky Bekks</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Now we are going to create our first application localized messages.</p><p>In this example we will create 2 sets of messages: one dedicated to the server project and one another for the client project.</p><blockquote>Note that you may define multiple localization sets. For example, you may define one set per component or per page, depending on your preferences.</blockquote><p>To define your messages you will need to write an interface with one property or one method to point to one localized message. The idea is to inject this interface in your component to get access to your localized message values.</p><blockquote>The LocalizationGen tool will help you to write the class implementing your interface.</blockquote><h4>Create a localizer on the server-side</h4><p>On the server project we can create an interface to describe your messages and the way you want to use it. Since this localization tooling is based on the <a href="https://learn.microsoft.com/dotnet/core/extensions/localization">.Net localization</a> abstraction our interface is extending <a href="https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.localization.istringlocalizer-1?view=dotnet-plat-ext-8.0">Microsoft.Extensions.Localization.IStringLocalizer&lt;T&gt;</a>.</p><p>Let’s create the file:<br>MyWebApp/Localizer/IServerGlobalStringLocalizer.cs</p><p>And write the interface:</p><pre>using Microsoft.Extensions.Localization;<br>using SoloX.BlazorJsonLocalization.Attributes;<br><br>namespace MyWebApp.Localizer<br>{<br>  /// &lt;summary&gt;<br>  /// The component class.<br>  /// In this example it is an empty class but instead you can use directly<br>  /// a razor component.<br>  /// &lt;/summary&gt;<br>  public class ServerGlobal<br>  {<br>  }<br><br>  /// &lt;summary&gt;<br>  /// Here, we use the Localizer attribute to tell the LocalizationGen tool<br>  /// that we need the Json file stored in the wwwroot folder and that we<br>  /// want the fr-FR and en-UK files in addition of the default Json file.<br>  /// &lt;/summary&gt;<br>  [Localizer(&quot;wwwroot&quot;, [&quot;fr-FR&quot;, &quot;en-UK&quot;])]<br>  public interface IServerGlobalStringLocalizer :<br>    IStringLocalizer&lt;ServerGlobal&gt;<br>  {<br>    /// &lt;summary&gt;<br>    /// Let&#39;s define some properties to access the localized values.<br>    /// The optional Translate attribute allows to define a default<br>    /// translation for the localized entry.<br>    /// &lt;/summary&gt;<br><br>    [Translate(&quot;Home&quot;)]<br>    string HomePageTitle { get; }<br><br>    [Translate(&quot;Hello, world!&quot;)]<br>    string HelloTitle { get; }<br><br>    [Translate(&quot;Welcome to your new app.&quot;)]<br>    string HelloBody { get; }<br>  }<br>}</pre><h4>Create a localizer on the client-side</h4><p>Now we can create the interface on the client project with the file:<br>MyWebApp.Client/Localizer/IClientGlobalStringLocalizer.cs</p><p>And write the interface:</p><pre>using Microsoft.Extensions.Localization;<br>using SoloX.BlazorJsonLocalization.Attributes;<br><br>namespace MyWebApp.Client.Localizer<br>{<br>  /// &lt;summary&gt;<br>  /// The component class.<br>  /// In this example it is an empty class but instead you can use directly<br>  /// a razor component.<br>  /// &lt;/summary&gt;<br>  public class ClientGlobal<br>  {<br>  }<br><br>  /// &lt;summary&gt;<br>  /// Here, we use the Localizer attribute to tell the LocalizationGen tool<br>  /// that we need the Json file stored in the wwwroot folder and that we<br>  /// want the fr-FR and en-UK files in addition of the default Json file.<br>  /// &lt;/summary&gt;<br>  [Localizer(&quot;wwwroot&quot;, [&quot;fr-FR&quot;, &quot;en-UK&quot;])]<br>  public interface IClientGlobalStringLocalizer :<br>    IStringLocalizer&lt;ClientGlobal&gt;<br>  {<br>    /// &lt;summary&gt;<br>    /// Let&#39;s define properties to access the localized values.<br>    /// The optional Translate attribute allows to define a default<br>    /// translation for the localized entry.<br>    /// &lt;/summary&gt;<br><br>    [Translate(&quot;Counter&quot;)]<br>    string CounterPageTitle { get; }<br><br>    [Translate(&quot;Counter&quot;)]<br>    string CounterTitle { get; }<br><br>    [Translate(&quot;Click me&quot;)]<br>    string ClickMe {  get; }<br><br>    /// &lt;summary&gt;<br>    /// Here is an example where we define a localized entry with a method<br>    /// instead of a property. This is to provide a way to use arguments in<br>    /// your localized message.<br>    /// &lt;/summary&gt;<br>    /// &lt;param name=&quot;currentCount&quot;&gt;<br>    /// The argument we want to use in the message.<br>    /// &lt;/param&gt;<br>    /// &lt;returns&gt;The localized value with the argument(s) serialized within<br>    /// the message.<br>    /// &lt;/returns&gt;<br>    [Translate(&quot;Current count: {0}&quot;)]<br>    string CurrentCount(int currentCount);<br>  }<br>}</pre><h3>Generate the localization implementation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n6wNzuG6JXlt1IkS" /><figcaption>Photo by <a href="https://unsplash.com/@cakirchoff?utm_source=medium&amp;utm_medium=referral">Chad Kirchoff</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Using the LocalizationGen tool</h4><p>Once your interfaces are created, we can run the LocalizationGen tool to generate the interface implementations and the associated Json resources.</p><pre>dotnet localizationgen MyWebApp/MyWebApp.csproj</pre><p>The tool will generate the CS files:<br>MyWebApp\Localizer\ServerGlobalStringLocalizer.g.cs<br>MyWebApp\Localizer\ServerGlobalStringLocalizerExtensions.g.cs</p><p>And the Json files:<br>MyWebApp\wwwroot\Localizer\ServerGlobal.json<br>MyWebApp\wwwroot\Localizer\ServerGlobal.fr-FR.json<br>MyWebApp\wwwroot\Localizer\ServerGlobal.en-UK.json</p><p>Then we can run the command on the client side:</p><pre>dotnet localizationgen MyWebApp.Client/MyWebApp.Client.csproj</pre><p>Resulting in the CS files:<br>MyWebApp.Client\Localizer\ClientGlobalStringLocalizer.g.cs<br>MyWebApp.Client\Localizer\ClientGlobalStringLocalizerExtensions.g.cs</p><p>And the Json files:<br>MyWebApp.Client\wwwroot\Localizer\ClientGlobal.json<br>MyWebApp.Client\wwwroot\Localizer\ClientGlobal.fr-FR.json<br>MyWebApp.Client\wwwroot\Localizer\ClientGlobal.en-UK.json</p><h4>Update translation in the Json files</h4><p>As you can see, the Json files have been generated with the default value or with the value defined with the attribute Translate.</p><p>ServerGlobal.json will look like:</p><pre>{<br>  &quot;HomePageTitle&quot;: &quot;Home&quot;,<br>  &quot;HelloTitle&quot;: &quot;Hello, world!&quot;,<br>  &quot;HelloBody&quot;: &quot;Welcome to your new app.&quot;<br>}</pre><p>And ClientGlobal.json will look like:</p><pre>{<br>  &quot;CounterPageTitle&quot;: &quot;Counter&quot;,<br>  &quot;CounterTitle&quot;: &quot;Counter&quot;,<br>  &quot;CurrentCount&quot;: &quot;Current count: {0}&quot;,<br>  &quot;ClickMe&quot;: &quot;Click me&quot;<br>}</pre><p>You can update those files with the proper translations and don’t worry, if you run the generation tool again your translation won’t be overwritten. Only new message key will be added.</p><p>In this example we can change the ServerGlobal.fr-FR.json and the ClientGlobal.fr-FR.json with the proper French message translations.</p><p>The ServerGlobal.fr-FR.json will look like this:</p><pre>{<br>  &quot;HomePageTitle&quot;: &quot;Accueil&quot;,<br>  &quot;HelloTitle&quot;: &quot;Bonjour à tous !&quot;,<br>  &quot;HelloBody&quot;: &quot;Bienvenu dans votre nouvelle application.&quot;<br>}</pre><p>And ClientGlobal.fr-FR.json like this:</p><pre>{<br>  &quot;CounterPageTitle&quot;: &quot;Compteur&quot;,<br>  &quot;CounterTitle&quot;: &quot;Compteur&quot;,<br>  &quot;CurrentCount&quot;: &quot;Compte courant : {0}&quot;,<br>  &quot;ClickMe&quot;: &quot;Cliquer ici&quot;<br>}</pre><h3>Register and use the localizer</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sEVMC-cNcRqehMmk" /><figcaption>Photo by <a href="https://unsplash.com/@nasa?utm_source=medium&amp;utm_medium=referral">NASA</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Now that the localizer interface implementations are generated, we can update the services registration to be able to inject the right implementation in your components.</p><h4>Register the implementations</h4><p>In the server project we can update the MyWebApp/Program.cs file:</p><pre>using MyWebApp.Client.Localizer;<br>using MyWebApp.Localizer;<br><br>// [...]<br><br>builder.Services<br>  // Register the server global localization.<br>  .AddTransient&lt;IServerGlobalStringLocalizer, ServerGlobalStringLocalizer&gt;()<br>  // Since client pages can also be rendered on server side we need to<br>  // register the client global localization.<br>  .AddTransient&lt;IClientGlobalStringLocalizer, ClientGlobalStringLocalizer&gt;();</pre><p>And in the client project we can update the file:<br>MyWebApp.Client/Program.cs</p><pre>using MyWebApp.Client.Localizer;<br><br>// [...]<br><br>builder.Services<br>    // Register the client global localization.<br>    .AddTransient&lt;IClientGlobalStringLocalizer, ClientGlobalStringLocalizer&gt;();</pre><p>We also need to make sure that the localization resources are really loaded since the Json files are hosted on the server side as static asserts. This is especially true for the client components since the Json file is actually loaded through the HTTP connection.</p><p>In order to make sure this is loaded before it is used, we can update MyWebApp.Client/Program.cs like this:</p><pre>using SoloX.BlazorJsonLocalization;<br><br>// [...]<br><br>// Load localization resources asynchronously<br>// replacing :<br>//<br>//await builder.Build().RunAsync();<br>//<br>// with<br>//<br>var webAssemblyHost = builder.Build();<br><br>// Get the client localizer.<br>var localizer = webAssemblyHost.Services<br>  .GetRequiredService&lt;IClientGlobalStringLocalizer&gt;();<br><br>// Load resources.<br>await localizer.LoadAsync();<br><br>// And run the application.<br>await webAssemblyHost.RunAsync();</pre><blockquote>Note that we could have use the embedded configuration of the Json resources so that we wouldn’t need to care about asynchronous load of the resources.</blockquote><h4>Add default using statements</h4><p>Update the default imports files to include the Localizer namespace:</p><p>In MyWebApp/Components/_imports.razor file:</p><pre>@using MyWebApp.Localizer<br>@using MyWebApp.Client.Localizer</pre><p>And in MyWebApp.Client/_imports.razor file:</p><pre>@using MyWebApp.Client.Localizer</pre><h4>All is ready to be used</h4><p>Then we can update the Home page in the file<br>MyWebApp/Components/Pages/Home.razor</p><pre>@page &quot;/&quot;<br><br>@* Inject the server global localizer *@<br><br>@inject IServerGlobalStringLocalizer Localizer<br><br>@*<br> Then we can use the localizer properties to get the localized messages.<br> *@<br><br>&lt;PageTitle&gt;@Localizer.HomePageTitle&lt;/PageTitle&gt;<br><br>&lt;h1&gt;@Localizer.HelloTitle&lt;/h1&gt;<br><br>@Localizer.HelloBody</pre><p>And we can use it in the client-side WebAssembly components for example, in MyWebApp.Client/Pages/Counter.razor:</p><pre>@page &quot;/counter&quot;<br>@rendermode InteractiveWebAssembly<br><br>@* Inject the client global localizer *@<br><br>@inject IClientGlobalStringLocalizer Localizer<br><br>@*<br> Then we can use the localizer properties or methods to get the localized<br> messages.<br> *@<br><br>&lt;PageTitle&gt;@Localizer.CounterPageTitle&lt;/PageTitle&gt;<br><br>&lt;h1&gt;@Localizer.CounterTitle&lt;/h1&gt;<br><br>&lt;p role=&quot;status&quot;&gt;@Localizer.CurrentCount(currentCount)&lt;/p&gt;<br><br>&lt;button class=&quot;btn btn-primary&quot; @onclick=&quot;IncrementCount&quot;&gt;<br>@Localizer.ClickMe<br>&lt;/button&gt;<br><br>@code {<br>    private int currentCount = 0;<br><br>    private void IncrementCount()<br>    {<br>        currentCount++;<br>    }<br>}</pre><h3>Last word</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Xwc0mhT3eFl8aQFH" /><figcaption>Photo by <a href="https://unsplash.com/@markusspiske?utm_source=medium&amp;utm_medium=referral">Markus Spiske</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Localization is a critical aspect of web development, ensuring that your applications are accessible and user-friendly across different languages and regions. By adopting code-first JSON localization, you’ll take a significant step towards creating more efficient and maintainable multilingual applications.</p><p>Remember, the techniques discussed in this article are not limited to Blazor web apps; they can be applied to various .NET projects. Whether you’re a seasoned developer or just starting, mastering localization techniques can greatly enhance the quality and reach of your applications.</p><p>If you have any questions or feedback, don’t hesitate to reach out. And for those eager to dive deeper, you can find the example code sources in this <a href="https://github.com/xaviersolau/DevArticles/tree/code_first_json_localization">repository</a>, ready for exploration and experimentation.</p><p>Thank you for reading, and happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a1b18352dd67" width="1" height="1" alt=""><hr><p><a href="https://medium.com/younited-tech-blog/code-first-json-localization-on-blazor-web-app-a1b18352dd67">Code first Json localization on Blazor Web App</a> was originally published in <a href="https://medium.com/younited-tech-blog">YounitedTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GENAI-BOT-FRAMEWORK : our incoming free, open source, Entreprise-Ready GenAI solution]]></title>
            <link>https://medium.com/younited-tech-blog/genai-bot-framework-our-incoming-free-open-source-entreprise-ready-genai-solution-943b15399336?source=rss----b5e215f370b0---4</link>
            <guid isPermaLink="false">https://medium.com/p/943b15399336</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[gen-ai-tools]]></category>
            <category><![CDATA[genarative-ai]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[large-language-models]]></category>
            <dc:creator><![CDATA[Antoine habert]]></dc:creator>
            <pubDate>Thu, 04 Apr 2024 12:33:05 GMT</pubDate>
            <atom:updated>2024-04-04T12:33:05.343Z</atom:updated>
            <content:encoded><![CDATA[<h3>GENAI-BOT-FRAMEWORK : our incoming free, open source, Entreprise-Ready GenAI solution</h3><p>In our journey towards embracing generative AI at <a href="https://younited.com/">Younited</a>, we’ve recognized its transformative potential beyond conventional AI applications in real business scenarios exactly one year ago. This cutting-edge technology propels us forward in innovation, enhancing operational processes, accelerating our internal content generation, and ultimately opening new avenues in customer engagement.</p><p>The rapid evolution of generative AI technologies, coupled with our extensive testing and exploration, underscored the necessity for a specialized framework, leading to the initiation of what we call our GENAI-Bot-Framework. This endeavor stems from the insight that a bespoke framework would offer the required flexibility and complexity to support our vision. <a href="https://medium.com/@pilosite/genai-bot-framework-insights-from-younited-on-generative-ai-d53203b21b9f">[previous article here]</a></p><p>Today, I’m delighted to delve deeper into the foundational principles of this framework with you. We’ll first introduce the core technical principles of the GENAI-Bot-Framework, and then showcase through various use cases how its implementation is poised to revolutionize practices not only within our tech department but also across our entire organization — and potentially yours. By exploring the architecture and strategic integration of generative AI models, we aim to demonstrate the substantial impact of this framework on accelerating and transforming enterprise operational capabilities.</p><p>Additionally, we’ll discuss the next steps for the framework, including upcoming demonstrations and, most importantly, its public release on GitHub in early May.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iWJJX5nc4z5s24fzLBgI_Q.png" /></figure><h3>Context and Motivation</h3><p>The genesis of the GENAI-Bot-Framework was driven by more than just the recognition of gaps in existing AI solutions; it was inspired by a broader vision for the future of AI interactions. Our ambition was to transcend mere adaptation of current initiatives — often necessitating extensive internal re-engineering to fully cover our needs — to embrace a more sophisticated yet easy to implement approach. We envisioned a framework capable of orchestrating complex dialogues across multiple participants and varied media, while also facilitating seamless interactions between AI agents.</p><p>This vision aimed not only to surmount present limitations but also to establish a solid foundation for the impending wave of AI evolution.</p><p>The GENAI-Bot-Framework is conceived as a dynamic, ever-evolving platform, ready to integrate emerging technologies and methodologies. Anticipating the introduction of significant enhancements in the near future, we are committed to reinforcing our framework as a versatile, interactive, and accessible tool, thereby broadening the horizon for AI applications and making them available to a more extensive audience. Our goal is to not only keep pace with the rapid advancements in AI but also to lead in defining its practical application across real-world scenarios.</p><h3>Advantages and Originality</h3><p>Developed with a distinct vision, the GENAI-Bot-Framework is a testament to our commitment to providing a solution that is both flexible and adaptable, catering to a wide spectrum of application needs. The design philosophy of the framework is underscored by several key advantages:</p><ul><li><strong>Flexibility and Adaptability: </strong>Tailored for real-world use, the GENAI-Bot-Framework’s design is all about being flexible and user-friendly. It handles different AI models and multiple agents in one go, cutting down on the coding hassle. As an open-source tool, it’s ready for anyone to tweak and expand. It’s built for the real deal: practical AI scenarios where LLM-driven instructions lead the charge, with room to grow through additional actions and behaviors, which we’ll touch on with examples later.</li><li><strong>Integration with Various Platforms:</strong> A key feature of the GENAI-Bot-Framework is its ability to seamlessly integrate with a wide range of user interaction platforms. This includes not only instant messaging applications like Slack or Teams but also extends to ticketing systems, email platforms, direct API calls, and interactions with internal applications. This capability ensures effective management of complex dialogues and real-time interactions across various communication mediums that are fundamental to users’ workflows. By enhancing the framework’s applicability beyond traditional uses, we offer a versatile experience that adapts to the unique advantages of each interaction model.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2EKezxj8SaI-_-_F0hi4WA.png" /></figure><ul><li><strong>Multi-Agent and Multi-Party Conversation Management:</strong> Our framework shines when it comes to orchestrating multi-user interactions, especially in business messaging environments like Slack or Teams. By leveraging the natural multilingual capabilities of generative AI models, it effortlessly bridges language barriers, making global communication a breeze. The real magic, though, lies in its advanced handling of multi-party conversations. This ensures smooth and coherent exchanges among participants, turning a single bot into a powerhouse for collaborative scenarios. Such a setup is invaluable for a multitude of real-world applications, enhancing teamwork and efficiency across the board.</li><li><strong>Seamless Integration and Multi-Agent Collaboration: </strong>The real kicker with the GENAI-Bot-Framework isn’t just its flexibility — it’s how it turns your AI into a team player. Forget the solo acts; this framework is all about ensemble performances, enabling multiple AI agents to tackle problems together, and yes, they even chat among themselves to figure out the best solutions for your users. It’s not confined to just slotting into your existing setup, whether on-premise, cloud, or local — it’s about pushing boundaries and exploring how collaborative AI can revolutionize the way we work. With its straightforward plugin system, you’re not just adding features; you’re creating a network of AI collaborators ready to dive deep into complex scenarios. We hope this framework serves as a facilitator for individuals and enterprises alike, turning the concept of AI teamwork into a tangible reality.</li></ul><blockquote><em>The goal of the GENAI-Bot-Framework is to make generative AI “Enterprise Ready”, allowing for its seamless integration into companies’ information systems.</em></blockquote><h3>Core Principles and Architecture</h3><p>The GENAI-Bot-Framework is built on Python, utilizing standard libraries to ensure it seamlessly integrates with a company’s existing IT infrastructure. This foundation facilitates easy connections to an extensive range of systems, including cloud services, messaging platforms, servers, and databases. By prioritizing compatibility and ease of integration, the framework is designed to fit into your current setup without requiring significant changes. This approach minimizes the hurdles for businesses ready to embrace generative AI technologies, making the GENAI-Bot-Framework a practical and accessible choice for enhancing your operational capabilities.</p><h4>Framework Structure and Deployment</h4><p>At its core, the GENAI-Bot-Framework is a Python-based program, crafted with FastAPI for swift and reliable performance. It’s neatly packaged into a Docker image for a hassle-free deployment across various hosting environments. This flexible structure is designed to fit snugly into your preferred tech stack, whether it be on a local server or in the cloud.</p><p>Configuration and data management is a breeze, thanks to a user-friendly YAML file that sets the stage for the framework’s operation. All necessary operational data — from logs to prompts, sub-prompts, and conversation histories — are meticulously managed and can be stored according to your needs. Whether you choose to keep it close to the vest with local server storage or spread out in the cloud, the GENAI-Bot-Framework adapts to your storage strategies, ensuring your data is right where you need it.</p><p>As we delve deeper into the system’s functionality, we’ll explore how these elements — the configuration file, data storage, and the framework’s inherent adaptability — work in concert to create a robust and flexible AI interaction platform.</p><p><strong>Plugin System</strong></p><p>The decision to employ a plugin-based architecture is foundational to the framework’s design, providing a structured method for extending its functionality. This approach facilitates the straightforward addition of new features or integration with other systems and software through the development or incorporation of plugins. It grants businesses the flexibility to customize and scale their AI solutions as their needs evolve.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/816/1*02M1tH19SQE8WB1vnnZA4w.png" /></figure><ol><li><strong>User Interactions:</strong> This suite caters to diverse communication channels, enabling the framework to handle everything from instant messages to emails, ticketing systems, and beyond.</li><li><strong>User Interaction Behaviors:</strong> Interaction customization is key. This set of plugins allows the behavior of AI models to be fine-tuned according to the context and medium of interaction, enhancing user experience and engagement.</li><li><strong>GenAI Interactions: </strong>At the heart of the system lies the capacity to manage classic LLM functionalities, configured for an array of services including chat, image generation, audio processing, and innovative future capabilities.</li><li><strong>Custom Actions: </strong>The framework’s extensibility is showcased here, where actions can be crafted to query databases, search the web, analyze logs, and more, directly interacting with the enterprise’s systems.</li></ol><p>The GENAI-Bot-Framework’s dispatcher model elevates these plugins by enabling seamless communication between different LLMs and across various communication channels with minimal coding effort. This not only optimizes user experience but also ensures that the framework remains adaptable and robust for any ‘real world’ AI application scenarios within the enterprise.</p><p><strong>Dynamic Prompt System</strong></p><p>The GENAI-Bot-Framework introduces an advanced dynamic prompt system designed to navigate complex interaction workflows with precision and adaptability. Here’s how it’s structured:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/659/1*A4WfxvpQypNQRzjfBWGflA.png" /></figure><ul><li><strong>Core Prompt:</strong> The backbone of our framework, the Core Prompt, sets the operational parameters for our AI bots. It requires responses in a structured format, like YAML or JSON, which streamlines interaction handling, regardless of the LLM used. This systematization ensures that every interaction is coupled with an action, for instance, turning a simple request into a specific task like triggering a connected coffee machine.</li><li><strong>Main Prompt: </strong>This is the instructional core that contextualizes the bot’s purpose (e.g., you are an AI specializing in technical support). It describes the workflow and can invoke actions defined in the code by name, tailoring the bot’s behavior to each interaction.</li><li><strong>Sub Prompts: </strong>Based on our experience, we’ve seen the need for bots to handle multiple use cases. Sub Prompts allow for contextually relevant instructions without overburdening the main prompt with costly unused commands. This mechanism enables bots to trigger specific sub-instructions as needed, optimizing token load and dedicating certain tasks to specialized LLMs, all while enabling rich interactions.</li></ul><h4>Core Prompt System Details</h4><p>Our Core Prompt ensures that responses are structured to be easily decoded by the framework. A standard action named “Observation” is generated, providing four key insights:</p><ul><li><strong>Observation: </strong>What the model understands from the user input.</li><li><strong>Thought: </strong>The model’s proposed reaction to the input.</li><li><strong>Plan: </strong>The anticipated sequence of actions.</li><li><strong>Next Step:</strong> The model’s prediction for subsequent interactions.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/517/1*rGiJbpOn3lPkH5_UIYEbBA.png" /></figure><p>This methodology offers two benefits:</p><ol><li>It allows for a <strong>deeper understanding of the bot’s functioning</strong>, facilitating troubleshooting and fine-tuning of prompts. Typically, in instant messaging usage, these messages are broadcasted to a dedicated “mind” channel for administrators to review the bot’s behavior.</li><li>It <strong>structures the LLM’s responses within a predictable framework</strong>, significantly enhancing the bot’s reliability. Our experience shows that following this model leads to a more consistent adherence to instructions, all while maintaining the bot’s unique personality.</li></ol><p>This dynamic prompt system underscores the GENAI-Bot-Framework’s commitment to creating an environment where AI can thrive, delivering predictable, efficient, and rich user interactions.</p><p><strong>The feedback loop</strong></p><p>The framework’s feedback system is integral to its learning and development capabilities. It categorizes user responses and feedback, using them to refine the AI’s understanding and enhance future interactions. This continuous loop of feedback and improvement is crucial for maintaining the bot’s effectiveness and relevance.</p><p>Additionally, the semi-assisted human evaluation mechanism introduces a collaborative element between AI and human oversight. It employs an LLM agent, under human supervision, to review and augment the feedback received. This not only ensures the quality of the feedback but also aids in the nuanced understanding of complex interactions, allowing for a harmonious blend of automated learning and human expertise.</p><p>Together, this robust system of dynamic prompts and feedback ensures that the GENAI-Bot-Framework can manage and optimize complex dialogues and tasks, evolving over time to better meet user needs and expectations.</p><p><strong>Multi-Agent System and Inter-Model Interactions</strong></p><p>The GENAI-Bot-Framework is designed to facilitate sophisticated multi-agent interactions within a single workflow. It allows for the invocation of different LLMs, either through direct instructions or by enabling the LLMs themselves to make autonomous decisions about which model to engage for a particular task. This capability significantly broadens the scope of potential interactions by allowing one agent to retrieve information from another, either transparently or visibly within the user interaction. This feature paves the way for creating more intricate and innovative workflows without the need for extensive coding, as agents can collaborate, share knowledge, and offer a more cohesive experience.</p><h3>Use Cases and Practical Examples</h3><p>Our foray into applying the GENAI-Bot-Framework started with Slack, primarily because it ticked several boxes for us. It was already a staple in our tech team’s communication, supporting multi-user discussions and serving as a hub for numerous notifications — from alerts and incidents to support requests. This initial focus helped us explore the framework’s broad capabilities in a familiar setting, revealing its versatile nature through:</p><ul><li>Enabling multilingual interactions, critical for our global team’s connectivity.</li><li>Streamlining the management of both Slack and Teams threads to maintain focus in conversations.</li><li>Handling diverse content types, like images, text, and structured PDFs, facilitating a wide range of communication needs.</li><li>Activating image generation with plugins such as Dall-e or Stable Diffusion, enhancing creative content creation.</li><li>Identifying multiple participants in a conversation, crucial for dynamic discussions.</li><li>Reading web and recursive Slack links with appropriate permissions, integrating web content smoothly into dialogues.</li><li>Generating detailed text files, breaking through the usual output constraints of LLMs for more extensive documentation.</li></ul><p>A standout feature of the framework is its ability to produce long texts, overcoming traditional LLM limitations. This advancement, which we’ll further illustrate in our forthcoming demo videos, exemplifies the framework’s capacity for innovation in content generation.</p><p>The integration of the GENAI-Bot-Framework into our operational ecosystem, starting with Slack, showcased not just a technical alignment with our existing tools but also opened the door to enhanced operational processes and direct customer engagement. Its design, geared towards consistency across platforms through a plugin architecture, ensures a smooth user experience, whether within Slack, Teams, or any future system we adopt.</p><p>As we delve deeper into the framework’s potential, we’re keen to share how its application could similarly transform operational practices and customer interaction within your organization, bringing a new level of efficiency and collaboration to the forefront.</p><p>With these capabilities, the GENAI-Bot-Framework has been instrumental in a variety of innovative use cases at Younited. Let’s have a look at 3 of the dozens of bots experiments currently ungoing at Younited</p><h3>Usecases</h3><h4>Meeting Summaries Example, Enhanced</h4><p>Our use of the GENAI-Bot-Framework goes beyond converting meeting transcripts into digestible formats; it allows for the creation of customized summaries tailored to the nature of each meeting. From succinct daily stand-up recaps focusing on objectives, attendees, and actions, to more detailed accounts of lengthy discussions or presentations, the framework’s versatility shines. Each summary type is designed with specific expectations in mind, ensuring that the information provided is most relevant to the meeting’s format.</p><p>What sets this system apart is its ability to easily configure and deploy multiple summary variants within the same bot. Whether you need a quick overview for a routine check-in or an in-depth breakdown of a strategic planning session, setting up the appropriate summary style is straightforward. This capability means that tailored summaries can be rapidly made available, either company-wide or to specific teams, in just a few seconds.</p><p>Leveraging LLMs, particularly GPT-4 Turbo, enables this nuanced content generation, demonstrating a key advantage of these technologies: their flexibility in adapting output to suit different mediums and contexts. This adaptability is crucial for generating dual outputs that cater to quick Slack references and detailed Azure DevOps wiki documentation, thus streamlining our internal documentation process while showcasing the potential of LLMs for enhancing organizational communication and knowledge management.</p><p>To illustrate here’s an anonimyzed sample meeting summary based on one of our heavily edited transcript for privacy reason :-) :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/528/1*c3GIbwR3jWmmVhLGD3I9lA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/660/1*nTo5ehiy2E84XXKb841BjA.png" /></figure><p><strong>Incident Management</strong></p><p>Our incident management bot operates within a dedicated rapid response channel, handling a variety of messages ranging from automatic alert notifications and maintenance updates to inquiries about suspected or past issues — even the occasional misplaced message. This versatility is powered by the GENAI-Bot-Framework, enabling distinct workflows for each category of communication. For instance, upon receiving an automatic alert, the bot can initiate advanced pre-diagnostic checks on our infrastructure and logs, showcasing its proactive approach to incident management.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/1*oQIfscKAp81yFWE01bXZMA.png" /></figure><p>The framework’s adaptability extends to learning from experience. Utilizing the feedback system, we can guide the bot towards more effective responses for future alerts. This continuous improvement cycle is facilitated through interactions with feedback, allowing the bot to adjust its approach based on past actions and suggestions.</p><blockquote>Beyond automatic adjustments, feedback management involves a unique channel, #the-construct, reminiscent of Matrix. Here, bots interact with Morphe-yuc, a specialized feedback analysis bot. Morphe-yuc reviews feedback, user interactions, and the requesting bot’s main prompt to make informed decisions: validating feedback, discarding it, suggesting integration into a subprompt or main prompt, or even escalating to our GenAI team for human review when necessary.</blockquote><blockquote>unrelated screenshot of an early mocked POC below :-)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*rStn69A4WBcJbUeDJo5kLg.png" /></figure><p>During incidents, the bot is instrumental in generating ‘incident scorecards’, offering real-time insights into the situation, progress, and actions taken.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/644/1*OPUgI-wW51Xb6iXnXFm77Q.png" /></figure><p>Following an incident, it meticulously prepares post-mortem templates, sets up dedicated Slack channels for discussions, and assembles crucial elements like timelines and participant actions. This comprehensive approach significantly supports our technical and Site Reliability Engineering (SRE) teams, streamlining both immediate response and reflective analysis.</p><p>Through these capabilities, the incident management bot exemplifies the GENAI-Bot-Framework’s potential to not just react to but also anticipate and learn from incidents, enhancing our operational resilience and efficiency.</p><h4>Support Bot: A Case Study in Practical Innovation</h4><p>One of the shining examples of the GENAI-Bot-Framework in action is our support bot, developed with the invaluable contributions of <a href="https://medium.com/u/fe10b1dbab08">Nicolas Bari</a>, a Tech Support and Devops engineer from Younited’s Tech Ops Team and a pioneering early adopter of the framework. Nicolas has invested significant energy into harnessing the framework, devising Level 1 support use cases that truly demonstrate its potential.</p><p>Under Nicolas’s guidance, the support bot has evolved to not just read existing procedures but also incorporate a host of useful and reusable features:</p><ul><li>Querying our HR tools to identify a person’s manager for approval if needed.</li><li>Creating, updating, and advancing the status of Jira tickets in sync with Slack requests.</li><li>Triggering actions in our task automation tool to fulfill user requests directly.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/653/1*RUhtN4KuK46oWII4iaNPzg.png" /></figure><p>This bot doesn’t only streamline Level 1 support tasks; it’s a testament to the GENAI-Bot-Framework’s adaptability and Nicolas’s ingenuity. It categorizes user requests, probes with the right questions, and seamlessly manages Jira tickets and internal databases, all while ensuring issues are resolved efficiently.</p><p>Furthermore, Nicolas’s work with the support bot opens up discussions for a future article on the “jailbreak challenge” we conducted. This experiment was designed to test the limits of integrating LLMs not just internally but potentially in customer-facing roles, highlighting both the feasibility and challenges of bringing cutting-edge AI to the forefront of user interaction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/867/1*B9hmtp1Sc8GPbNHOS3SeTg.png" /><figcaption>JIRA ticket status changed by the LLM when an user try to impersonate another user</figcaption></figure><p>These practical implementations underscore the framework’s capacity to refine complex workflows, bolster communication efficiency, and deliver significant time savings and ROI. The framework’s robust architecture, complemented by its dynamic and versatile interaction model, positions it as a crucial tool in the modern IT landscape, paving the way for future innovations in support and beyond.</p><h3>Conclusion and Future Outlook</h3><p>Our exploration of the GENAI-Bot-Framework has unfolded a system designed to enrich the generative AI ecosystem, underscoring its flexibility, adaptability, and technical excellence. This journey underscores its essential role for both businesses and developers. And this is a really fun tool to work with :-)</p><h4>Summary of Key Points</h4><ul><li><strong>Framework Architecture: </strong>With its foundation in Python 3.11.X and FastAPI, the framework stands out for its asynchronous operations and scalability, simplifying development and integration.</li><li><strong>Dynamic Prompt System: </strong>Its advanced multi-layered approach streamlines complex workflows, allowing for detailed interactions through Core, Main, and Sub Prompts.</li><li><strong>Plugin System:</strong> Demonstrating remarkable extensibility, the framework’s plugin architecture facilitates tailored enhancements without compromising the core system.</li><li><strong>Multi-Agent Capabilities:</strong> It enables advanced interactions by supporting multiple AI agents, fostering a collaborative and intelligent environment.</li><li><strong>Practical Applications: </strong>Proven use cases at Younited, from meeting summaries to incident management and support automation, highlight its operational impact.</li></ul><h4>Looking Forward</h4><p>The GENAI-Bot-Framework is set for ongoing growth, with an open-source release poised to drive innovation through community contributions. Anticipated enhancements include integrating more sophisticated AI models, expanding cloud platform integrations, and refining user interactions with advances in natural language processing.</p><h4>What’s Next?</h4><ul><li><strong>Demo Video:</strong> A detailed demonstration video is on the horizon, showcasing practical applications and key features of the framework.</li><li><strong>GitHub Release:</strong> Scheduled for <strong>early May</strong>, this milestone will be officially announced, <strong>making the framework accessible to a wider audience.</strong></li><li><strong>Live Q&amp;A Session:</strong> An upcoming live session will provide insights into the framework’s practical application, offering an opportunity for community engagement and support.</li></ul><p>In conclusion, the GENAI-Bot-Framework represents more than just a solution for today’s needs — it’s a foundation for future innovation, reflecting our commitment to enhancing how we interact with AI technologies. Stay tuned for these exciting developments as we continue to advance the boundaries of AI integration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qJmj1eHkPbriSPOPvAuDTg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=943b15399336" width="1" height="1" alt=""><hr><p><a href="https://medium.com/younited-tech-blog/genai-bot-framework-our-incoming-free-open-source-entreprise-ready-genai-solution-943b15399336">GENAI-BOT-FRAMEWORK : our incoming free, open source, Entreprise-Ready GenAI solution</a> was originally published in <a href="https://medium.com/younited-tech-blog">YounitedTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Benefits of TDD and Peer Programming]]></title>
            <link>https://medium.com/younited-tech-blog/benefits-of-tdd-and-peer-programming-ca471b435621?source=rss----b5e215f370b0---4</link>
            <guid isPermaLink="false">https://medium.com/p/ca471b435621</guid>
            <category><![CDATA[peer-programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[quality]]></category>
            <category><![CDATA[tdd]]></category>
            <dc:creator><![CDATA[Damien Hanoun]]></dc:creator>
            <pubDate>Fri, 22 Mar 2024 18:54:27 GMT</pubDate>
            <atom:updated>2025-08-25T12:20:00.800Z</atom:updated>
            <content:encoded><![CDATA[<h3>TDD and Peer Programming Benefits</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/888/1*xiexZXnkP4YCTAQeTngyGQ.png" /></figure><p>Some months ago, I took the lead in interviewing new talented developers for my team. I wanted to accept only developers with a foundation for producing quality software (clean code, TDD, peer programming, …) or those interested in doing so.</p><p>I have encountered candidates who did not initially understand the benefits of such techniques. After the interview, some of them told us they understood how these techniques could help them do better work for the first time.</p><p>Since my arguments helped them to understand the benefits of these techniques, this article is a good opportunity to share my vision of them.</p><h3>TDD benefits</h3><p>Developers often reduce TDD to writing unit tests first and the red-green-refactor approach. And that’s pretty much it, which is somewhat reductive.</p><p>I would feel more comfortable using Specification-Driven Design or Intent-Driven Design to demonstrate what matters, but it may be a little pretentious.</p><p>Here are the points I will use to talk about it:</p><ul><li>The to-do list: Seeing what you achieve and what is left is a powerful tool to stay motivated. It also encourages thinking step by step without knowing everything from the start. The list will generally evolve according to new problems during implementation. Kent Beck&#39;s <a href="https://www.amazon.fr/Test-Driven-Development-Kent-Beck/dp/0321146530/ref=asc_df_0321146530/?tag=googshopfr-21&amp;linkCode=df0&amp;hvadid=228957151636&amp;hvpos=&amp;hvnetw=g&amp;hvrand=1047245681324540612&amp;hvpone=&amp;hvptwo=&amp;hvqmt=&amp;hvdev=c&amp;hvdvcmdl=&amp;hvlocint=&amp;hvlocphy=9056537&amp;hvtargid=pla-448095042394&amp;psc=1&amp;mcid=0da42118c881376297e13e5e40dd01df">Test-Driven Development</a> book represents it well. On my side, I keep only the following steps as a to-do list, and the previous steps are visible from my commits.</li><li>Contract first: There is a greater chance you would care about your class contract if the first thing you see and update is what you see from outside. When seeing the internal code of a method, it will make us tend to adapt the contract according to changes done inside, which has a greater chance of leading to poor design decisions and tests being more complex to maintain and understand.</li><li>More small tests for quicker feedback: Working incrementally with small intents allows us to have feedback sooner than waiting to finish an implementation before testing. If your test fails, whereas you expect it to pass, you lose only seconds or minutes to diagnose what’s wrong. I often face tests done after the implementation, which causes me to lose precious time refactoring tests and implementation and correcting logic errors that could have been done.</li><li>Double-check: In the finance world, there is a <a href="https://www.genio.ac/glossary/double-check-or-double-check/">double-check</a> system to prevent errors. Here, it is the same. Moreover, if I work alone, having the test and the implementation work the same way is reassuring.</li><li>Remove coverage percentage goals: Coverage is not an argument of quality. Quality will come from how you design your tests (structure and data), how much they help you detect unexpected change daily, and at what velocity.</li><li>Commit quality: When facing a pull request linked to a subject I don’t know, I look at commits to understand the developer&#39;s reasoning and give better feedback. As for me, you probably face commits like this: «Implementation», «Add unit test», «Correct errors», … These are not very helpful to follow the story of what has been done. TDD will help to commit by intent, resulting in a commit name that would look more like this: «Add trade-in option for the prospect in point of sales».</li><li>Handle each day with more confidence: It already happens to me to start working on a subject at 18h. Keeping my intents small, I had the time to do two commits and stop working at 18h30. Also, facing a vast subject that implies mental overload allows me to reduce it by evolving the solution step by step until I see a final solution I may not have seen from the start.</li><li>It is not only about unit tests: I will often start to define what I want with an end-to-end test or integration test, and make it fail first. Then, I will do a second level of TDD with unit tests. To validate integration between my pieces of code, I will sometimes relaunch end-to-end/integration tests to have feedback about my implementation (like checking that dependency injection works with my new classes) to finally come back at the end and check if my first test does what I expect.</li><li>Prevent over-engineering: By treating problems individually, we avoid overthinking the final solution and allow it to evolve only according to the issues we face.</li><li>Continuous simplification: Small, continuous refactorings make it easier for the system to grow smoothly over time.</li></ul><p>Even if it is a little off-topic, if you have executable acceptance specifications that execute fast enough to be used in your development workflow, you should consider reducing the number of unit tests to cases with risk.</p><p>Anyway, TDD is a tool that could help you make the right decisions, but remember that it does not make design decisions for you.</p><h3>Peer programming benefits</h3><p>When I talk about peer programming to developers, they often think it is just about having two developers behind a computer who work together on the same subject. And that’s pretty much it. Again, this vision is somewhat reductive.</p><p>Here are the points I will use to talk about it:</p><ul><li>Peers have different roles: The one with the keyboard is the session conductor in charge of updating the code, whereas the other is the observer who gives the orientation. This idea of not overlapping responsibilities mainly reduces friction and improves the workflow.</li><li>Peers often change their roles: You must change roles based on a timer or at each commit on a small amount of time basis.</li><li>Feedback, sharing, and learning: Coding with colleagues is an excellent knowledge-sharing strategy. You will share what you know by design, get a lot more feedback of better quality on a lot more aspects (like the habit you have in your IDE, the way you treat a problem, or the tools you like to use) than what you could get with pull requests, and learn a lot more quickly. It could reduce the need for presentations or documentation.</li><li>Continuous non-blocking code review: If you embrace the continuous integration philosophy, you certainly look to make ideas go faster to production without leaving quality aside. If everyone works with everyone in a team, methodologies, tools, and techniques that work best will be used by all team members and will increase trust. If you trust your colleagues, you could start thinking about removing the pull request system (which is a blocking system). On this point, I am strongly influenced by Dave Farley’s videos (like <a href="https://www.youtube.com/watch?v=WmVe1QrWxYU">I’ve Found Something BETTER Than Pull Requests…</a>), whom I could consider as my mentor. As he mentions, the idea of slowing down for safety is a mistake; we don’t improve quality by adding more bureaucracy to the process. Not to mention the time I spent explaining why I made some decisions in pull request comments before sharing it with the team.</li><li>Team capacity stabilisation: If you need to forecast (using <a href="https://www.amazon.fr/NoEstimates-Measure-Project-Progress-Estimating-ebook/dp/B01FWMSBBK">NoEstimates</a>, for example), one of your goals is to make your team predictive to reduce the forecast range. One way to achieve that is peer programming to improve knowledge-sharing and resilience to arrival, holidays, departure, or sick leave.</li><li>Improvement of quality: Two heads are better than one. Even if it ends with a slight improvement, we all know how small details can impact production or team productivity in the long run. I often hear the argument that it costs twice as much as a developer working alone, but we are comparing the quickness of delivery and quality. If, like me, you consider that quality is more critical and valuable for quickness in the long term, quickness at day level is irrelevant.</li><li>Shared energy expenditure and solving problems faster: Working with someone else will help you stay focused, especially if you are tired or the subject requires knowledge and energy. Mob programming could be a better strategy if it is a dangerous update. Listening and talking are other points that change our experience and could help us to envision our subject better and faster.</li><li>Peer as protector: If you work in your company’s building, the chances are high that someone will come to ask you something. Using your peer as protection against distractions can be helpful.</li></ul><p>When I think about it, the only concrete example I have of a team that constantly uses peer programming was at Expedia. It was six years ago during <a href="https://www.linkedin.com/posts/damien-hanoun-a492b072_soir%C3%A9e-meetup-sur-quelques-notions-agile-activity-6408063901711241216-Y0no?utm_source=share&amp;utm_medium=member_desktop">a meetup</a> where Julien Topçu and his team talked about how they handle projects using MVP, DDD, and agile methodologies like NoEstimates, eXtreme Programming, and Kanban—a fascinating way to organize.</p><h3>Conclusion</h3><p>If both allow quicker feedback and quality improvement, both also require practice to master and, in an ideal world, work with experienced people on these techniques. I never had this chance, which makes me think I still have much to learn.</p><p>I practice TDD every day and rarely face cases where using it would not make sense. I tend not to use it for test code helpers or proof of concept. I know the TCR (Test Commit Rollback) methodology will tend to be the successor of TDD, but I don’t feel comfortable using it yet.</p><p>For peer programming, I can’t use it as often as I want, and I have only used it a few times, but I have had some incredible experiences with it, even though I know I could be doing better. For the future, I am waiting for the <a href="https://www.jetbrains.com/help/idea/code-with-me.html">«Code with Me» tool of JetBrains</a> for Rider to experiment with doing peer programming with both developers coding simultaneously. I feel there is something to do with it.</p><p>Combining them feels very powerful, but I stay alert when using tools, techniques, or processes to prevent the “everyone does it” or “it is a good practice” effect. These arguments are invalid and prevent us from considering why we use them. If they don’t fit our context and we have strong arguments, we should not use them.</p><p>Think for yourself, experiment, seek to work with talented people, and keep what will make your life better.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ca471b435621" width="1" height="1" alt=""><hr><p><a href="https://medium.com/younited-tech-blog/benefits-of-tdd-and-peer-programming-ca471b435621">Benefits of TDD and Peer Programming</a> was originally published in <a href="https://medium.com/younited-tech-blog">YounitedTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can’t load embedded resources with culture name suffix in .Net Core.]]></title>
            <link>https://medium.com/younited-tech-blog/cant-load-embedded-resources-with-culture-name-suffix-in-net-core-21f279b9327b?source=rss----b5e215f370b0---4</link>
            <guid isPermaLink="false">https://medium.com/p/21f279b9327b</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[localization]]></category>
            <category><![CDATA[json]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Xavier Solau]]></dc:creator>
            <pubDate>Tue, 24 Oct 2023 09:37:50 GMT</pubDate>
            <atom:updated>2023-10-24T09:37:50.266Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KB02timx0b2aby1H" /><figcaption>Photo by <a href="https://unsplash.com/@kydroon?utm_source=medium&amp;utm_medium=referral">Kurt Cotoaga</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Can’t load embedded resources with culture name suffix in .Net Core.</h3><p>Have you ever used embedded resources in your .Net Core application? Sure, this is quite convenient and it is not really complicated to load! But did you try to name your embedded resources with a culture name suffix like <strong>MyResourceFile.fr-FR.json</strong> ? Did you encounter some difficulties? Well, it’s possible because loading it is not that straightforward!</p><p>In this article I will explain how to do it! Spoiler alert, I am going to talk about satellite assembly!</p><h4>What’s Embedded resources?</h4><p>Basically, embedded resources are resources inserted in the assembly itself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0tfXZuoHb_blcQRA" /><figcaption>Photo by <a href="https://unsplash.com/@marekokon?utm_source=medium&amp;utm_medium=referral">Marek Okon</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Let’s take an example with a localization sample. We are going to write a program to load translated messages from a Json file matching a specified culture name parameter. All messages are identified with a message key and stored in the Json files as key-value.</p><p>For this article we will use a console project that you can create with the command:</p><pre>dotnet new console -n MyEmbeddedLoadingProject</pre><p>Basically the program will load the localization resources and display all key-value pairs on the console.</p><p>Once the project is created, you can use your favorite text editor to create a new Json file to store the translation messages and you can save it as <strong>global.json</strong> in the project folder (In our example <strong>MyEmbeddedLoadingProject<em>)</em></strong>.</p><p>Let’s say the file will look like this:</p><pre>{<br>  &quot;HelloKey&quot;: &quot;Hello world!&quot;<br>}</pre><p>Then we can define it as an embedded resource in the project file like this:</p><pre>&lt;ItemGroup&gt;<br>    &lt;None Remove=&quot;global.json&quot; /&gt;<br>&lt;/ItemGroup&gt;<br>&lt;ItemGroup&gt;<br>  &lt;EmbeddedResource Include=&quot;global.json&quot; /&gt;<br>&lt;/ItemGroup&gt;</pre><p>That’s all, when you build your project, an assembly containing the resource file is generated.</p><blockquote>Note that internally the resources are stored in the assembly with a name prefixed by the assembly name. In our example, the embedded resource name is actually <strong>MyEmbeddedLoadingProject.global.json</strong>.</blockquote><h4>How to load it?</h4><p>Well the file is now embedded but how can we load and use the resource file? This is what we are going to see.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*A31Xi0T3qYdgYxdq" /><figcaption>Photo by <a href="https://unsplash.com/@rhysatwork?utm_source=medium&amp;utm_medium=referral">Rhys Moult</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>First we will add a Nuget that will help to load the embedded files:<br><strong>Microsoft.Extensions.FileProviders.Embedded<em><br></em></strong>You can go into the project folder and use the command:</p><pre>dotnet add package Microsoft.Extensions.FileProviders.Embedded</pre><blockquote>Note that you could simply use the <strong>Assembly GetManifestResourceStream</strong> methods to load embedded resources but this <strong>Nuget </strong>brings the <strong>IFileProvider </strong>abstraction that can be very convenient. In addition the <strong>EmbeddedFileProvider</strong> provides some uniformization about the way the embedded resources are named internally.</blockquote><p>In the project, we are going to add a class <strong>Loader</strong> with a method <strong>LoadAndDisplay </strong>that will load an embedded resource file within a given assembly.</p><pre>using System.Reflection;<br><br>namespace MyEmbeddedLoadingProject<br>{<br>    public class Loader<br>    {<br>        private readonly Assembly assembly;<br><br>        /// &lt;summary&gt;<br>        /// Setup Loader with the given assembly.<br>        /// &lt;/summary&gt;<br>        /// &lt;param name=&quot;assembly&quot;&gt;&lt;/param&gt;<br>        public Loader(Assembly assembly)<br>        {<br>            this.assembly = assembly;<br>        }<br><br>        /// &lt;summary&gt;<br>        /// Load and display all values from the given localization<br>        /// embedded file.<br>        /// &lt;/summary&gt;<br>        /// &lt;returns&gt;The asynchronous task result.&lt;/returns&gt;<br>        public Task LoadAndDisplay(string fileName)<br>        {<br>            // TODO<br>            return Task.CompletedTask;<br>        }<br>    }<br>}</pre><p>To implement the method, we can create an <strong>EmbeddedFileProvider </strong>instance with the assembly as constructor parameter and get the <strong>IFileInfo</strong> from it. Once this is done we can call a method <strong>LoadAndDisplayFromFileInfo</strong> to actually load the file and to write the entries onto the console.</p><pre>/// &lt;summary&gt;<br>/// Load and display all values from the given localization embedded file.<br>/// &lt;/summary&gt;<br>/// &lt;returns&gt;The asynchronous task result.&lt;/returns&gt;<br>public Task LoadAndDisplay(string fileName)<br>{<br>    // Get the EmbeddedFileProvider instance with the assembly.<br>    var fileProvider = new EmbeddedFileProvider(this.assembly);<br><br>    // Get the file info matching the given fileName argument.<br>    var globalFileInfo = fileProvider.GetFileInfo(fileName);<br><br>    // Then we can just call the method that take the fileInfo.<br>    return LoadAndDisplayFromFileInfo(globalFileInfo);<br>}</pre><p>The method <strong>LoadAndDisplayFromFileInfo</strong> is just going to check if the file exists and load it as if it was a basic file.</p><pre>private async Task LoadAndDisplayFromFileInfo(IFileInfo fileInfo)<br>{<br>    // Check that the file exists<br>    if (!fileInfo.Exists)<br>    {<br>        Console.WriteLine($&quot;Embedded resource &#39;{fileInfo.Name}&#39; doesn&#39;t exist.&quot;);<br>        return;<br>    }<br><br>    Console.WriteLine($&quot;Loading embedded resource &#39;{fileInfo.Name}&#39;.&quot;);<br><br>    // Get the file content stream.<br>    using var fileStream = fileInfo.CreateReadStream();<br><br>    // Load the Json data.<br>    var entries = await JsonSerializer<br>      .DeserializeAsync&lt;Dictionary&lt;string, string&gt;&gt;(fileStream);<br><br>    // Display all localization entries.<br>    foreach (var entry in entries)<br>    {<br>        Console.WriteLine($&quot;Localization entry &#39;{entry.Key}&#39; is &#39;{entry.Value}&#39;.&quot;);<br>    }<br>}</pre><p>Then we can use it in the <strong>Program.cs</strong> file to load the <strong>global.json</strong> file.</p><pre>var loader = new Loader(typeof(Program).Assembly);<br>// Load &amp; display the global file.<br>await loader.LoadAndDisplay(&quot;global.json&quot;);</pre><p>Now if you run the program you will see that the embedded <strong>global.json</strong> file is properly loaded and displayed on the console.</p><pre>Loading embedded resource &#39;global.json&#39;.<br>Localization entry &#39;HelloKey&#39; is &#39;Hello world!&#39;.</pre><h4>How about a culture name suffix?</h4><p>Now we are going to add a <strong>global.<em>CultureName</em>.json</strong> file for each supported culture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LIVEA-Y_k7_Nwwe-RvxSzw.jpeg" /></figure><p>Let’s say that we want to add the French culture so we add the <strong>global.fr-FR.json</strong> file that will look like this:</p><pre>{<br>  &quot;HelloKey&quot;: &quot;Bonjour à tous!&quot;<br>}</pre><p>We also need to update the project file to add the new embedded resource:</p><pre>&lt;ItemGroup&gt;<br>  &lt;None Remove=&quot;global.json&quot; /&gt;<br>  &lt;None Remove=&quot;global.fr-FR.json&quot; /&gt;<br>&lt;/ItemGroup&gt;<br>&lt;ItemGroup&gt;<br>  &lt;EmbeddedResource Include=&quot;global.json&quot; /&gt;<br>  &lt;EmbeddedResource Include=&quot;global.fr-FR.json&quot;&gt;<br>    &lt;DependentUpon&gt;global.json&lt;/DependentUpon&gt;<br>  &lt;/EmbeddedResource&gt;<br>&lt;/ItemGroup&gt;</pre><blockquote>Note that the <strong>DependentUpon</strong> element is optional, it is just here to tell that the French file is linked to a ‘root’ file. It allows the solution explorer to display de files as a tree.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/260/1*qiI_ErLcMNYR-n5o1waEFw.png" /><figcaption><strong>Global.json</strong> file is displayed as the root of all culture specific files.</figcaption></figure><p>Then we can update the <strong>Program.cs</strong> file to load the French <strong>global.fr-FR.json</strong> file.</p><pre>var loader = new Loader(typeof(Program).Assembly);<br>// Load &amp; display the global file.<br>await loader.LoadAndDisplay(&quot;global.json&quot;);<br><br>// Load &amp; display the French file.<br>await loader.LoadAndDisplay(&quot;global.fr-FR.json&quot;);</pre><p>Now if you run the program you will see that the French file is not found.</p><pre>Loading embedded resource &#39;global.json&#39;.<br>Localization entry &#39;HelloKey&#39; is &#39;Hello world!&#39;.<br><br>Embedded resource &#39;global.fr-FR.json&#39; doesn&#39;t exist.</pre><p>Well it didn’t work as expected… Next we are going to see how we can deal with it!</p><h4>Is the resource in a satellite assembly?</h4><p>Basically the raison why our program can’t find the file in the assembly is because it is not in the assembly. It is in fact in a satellite assembly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dUovdgJr69YL5e6iTY-K6A.jpeg" /></figure><p>If we have a look in the binary output folder we can see that there is a new folder named with the culture name <strong>fr-FR</strong> in addition of the usual generated assemblies. Inside the folder we can see that a resources assembly is also generated. This is a satellite assembly that is here to prevent the .Net Core runtime to load all culture specific data if it doesn’t need it.</p><p>In our example it is named like this: <strong>MyEmbeddedLoadingProject.resources.dll</strong>.</p><p>Now we are going to adapt our code to work with those satellite assemblies. In short, the Assembly class provides a method <strong>GetSatelliteAssembly</strong> to load the given culture specific resources.</p><p>We try to get the culture name from the file if any. Depending if we got a culture name we load the satellite assembly in order to use it in the <strong>EmbeddedFileProvider</strong>.</p><pre>/// &lt;summary&gt;<br>/// Load and display all values from the given localization embedded file.<br>/// &lt;/summary&gt;<br>/// &lt;returns&gt;The asynchronous task result.&lt;/returns&gt;<br>public Task LoadAndDisplay(string fileName)<br>{<br>    // Try to get the cultureInfo from the file name to know witch<br>    // satellite assembly needs to be loaded.<br>    var cultureInfo = TryGetCultureInfo(fileName);<br><br>    // Make sure the resource file name is defined without its culture<br>    // name.<br>    var baseResourceFileName = GetBaseResourceName(fileName, cultureInfo);<br><br>    // Get the main assembly or the satellite assembly depending if there<br>    // is a culture name specified.<br>    var assemblyToLoad = cultureInfo == null<br>        ? this.assembly<br>        : this.assembly.GetSatelliteAssembly(cultureInfo);<br><br>    // Get the EmbeddedFileProvider instance with the assembly.<br>    var fileProvider = new EmbeddedFileProvider(<br>        assemblyToLoad,<br>        this.assembly.GetName().Name);<br><br>    // Get the file info matching the given fileName argument.<br>    var globalFileInfo = fileProvider.GetFileInfo(baseResourceFileName);<br><br>    // Then we can just call the method that take the fileInfo.<br>    return LoadAndDisplayFromFileInfo(globalFileInfo);<br>}</pre><blockquote>Note that we need to give the assembly name in the <strong>EmbeddedFileProvider </strong>because it is not accessible from the satellite assembly. It is actually used internally to load embedded resources that are prefixed with it.</blockquote><p>We add the two helper methods to get the <strong>CultureInfo </strong>and the base resource file name:</p><pre>private CultureInfo? TryGetCultureInfo(string fileName)<br>{<br>    // Find the CultureInfo matching the file name suffix.<br>    var allCultures = CultureInfo.GetCultures(CultureTypes.AllCultures);<br><br>    return allCultures.FirstOrDefault(<br>        ci =&gt; fileName.EndsWith($&quot;.{ci.Name}.json&quot;));<br>}<br><br>private string GetBaseResourceName(string fileName,<br>    CultureInfo? cultureInfo)<br>{<br>    // Remove the culture name from the file name.<br>    return cultureInfo == null<br>        ? fileName<br>        : fileName.Replace($&quot;.{cultureInfo.Name}.json&quot;, &quot;.json&quot;);<br>}</pre><p>We can run the application and this time all resources are successfully loaded!</p><pre>Loading embedded resource &#39;global.json&#39;.<br>Localization entry &#39;HelloKey&#39; is &#39;Hello world!&#39;.<br><br>Loading embedded resource &#39;global.json&#39;.<br>Localization entry &#39;HelloKey&#39; is &#39;Bonjour à tous!&#39;.</pre><h4>A last word?</h4><p>The full article code sources can be found in <a href="https://github.com/xaviersolau/DevArticles/tree/embedded_resources_with_culture_name_suffix">this repository</a>.</p><p>And if you want to use a Json base localization solution in your dotnet project, you might by interested by <a href="https://github.com/xaviersolau/BlazorJsonLocalization">this project</a> too.</p><p>Well, I hope you found this article helpful!</p><p>Thanks for reading!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fGBGqQk4i2paUQec" /><figcaption>Photo by <a href="https://unsplash.com/@markusspiske?utm_source=medium&amp;utm_medium=referral">Markus Spiske</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=21f279b9327b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/younited-tech-blog/cant-load-embedded-resources-with-culture-name-suffix-in-net-core-21f279b9327b">Can’t load embedded resources with culture name suffix in .Net Core.</a> was originally published in <a href="https://medium.com/younited-tech-blog">YounitedTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to enhance your Service Hooks usage using Azure DevOps REST API ?]]></title>
            <link>https://medium.com/younited-tech-blog/how-to-enhance-your-service-hooks-usage-using-azure-devops-rest-api-bb07dcb726b9?source=rss----b5e215f370b0---4</link>
            <guid isPermaLink="false">https://medium.com/p/bb07dcb726b9</guid>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[azure-devops]]></category>
            <category><![CDATA[rest-api]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Cédric Valiente]]></dc:creator>
            <pubDate>Wed, 26 Jul 2023 09:18:33 GMT</pubDate>
            <atom:updated>2023-07-26T09:18:33.520Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to enhance your Service Hooks usage using Azure DevOps REST API ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3dFA6ywMtXJT5r4e" /><figcaption>Photo by <a href="https://unsplash.com/@freys?utm_source=medium&amp;utm_medium=referral">Freysteinn G. Jonsson</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>In my previous <a href="https://medium.com/younited-tech-blog/start-using-azure-devops-rest-api-in-c-c91e30685a49">article</a>, I showed you how to start using the powerful Azure DevOps REST API using C#.</p><p>Now I will show a more advanced use case that will show you how to get more insight on a nice feature called Service Hooks by using some API endpoints.</p><p>We will focus on Service Hooks events that will help us track deployments events that occurs inside one Azure DevOps Team Project pipelines.</p><p>First, let’s explain briefly what’s the Service Hook feature is about 🚀.</p><h3>Service Hooks</h3><p>This feature is available in every Azure DevOps Team Project.</p><blockquote>👉 By default, Admin permissions is required to be able to see or configure Service Hooks. It’s still possible to get permissions to manage Service Hooks if you can’t get admin permissions, see the FAQ <a href="https://learn.microsoft.com/en-us/azure/devops/service-hooks/troubleshoot?toc=%2Fazure%2Fdevops%2Fmarketplace-extensibility%2Ftoc.json&amp;view=azure-devops#q-can-i-grant-a-regular-project-user-the-ability-to-view-and-manage-service-hook-subscriptions-for-a-project">here</a>.</blockquote><p>You can use this feature to configure integration with other services. That will allows you to react to<strong> events that occurs in Azure DevOps</strong> in third party services. See all built-in available services integration <a href="https://learn.microsoft.com/en-us/azure/devops/service-hooks/overview?view=azure-devops#available-services">here</a>.</p><p>A common usage is the integration with Slack or Microsoft Teams to get various notifications like, we won’t cover it in this article. <br>For more information see the <a href="https://learn.microsoft.com/en-us/azure/devops/service-hooks/services/workplace-messaging-apps?view=azure-devops">Workplace Messaging Apps</a> documentation related to this usage.</p><p>Here we will use<strong> Service Hooks </strong>services that will push a message into an <a href="https://learn.microsoft.com/en-us/azure/storage/queues/storage-quickstart-queues-portal">Azure Storage Queue</a> <strong>each time a deployment is done using a pipeline</strong>. This message can be consumed by an Azure Function for example (we won’t cover the consumption part in this article).</p><p>Let’s see how we will do that now using the REST API 😎.</p><h3>A word about pipelines naming: YAML and classic</h3><p>When you read articles or documentation about Azure DevOps, you may encounter multiple terms about pipelines: there is mostly 2 categories:</p><ul><li>Build and release pipeline that can be created using a web interface: they are called <strong>classic</strong>.</li><li>Pipelines that can do both build and deployment which are created using YAML files that are source controlled: they are called <strong>YAML pipelines</strong>.</li></ul><p>That’s a bit less obvious when you browse Azure DevOps web interface 😅:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/364/1*HIogaxJYXHGGnIbaZ0AQ5w.png" /><figcaption>Azure DevOps pipelines menu featuring classic and YAML pipelines</figcaption></figure><p><strong>Classic</strong> pipelines are still supported but newer features are reserved to <strong>YAML pipelines</strong>. Official documentation is useful to check which feature is available <a href="https://learn.microsoft.com/en-us/azure/devops/pipelines/get-started/pipelines-get-started?view=azure-devops#feature-availability">here</a>.</p><blockquote>👉 If you create a new organization in Azure DevOps, you may only find <strong>YAML pipelines</strong> by default. There is a feature to disable classic pipelines that will be enabled by default (see this <a href="https://devblogs.microsoft.com/devops/disable-creation-of-classic-pipelines/">blog article</a>).</blockquote><h3>Tracking pipeline deployments</h3><p>I chose to use events related to deployments because there is some special details about them that make this use case interesting.</p><p>We will use the following Service Hook events to track deployments. We will cover deployments done with both classic releases and YAML pipelines:</p><ul><li><a href="https://learn.microsoft.com/en-us/azure/devops/service-hooks/events?toc=%2Fazure%2Fdevops%2Fmarketplace-extensibility%2Ftoc.json&amp;view=azure-devops#release-deployment-completed"><strong>Release deployment completed</strong></a><strong>: </strong>this event will help us track deployment done using classic release pipeline.</li><li><a href="https://learn.microsoft.com/en-us/azure/devops/service-hooks/events?toc=%2Fazure%2Fdevops%2Fmarketplace-extensibility%2Ftoc.json&amp;view=azure-devops#run-stage-state-changed"><strong>Run stage state changed</strong></a><strong>: </strong>this event will help us track all YAML pipelines execution (and some of them may use deployment jobs).</li></ul><h4>Action 🚀</h4><p>Ok now let’s create those events ! I will still use <a href="https://www.linqpad.net/">LINQPad</a> to run those code samples.</p><p>You will need to prepare the following information:</p><ul><li>Generate a PAT token on your Azure DevOps organization. Each sample tell you which permission you will need.</li><li>Use an existing Azure Storage Account or <a href="https://learn.microsoft.com/en-us/azure/storage/common/storage-account-create?tabs=azure-portal#create-a-storage-account-1">create</a> a new one. You will need to get the <a href="https://learn.microsoft.com/en-us/azure/storage/common/storage-configure-connection-string">storage account access keys</a>.</li><li>In your Azure DevOps organization, select a team project you will use and get the team project id using using the REST API. You can browse url <a href="https://dev.azure.com/younitedcredit/_apis/projects/">https://dev.azure.com/</a>&lt;AZURE-DEVOPS-ORGANIZATION&gt;<a href="https://dev.azure.com/younitedcredit/_apis/projects/">/_apis/projects/</a></li></ul><blockquote>👉 Each code sample will create one event. You need to replace the following tokens to provide your personal values:</blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6b7eda733a92c6d7573802027e410830/href">https://medium.com/media/6b7eda733a92c6d7573802027e410830/href</a></iframe><h4>Create deployment completed subscription</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1d8a3c5d50222a6983318e2b37e16c35/href">https://medium.com/media/1d8a3c5d50222a6983318e2b37e16c35/href</a></iframe><h4>Create run stage state changed subscription</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eebcc92f8db7a0c8c8ea791c5a92c319/href">https://medium.com/media/eebcc92f8db7a0c8c8ea791c5a92c319/href</a></iframe><h3>Test your subscriptions 🚀</h3><p>Trigger some deployments to get notifications in your storage queue when your pipelines are executed !</p><p>You can browse your storage queue using Azure Portal or <a href="https://learn.microsoft.com/en-us/azure/vs-azure-tools-storage-manage-with-storage-explorer?tabs=windows">Azure Storage Explorer</a> to look at the JSON payload Azure DevOps sent to your queue 🥳.</p><h3>Watch your subscriptions details</h3><p>Use the web interface from your team project then <strong>Project Settings</strong> &gt; <strong>Service Hooks.</strong></p><p>Direct url access (don’t forget to replace tokens with your values): <a href="https://dev.azure.com/">https://dev.azure.com/</a>&lt;AZURE-DEVOPS-ORGANIZATION&gt;/&lt;AZURE-DEVOPS-TEAMPRROJECTID&gt;/_settings/serviceHooks</p><p>Browse <a href="https://learn.microsoft.com/en-us/rest/api/azure/devops/hooks/subscriptions?view=azure-devops-rest-7.0">REST API subscriptions</a> endpoints with your browser. Use list endpoint to get subscriptions ids if you didn’t saved after creation.</p><ul><li><strong>GET list: </strong><a href="https://dev.azure.com/%7Borganization%7D/_apis/hooks/subscriptions?api-version=7.0">https://dev.azure.com/</a>&lt;AZURE-DEVOPS-ORGANIZATION&gt;<a href="https://dev.azure.com/%7Borganization%7D/_apis/hooks/subscriptions?api-version=7.0">/_apis/hooks/subscriptions?api-version=7.0</a></li><li><strong>GET subscription details:</strong> <a href="https://dev.azure.com/%7Borganization%7D/_apis/hooks/subscriptions/%7BsubscriptionId%7D?api-version=7.0">https://dev.azure.com/</a>&lt;AZURE-DEVOPS-ORGANIZATION&gt;<a href="https://dev.azure.com/%7Borganization%7D/_apis/hooks/subscriptions/%7BsubscriptionId%7D?api-version=7.0">/_apis/hooks/subscriptions/{subscriptionId}?api-version=7.0</a></li></ul><h3>Service Hooks gotcha/limitations</h3><p>Here a quick list of interesting details or limitations about Service Hook usage:</p><ul><li>7 days events history.</li><li>Payload size is <a href="https://learn.microsoft.com/en-us/azure/devops/service-hooks/troubleshoot?toc=%2Fazure%2Fdevops%2Fmarketplace-extensibility%2Ftoc.json&amp;view=azure-devops#q-what-is-the-payload-limit-of-a-service-hook">limited</a> to 2 MB. Even more (64 KiB) if you want to push message to <a href="https://learn.microsoft.com/en-us/azure/storage/queues/scalability-targets#scale-targets-for-queue-storage">Azure Storage Queue</a>.</li><li>Outbound IP addresses used by Service Hooks calls are available <a href="https://learn.microsoft.com/en-us/azure/devops/organizations/security/allow-list-ip-url?view=azure-devops&amp;tabs=IP-V4#ip-addresses-and-range-restrictions">here</a> (if you have network restriction in place).</li></ul><p>Also a lot of useful information in the<a href="https://learn.microsoft.com/en-us/azure/devops/service-hooks/troubleshoot?toc=%2Fazure%2Fdevops%2Fmarketplace-extensibility%2Ftoc.json&amp;view=azure-devops"> troubleshooting page</a> documentation 😍.</p><h3>Next step</h3><p>As you may have noticed if you looked at JSON payload, in the case of YAML pipeline notifications, we don’t exactly have the information that a deployment have been executed but only that a pipeline was executed !</p><p>In the next article, I will show you a possible solution to achieve that, stay tuned 😉</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb07dcb726b9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/younited-tech-blog/how-to-enhance-your-service-hooks-usage-using-azure-devops-rest-api-bb07dcb726b9">How to enhance your Service Hooks usage using Azure DevOps REST API ?</a> was originally published in <a href="https://medium.com/younited-tech-blog">YounitedTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Large Language Models in TECH Operations]]></title>
            <link>https://medium.com/younited-tech-blog/large-language-models-in-tech-operations-85b8e97b78fa?source=rss----b5e215f370b0---4</link>
            <guid isPermaLink="false">https://medium.com/p/85b8e97b78fa</guid>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[powershell]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Antoine habert]]></dc:creator>
            <pubDate>Thu, 06 Jul 2023 07:57:32 GMT</pubDate>
            <atom:updated>2023-07-06T07:57:32.464Z</atom:updated>
            <content:encoded><![CDATA[<h3>Large Language Models in Tech Operations: Our Experience with Azure OpenAI, GPT and PowerShell</h3><p>In this article, I want to share our journey, our discoveries, and the value that these technologies add to the day-to-day management of our Cloud infrastructure.</p><p>As the Tech Operations Manager at Younited, I collaborate with the DevSecOps, SRE, and Tech Support teams to ensure the operational quality and performance of our technical production platform. We recently had the opportunity to experiment with large language models (LLMs) in the realm of IT Operations. Specifically, we’ve deployed thanks to Microsoft generative models GPT-3.5, GPT-4 and <a href="https://platform.openai.com/docs/guides/embeddings/what-are-embeddings">ADA-002</a> within <a href="https://azure.microsoft.com/en-us/products/cognitive-services/openai-service">Azure Cognitive Services</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/299/1*9G8A4Rg9f8ScPn68_uiFMA.png" /><figcaption>Azure OpenAI in Microsoft Cognitive Services</figcaption></figure><h3>Younited Overview</h3><p><a href="https://younited.com/">Younited</a> is a rapidly growing french Fintech with more than 600 employees across five countries. We are specialists in loan-as-a-service within complete digital journeys, including electronic signature, KYC, BankReaders, and automated scoring. Our portfolio includes B2C loans platforms in Europe, customized B2B solutions for our partners, and a B2B2C payment solution known as <a href="https://younited.com/fr/partners/pay/">Younited Pay</a>.</p><h3>Our Technical Infrastructure</h3><p>Since 2016, Younited has adopted a microservices architecture and migrated our infrastructure to a 100% Cloud environment, predominantly on Azure. Our development teams are organized into feature teams, and we prioritize managed services across the entire production chain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/286/1*GbL6_jWA70tFouIuAHu5ug.png" /><figcaption>Devops — everything as code</figcaption></figure><p>We’ve adopted the “as code” approach for infrastructure, configuration, alerting, and of course applications’ build and deployment. With continuous integration in our architecture, we are averaging 15 deployments per day, making our Information System particularly dynamic.</p><h3>AI to Tackle DevSecOps, SRE and Tech Support Challenges</h3><p>Given our rapid growth, we are continuously looking to automate as many tasks and issue resolutions as possible. A vital part of this growth strategy is empowering our technical teams to efficiently locate and cross-reference the wealth of information provided by TECH OPS, with the eventual goal of transforming these resources into self-service procedures.</p><p>Moving on to another crucial aspect, our 100% Cloud microservices infrastructure offers considerable flexibility, scalability, and efficiency. However, this distributed architecture does not come without challenges.</p><p>When an incident occurs, particularly if it affects a transverse component in our information system, quickly identifying the root cause can prove complex. The complexity can emerge from various facets within the rich and diverse ecosystem of loan processing, such as multiple alerts triggered by a failed component, interdependencies, internal processes, interactions with third parties, or a chain of interconnected problems (Murphy’s Law). In such situations, it becomes crucial to have tools that enable swift analysis and mitigation to minimize the impact on our operations and customer services. These tools play a vital role in efficiently directing the various support levels and escalation, regardless of the specific problems that arise.</p><p>This is exactly where <a href="https://azure.microsoft.com/en-us/products/cognitive-services/openai-service">Azure OpenAI</a> comes into play. These AI solutions show promising potential to assist us in several key Tech OPS processes:</p><ul><li>Speeding up script creation</li><li>Facilitating documentary research and onboarding</li><li>Automating support and advanced Cloud and CI/CD related workflows</li><li>Optimizing our incident management process through swift root cause analysis</li></ul><p>We will specifically explore our use of AI for Root Cause Analysis (RCA), one of many potential use cases we are evaluating for <a href="https://azure.microsoft.com/en-us/products/cognitive-services/openai-service">Azure OpenAI</a>’s pertinence.</p><h3>AI for Root Cause Analysis</h3><p>In our efforts to improve incident analysis and mitigation, we decided to focus on RCA as one of the first areas to evaluate with modern AI/LLMs. Our goal was to:</p><ol><li>Quickly identify the source of exceptions</li><li>Determine the origin of issues (internal, external, application-based, and/or infrastructure-based)</li><li>Visualize problems through graphical representations</li><li>Automatically implement mitigations when possible</li><li>Offer a relevant sequence of remediation steps if no automatic mitigations are possible</li><li>Provide next steps for further analysis if necessary</li></ol><p>We also wanted to be able to capitalize on our experience by providing feedbacks to GPT on its analyses, establishing a cycle of continuous improvement, and enabling it to adapt closely to our environment and technical specificity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*gz62sorzpzgK3ySFT4Zg6A.png" /><figcaption>Our initial GPT powered RCA Analysis workflow projection</figcaption></figure><p>To address this challenge, we built a proof of concept (POC) process leveraging our existing tools and the capabilities provided by OpenAI’s GPT4.</p><h3>Reusing our Slack integrated PowerShell Bot for fast POC</h3><p>We started by leveraging an existing bot on Slack, based on a fork of <a href="https://github.com/poshbotio/PoshBot">PoshBot</a>. PoshBot is a PowerShell bot framework we already use for certain infrastructure tasks, mainly reporting. We added a layer to this bot to enable it to interact with <a href="https://azure.microsoft.com/en-us/products/cognitive-services/openai-service">Azure OpenAI</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/0*H26jKSOJ5RO7z1m8" /></figure><h3>Interaction with Azure OpenAI detailed workflow</h3><p>In this section, we present a detailed workflow of the POC, showcasing the interactions between ChatGPT agents, PowerShell, <a href="https://github.com/hwchase17/langchain">Langchain</a>, and <a href="https://platform.openai.com/docs/guides/embeddings/what-are-embeddings">ADA-002</a> in the context of RCA generation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/943/1*EgHd3XY6t4kiFTm2EWRwFg.png" /><figcaption>RCA Analysis POC detailed workflow</figcaption></figure><p>The first step <strong>[1]</strong> of interacting with GPT involves loading a ChatGPT context using a bot command. Loading a context means that we add a system prompt at the beginning of the JSON payload that is exchanged with <a href="https://azure.microsoft.com/en-us/products/cognitive-services/openai-service">Azure OpenAI</a>.</p><blockquote>ChatGPT uses a specific JSON payload structure when interacting with the OpenAI API. The payload is structured around three key elements: “system”, “user”, and “assistant”. <a href="https://tmmtt.medium.com/chatgpt-api-tutorial-3da433eb041e">More info here</a>.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/423/1*gFpWyfCzsFGzdKz1gz6y3w.png" /></figure><h3>Let’s Talk JSON!</h3><p>We crafted this context (System Message) so that ChatGPT would respond <strong>exclusively in the JSON format</strong>. This allows us to interpret ChatGPT’s outputs more easily with our PowerShell code. We put this at the beginning of the prompt, as this is the most important instruction that we want GPT to consider.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*zjWCK0WNXWHsOVH2UNlbdA.png" /><figcaption>Preview of our RCA ChatGPT prompt</figcaption></figure><p>For instance, if GPT provides a textual response, we instruct it to create a “text” block in the response. Likewise, if the response contains code, we instruct it to create a “code” block. If the response requires a specific action, we instruct it to create an “ACTION” block with the action’s name and appropriate parameters. This formatting command is crucial when using ChatGPT in “middleware” mode, as it greatly simplifies the way we handle data and makes our processes smoother.</p><h3>The RCA process trigger</h3><p>Once the user requests <strong>[2]</strong> an RCA for a certain OperationID and provides an associated log analytics name, ChatGPT generates an “Action” block with the name “RCA” and the parameters OperationID and AppInsightName. Even with this rather small prompt, it perfectly understands the query even if the user writes in French or Italian, that a huge step forward in ease of use compared to older bot framework/techniques that I’ve experienced. It simply works great.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*_vn77Hi8c2lDU5V5ouPx5g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*dcKbiYPwf-NE6qFL7JX8Cw.png" /></figure><p>This triggers a PowerShell command <strong>[3]</strong> that retrieves all associated End-to-End transactions (requests, dependencies, traces, etc.) and do so for each internal dependency that relate to the OperationID. This creates a comprehensive and complete log file on a request exception, which is then sent back to ChatGPT as input. The user receives a graphical representation of the timeline of events and the logs in JSON format <strong>[4]</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/533/1*Y4zBOItKDr6x3VH__OBPiQ.png" /></figure><p>Meanwhile, ChatGPT receives a lighter version of the AppInsights logs transformed into CSV format via <a href="https://github.com/hwchase17/langchain">Langchain</a>. Note that the chart code was entirely generated thanks to ChatGPT, and the code was nearly perfect in minutes, saving us precious time to play with more interesting topics!</p><blockquote>We transform the JSON into CSV because this format is significantly less demanding on GPT tokens. Langchain provides functions to transform JSON, wiki markups and other text format to optimized GPT text. even if in our usecase ChatGPT respond with exclusive JSON, we can dynamically take its output, react in our powershell or .NET code, then change the final output in the openai payload in order to <a href="https://techcommunity.microsoft.com/t5/healthcare-and-life-sciences/unlocking-the-power-of-tokens-optimizing-token-usage-in-gpt-for/ba-p/3826665#:~:text=Tokens%20are%20the%20fundamental%20units,on%20the%20specific%20tokenization%20approach.">keep tokens count low</a>.</blockquote><p>Next, ChatGPT provides a summary of the incident and calls on <a href="https://github.com/hwchase17/langchain">Langchain</a> <strong>[5]</strong> to verify in our vector database (in this case, <a href="https://www.trychroma.com/">ChromaDB</a>) whether a similar incident has previously occurred, and if so, retrieves any feedback provided at the time <strong>[6]</strong>. If such feedback exists, it is considered by ChatGPT in its analysis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*USgmPafz32Mu69qejp2GvA.png" /></figure><p>ChatGPT then performs a comprehensive analysis of the incident <strong>[7]</strong>: summarizing the incident, carrying out a RCA (determining if the issue is internal/external, application-based, or infrastructure-related, based on the retrieved data and prior feedback), and suggesting next steps (additional analyses, potential mitigations such as restarting an application, upscaling an application host, upgrading a database DTU, etc.).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/719/1*VDjwL2UQtuKNMC4xOkE_Jg.png" /></figure><blockquote>Please note that we’ve instructed ChatGPT to respond within Slack and asked it to use the corresponding formatting associated with this mode of interaction on its own. As a result, it autonomously applies formatting to certain words, uses emoticons, and so on. Of course, this would also work with Teams or other messaging systems that was in the scope of its training.</blockquote><p>In the end, if the user submits feedback <strong>[8]</strong>, the bot will generate a new ‘Action’ command instructing PowerShell to add this feedback <strong>[9]</strong> (potentially amended by ChatGPT for additional clarity based on our context instructions) directly into the vector database using a call to <a href="https://github.com/hwchase17/langchain">Langchain</a> and <a href="https://platform.openai.com/docs/guides/embeddings/what-are-embeddings">the ADA-002 model</a> <strong>[10]</strong>. This way, it can be retrieved and reviewed if the same incident occurs in the future.</p><h3>Next Steps</h3><p>In the future, we plan to industrialize the process of capitalizing more precisely on the knowledge gained from each incident, bringing more details and decision-making capacities into the mix. We aim to include automated mitigation for well-known use-cases and manage the entirety of the incident management chain — from team interventions to post-mortem quality. In addition, we’re looking to utilize a wider range of large language models to cater specifically to certain needs, such as specializing in .NET/PYTHON/PowerShell code, or gleaning information on our architectures, best practices, etc.</p><h3>Lessons Learned from Integrating GPT Into Our Processes</h3><p>Throughout our integration of AI into our operations, we’ve gleaned some valuable lessons:</p><ul><li><strong>Multiple Agents:</strong> We found it more efficient to use multiple ChatGPT agents for different steps in the RCA process. This strategy helped us limit the size of the prompts and increase efficiency, avoiding token saturation.</li><li><strong>GPT-4’s</strong> <strong>Improved Instruction Following and Reduced Hallucination:</strong> GPT-4 demonstrates significant advancements in following instructions accurately and minimizing the generation of irrelevant or incorrect information (hallucinations). This improvement in instruction adherence and reduced hallucination contributes to more reliable outputs.</li><li><strong>Consider Performance and Cost:</strong> It’s important to consider the trade-off between performance and cost when choosing between GPT-4 and other models. While GPT-4 offers enhanced capabilities, it is slower and comes at a higher cost. Therefore, it’s crucial to evaluate your specific use case and determine which model aligns best with your needs while optimizing operational efficiency and managing costs effectively. In your workflow for each agent, choose the suitable AI model (GPT 3.5 / GPT4 8K / GPT4 32K or other non-OpenAI models…) based on the specific needs of each agent. This approach ensures optimal operation, cost optimization, and expected results from each agent.</li><li><strong>Prioritizing English:</strong> One important lesson we’ve learned is the significance of prioritizing English. Although GPT excels at contextualizing user requests in multiple languages, English usually requires fewer tokens for the same instruction. By giving priority to English, we can optimize token usage, resulting in more efficient communication with the model. This optimization leads to improved performance and more favorable outcomes.</li><li><strong>Formatting ChatGPT Output:</strong> Forcing the output of ChatGPT into a JSON format simplifies data interpretation by our PowerShell code. It allows us to exploit the results easily within our code.</li><li><strong>Coding Predictable Information:</strong> When information is predictable, directly coding its gathering to feed into the conversation has proven to be efficient. This not only makes our processes more effective, but also saves computational resources. But feel free to use ChatGPT to generate the code for you, it works great!</li><li><strong>Using Embedding:</strong> <a href="https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/embeddings?tabs=console">Embedding</a> is used to handle dynamic information learning and collection. This optimizes token usage, manages continuous improvement, and maintains long-term memory of conversations.</li><li><strong>Preferring CSV Format for structured Data input:</strong> We found that CSV is generally a better format for incoming data than JSON or other structured Data like XML. It facilitates data processing, makes our operations more effective and most importantly uses fewer tokens for the same result.</li><li><strong>Using a Framework:</strong> It’s worth noting the benefits of using a framework like <a href="https://github.com/hwchase17/langchain">Langchain</a> for testing. It provides a unified interface for interacting with different LLM and managing basic tasks like conversation, history, embedding, and information retrieval. It also provides several commands for managing agents and their workflows. This allows for rapid testing and exploration of different models and approaches.</li></ul><blockquote>it’s important to remember that Langchain is still a relatively young framework. For more custom use-cases, it might be simpler and more effective to directly code the process yourself. It’s a matter of choosing the right tool for the job and using Langchain where it makes sense. At the very least, it provides an excellent way to easily explore and experiment with different LLMs and workflows.</blockquote><h3><strong>Data Privacy</strong></h3><p>As a Fintech company and a bank, we operate in a heavily regulated environment <strong>where the privacy and security of our data are of utmost importance</strong>. One of the major considerations in our decision to experiment with GPT-4 was the data confidentiality aspect. We were able to proceed with our tests with confidence, knowing that Microsoft provided a transparent privacy policy that was compliant with our established Azure practices. Furthermore, <strong>the data localization in Europe was a critical factor for us</strong>. Ensuring that our data stayed within regulatory-approved boundaries was essential in maintaining our standards and the trust of our customers. It was reassuring to see that advanced AI technologies like GPT-4 can still be used in a manner that aligns with our stringent data privacy and security requirements.</p><h3>Data Governance</h3><p>Even with robust data privacy measures by the provider, <strong>it’s vital to establish clear rules regarding what can and cannot be shared with a LLM</strong>, especially in an internal use context. This should align with the overall data practices of the organization, for instance, the handling of P2I (Process, People, and Information) data.</p><p>One smart way to ensure data protection is to integrate usage rules directly into the ChatGPT context, such as prohibiting the use of personal information in exchanges. We could also consider creating a dedicated agent responsible for detecting unauthorized information in the conversation.</p><p>Before transitioning to a production environment,<strong> it is essential to ensure that usage guidelines are clearly defined and communicated to all users.</strong> This will help to prevent any inadvertent data sharing that could potentially compromise sensitive information. By setting up these clear boundaries and adhering to best practices for data governance, organizations can maintain the security and integrity of their data while still leveraging the benefits of LLMs.</p><h3>In Conclusion</h3><p>The integration of OpenAI GPT-4 and <a href="https://platform.openai.com/docs/guides/embeddings/what-are-embeddings">ADA-002</a> models has been a truly exciting and enriching journey for our Tech Operation teams at Younited.</p><p>In terms of our POC objectives, <strong>they have been successfully met</strong> — the system functions effectively, with the generated Root Cause Analyses proving to be accurate and insightful. Moreover, the addition of vectorizing feedbacks presents a promising future for continual learning and process improvement. We eagerly anticipate further development and enhancements in our AI integration journey.</p><p>Indeed, LLMs hold immense promise for the future of Tech OPS processes in all fields: DevSecOps, SRE, Tech Support and beyond. They can be invaluable for tasks ranging from automation, coding assistance, information retrieval, to the handling of complex information processing tasks such as RCA or even self-service on devops processes based solely on documentation.</p><p>However, <strong>it’s important to recognize that these are still early days</strong>. As we continue to explore and these models mature, their utility will undoubtedly grow. The future likely lies with a combination of large, general models capable of following complex instructions, and smaller, highly specialized models fine-tuned by companies to meet specific needs (be they Devops, support, or business-specific or tech-specific).</p><p>Despite the challenges, it is crucial for organizations <strong>to begin exploring what is currently possible with LLMs</strong>. The potential applications are vast, and getting a head start on understanding and implementing these technologies will be a significant advantage as they continue to evolve. The future of Tech ops is incredibly exciting, and LLMs like GPT-4, <a href="https://platform.openai.com/docs/guides/embeddings/what-are-embeddings">ADA-002</a> and the growing open source generative models ecosystem will undoubtedly play a crucial role in shaping it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=85b8e97b78fa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/younited-tech-blog/large-language-models-in-tech-operations-85b8e97b78fa">Large Language Models in TECH Operations</a> was originally published in <a href="https://medium.com/younited-tech-blog">YounitedTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Optimisation de la livraison logicielle : Surmontez les défis de la phase de déploiement]]></title>
            <link>https://medium.com/younited-tech-blog/optimisation-de-la-livraison-logicielle-surmontez-les-d%C3%A9fis-de-la-phase-de-d%C3%A9ploiement-ce91f928e3e0?source=rss----b5e215f370b0---4</link>
            <guid isPermaLink="false">https://medium.com/p/ce91f928e3e0</guid>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[product-owner]]></category>
            <dc:creator><![CDATA[Marwen Saafi]]></dc:creator>
            <pubDate>Tue, 27 Jun 2023 08:42:40 GMT</pubDate>
            <atom:updated>2023-06-27T08:42:40.503Z</atom:updated>
            <content:encoded><![CDATA[<h3>Optimisation de la livraison logicielle : Surmontez les défis de la phase de déploiement</h3><p>La rapidité est un élément clé de la réussite. Dans le domaine du développement logiciel, cela se traduit par la nécessité de livrer nos produits plus rapidement que jamais… 🚀🚀🚀</p><h3>Introduction :</h3><p>La gestion efficace de la livraison de produits logiciels constitue un défi crucial pour de nombreuses entreprises technologiques.</p><p>Le passage aux <a href="https://medium.com/younited-tech-blog/project-team-ou-product-team-la-sentence-est-irr%C3%A9vocable-21573e0f80e2">Component Team</a> et à l’<a href="https://www.atlassian.com/fr/microservices/microservices-architecture">Architecture microservices</a> sont deux approches couramment utilisées pour améliorer la livraison de logiciels dans les entreprises technologiques.</p><p>Les Component Teams favorisent la collaboration étroite entre les membres de l’équipe, en encourageant la communication continue, le partage des connaissances et la prise de décisions collective.</p><p>Une équipe typique dans une entreprise tech comprend un Product Owner (PO), un Ingénieur en Assurance Qualité (QA) et plusieurs Développeurs (<a href="https://www.codexa.fr/conduite-de-reunion/pizza-team-le-nouveau-concept-de-reunions/">pizza team</a>). Traditionnellement, le PO organise les sprints et le backlog, tandis que les Développeurs se concentrent sur le développement des fonctionnalités. Le QA est chargé de tester toutes les User Stories avant leur déploiement.</p><p>Cependant, cette approche peut entraîner plusieurs problématiques. Dans nos équipes, nous avons récemment été confrontés à des difficultés similaires. Nous avons constaté que le QA était submergé de travail lorsqu’il s’agissait de tester le travail de plusieurs Développeurs. Les Développeurs se concentraient principalement sur la phase de développement, laissant la phase de déploiement et de test en suspens. En conséquence, de nombreuses User Stories se sont retrouvées bloquées dans la colonne “review PR” ou “To test”, retardant ainsi leur intégration dans le produit final. La pression exercée par l’équipe business pour livrer les fonctionnalités à temps a exacerbé la situation.</p><p>Dans cet article, nous explorerons différentes approches et stratégies pour surmonter les problèmes lors de la phase de déploiement et optimiser le processus de livraison. En adoptant des pratiques axées sur la collaboration et l’autonomie, nous chercherons à renforcer notre capacité à livrer rapidement des fonctionnalités tout en garantissant des standards élevés en matière de qualité logicielle.</p><h3>Un peu de contexte :</h3><p>Lorsque nos équipes ont envisagé différentes méthodologies de gestion de projet, nous avons pris la décision de nous orienter vers le <a href="https://asana.com/resources/what-is-kanban">Kanban</a> plutôt que le Scrum. Parmi les raisons qui ont motivé ce choix, les changements de priorités et les imprévus ont joué un rôle crucial. Voici quelques-unes des autres raisons qui ont influencé notre décision :</p><ul><li><strong>Flexibilité face aux changements</strong> : Nous travaillons dans un environnement où les changements de priorités et les imprévus sont fréquents. Avec le Kanban, nous sommes en mesure de gérer ces situations de manière plus fluide et réactive. Plutôt que d’être liés à des itérations fixes, nous pouvons ajouter, supprimer ou reprioriser des tâches en fonction des besoins changeants du projet.</li><li><strong>Gestion du flux de travail</strong> : Le Kanban met l’accent sur la gestion du flux de travail de manière visuelle et transparente. En utilisant un tableau Kanban, nous pouvons facilement suivre l’état de chaque tâche, identifier les goulots d’étranglement et prendre des mesures pour les résoudre rapidement. Cette approche nous permet de maintenir un flux de travail régulier et d’optimiser notre productivité.</li></ul><p>L’adoption du Kanban par nos équipes a présenté des défis liés à la façon dont les Développeurs, l’ingénieur QA et le PO collaboraient. Ces problèmes comprenaient des Développeurs qui passaient rapidement aux tickets suivants, mettant l’accent sur le développement au détriment des tests et du déploiement. De plus, la responsabilité des tests reposait entièrement sur le QA, ce qui entraînait des goulots d’étranglement et une boucle de rétroaction prolongée. En outre, l’isolement du PO dans la rédaction des User Stories a entraîné des critères d’acceptance incomplets et des lacunes dans la compréhension mutuelle.</p><blockquote>Pour résoudre ces problèmes, il était nécessaire de revoir notre approche et d’apporter des changements au sein de nos équipes, en repensant notre flux de travail et en adoptant des pratiques plus collaboratives.</blockquote><h3>Identification des « pain points » :</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/811/1*B0Uj8uW8E8aYy2jzSsDYCA.png" /><figcaption>brainstorming</figcaption></figure><p>Nous avons pris l’initiative de mener des workshops dédiés. Ces workshops avaient pour objectif d’identifier les points douloureux rencontrés par chaque membre de l’équipe et de trouver des solutions pour les résoudre. Voici comment nous avons procédé :</p><ul><li><strong>Organisation de plusieurs réunions</strong> : Nous avons planifié et organisé plusieurs réunions dédiées où tous les membres de l’équipe pouvaient participer. Ces réunions étaient structurées et permettaient à chacun de s’exprimer librement sur les problèmes qu’il rencontrait dans le processus de déploiement. Ces problèmes comprenaient les retards, les lacunes de communication, les processus inefficaces, les problèmes de test, etc. Nous avons documenté ces problèmes sur Miro pour une visualisation claire et une référence ultérieure.</li><li><strong>Utilisation de </strong><a href="https://miro.com/fr/"><strong>Miro</strong></a><strong> comme outil de travail</strong> : Pour faciliter la collaboration et la visualisation des informations, nous avons utilisé l’outil en ligne Miro. Cela nous a permis de créer des tableaux, des post-its virtuels et de travailler simultanément sur les mêmes documents. Miro a été particulièrement utile pour capturer les idées et les problèmes identifiés lors des sessions de brainstorming.</li></ul><p>Lors de nos workshops, nous avons identifié plusieurs points qui affectaient notre processus de delivery. Voici un résumé des problèmes que nous avons identifiés :</p><ol><li><strong>“Non-importance” de déployer rapidement une fonctionnalité</strong> : Nous avons constaté que l’équipe ne mettait pas suffisamment l’accent sur l’importance de tirer une fonctionnalité vers la production rapidement. Cela entraînait des retards dans la mise à disposition des nouvelles fonctionnalités aux utilisateurs finaux, ce qui pouvait avoir un impact négatif sur notre réactivité envers les besoins du marché et sur la satisfaction des utilisateurs.</li><li><strong>Concentration excessive des Développeurs sur le développement</strong> : Les Développeurs se concentraient principalement sur le fait de passer rapidement au développement du prochain sujet une fois qu’un sujet était terminé. Cette approche “développer plus, c’est mieux” négligeait l’importance d’un déploiement et d’une validation précise et efficace de chaque fonctionnalité développée (en intégrant des tests automatisés aux fonctionnalités développées).</li><li><strong>Goulots d’étranglement dans la phase de test</strong> : En raison de la charge de travail disproportionnée entre le QA et les Développeurs et en l’absence des tests automatisés, la phase de test présentait un véritable goulot d’étranglement. Un seul QA était chargé de tester les fonctionnalités développées par plusieurs Développeurs, ce qui entraînait des retards importants dans la validation et la résolution des problèmes de qualité.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*UMitx6Nk8-oAwVLqkZgkqQ.jpeg" /><figcaption>flux de travail lors de la phase des tests</figcaption></figure><p>4.<strong> Boucles de feedback prolongées</strong> : En raison des problèmes identifiés lors de la phase de test qui auraient pu être évités si une discussion approfondie des tickets avait eu lieu entre tous les membres de l’équipe. Les boucles de feedback étaient souvent longues, ce qui prolongeait le temps nécessaire pour finaliser une fonctionnalité et la rendre prête pour la production.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/647/1*t9u_SWhNtt8z0gh-6RWsiQ.jpeg" /><figcaption>Encore un bug !!</figcaption></figure><blockquote>En identifiant les problèmes rencontrés par chaque partie prenante, nous avons pu avoir une vue d’ensemble des obstacles qui affectaient notre processus de déploiement. Cela a permis de créer une base solide pour développer des solutions.</blockquote><h3>Mise en place des améliorations :</h3><blockquote>1) Sensibilisation à l’importance du déploiement rapide</blockquote><p>a) <strong>Mettre en avant les avantages du déploiement rapide</strong> :</p><p>Expliquez à l’équipe les avantages concrets d’un déploiement rapide, tels que la satisfaction des utilisateurs, la possibilité d’itérer rapidement sur les fonctionnalités, la réduction des risques de conflits de fusion de code et la capacité à fournir des correctifs ou des améliorations plus rapidement. Mettez en évidence les bénéfices pour l’entreprise et pour l’équipe elle-même.</p><p>b) <strong>Impliquer l’équipe dans la planification et la prise de décision :</strong></p><p>Impliquez les membres de l’équipe dans la planification du processus de déploiement et dans la prise de décision concernant les priorités. En leur donnant une voix et en les faisant participer activement, ils se sentiront investis et comprendront mieux l’importance du déploiement rapide pour le succès du projet.</p><p><strong>c) Promouvoir une culture de qualité et de responsabilité :</strong></p><p>Insistez sur l’importance de la qualité du code et des tests dans le processus de déploiement rapide. Encouragez l’équipe à adopter des pratiques de développement telles que la revue de code, les tests automatisés et les tests de non-régression. Faites comprendre à l’équipe que la qualité du code et des tests est essentielle pour garantir un déploiement rapide et sans accroc.</p><blockquote>2) Équilibrer le déploiement versus le développement</blockquote><p><strong>a) Définir des limites de travail en cours (WIP — Work in Progress) :</strong></p><p>Nous avons établi des limites claires sur le nombre de tâches en cours dans chaque colonne de notre board Kanban. Cela permet d’éviter la surcharge de travail et de maintenir un flux de travail régulier. En limitant le nombre de tâches en cours, nous nous assurons que les Développeurs ne se concentrent pas uniquement sur le développement, mais aussi sur les autres étapes du processus, y compris les tests et le déploiement.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/501/1*TidDaTh12Tf2MPIdAOUwmg.jpeg" /><figcaption>D’autres choses à faire avant …</figcaption></figure><p><strong>b) Priorité accordée au passage des tickets vers la colonne de droite :</strong></p><p>Nous avons adopté une approche proactive en accordant la priorité à la progression des tickets vers la colonne de droite de notre board Kanban. Cette colonne représente généralement la phase finale avant le déploiement. En nous assurant que les tickets se déplacent rapidement vers cette colonne, nous favorisons un équilibre entre le développement et le déploiement, en nous assurant que les fonctionnalités développées sont prêtes à être livrées aux utilisateurs finaux.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/507/1*hu2p7nVmzkqVs8LUpJWqzQ.jpeg" /><figcaption>S’entraider pour mieux réussir …</figcaption></figure><p><strong>c) Accélérer les reviews de PR :</strong></p><ul><li>Utiliser des outils de suivi : Utilisez des outils de suivi pour garder une trace des PR en attente de revue. Ces outils permettent de visualiser facilement les PR en cours et d’envoyer des rappels automatiques aux examinateurs (Slack par exemple). Certains outils offrent également des fonctionnalités telles que des tableaux de bord personnalisés ou des notifications pour faciliter le suivi et la gestion des PR (Slack par exemple).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/490/1*yrjtoSNz_BazD63kt8-8dA.png" /><figcaption>Slack reminder</figcaption></figure><ul><li>Encourager la revue continue : Plutôt que d’attendre que le développement soit terminé avant de lancer une revue de PR, encouragez une approche de revue continue. Les Développeurs peuvent partager des PR en cours de développement pour obtenir des retours plus tôt dans le processus. Cela permet d’identifier les problèmes potentiels plus tôt et de réduire le temps nécessaire pour apporter des corrections.</li></ul><blockquote>3) Rééquilibrer les charges de travail</blockquote><p><strong>a) Automatisation des tests :</strong></p><p>Nous avons investi dans des outils et des frameworks d’automatisation des tests pour réduire la charge de travail manuelle du QA (et des dev aussi ;) ). En automatisant les tests fonctionnels, les tests de régression et d’autres aspects du processus de test, nous avons pu libérer du temps pour le QA, lui permettant de se concentrer sur des tâches plus complexes et stratégiques.</p><p><strong>b) Montée en compétence des Développeurs sur la partie test :</strong></p><p>Nous avons organisé des sessions de formation et des ateliers pour permettre aux Développeurs d’acquérir des compétences en matière de test. Cela inclut l’apprentissage des bonnes pratiques de test, l’utilisation d’outils de test appropriés et la compréhension des principes de la qualité logicielle. En renforçant les compétences des Développeurs dans le domaine du test, nous avons réduit la dépendance excessive envers le QA et favorisé une répartition équilibrée des responsabilités.</p><blockquote>4) Réduire la boucle de feedback</blockquote><p><strong>a) Réunion des 3 amigos :</strong></p><p>Organisez une réunion avant de démarrer chaque workItem, réunissant le PO, le développeur et le QA. Cette réunion permettra de clarifier les attentes, de discuter des détails du workItem et de s’assurer que tous les membres de l’équipe ont une compréhension commune des objectifs et des critères de réussite.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/478/1*6gUSQ8tza-dHw_mOPIw4mw.png" /><figcaption>3 amigos meeting</figcaption></figure><p>Nous avons récemment intégré l’utilisation de <a href="https://www.notion.so/product?utm_source=google&amp;utm_campaign=16166134042&amp;utm_medium=133365705979&amp;utm_content=581318305107&amp;utm_term=notion&amp;targetid=kwd-312974742&amp;gclid=CjwKCAjwkLCkBhA9EiwAka9QRkdUi7ucMG3krraEv3DSa3--do3EFlvHPYnqBjQ5RbQcYMR6n9le9RoCHcEQAvD_BwE">Notion</a> pour décrire de manière approfondie les demandes business. En ajoutant le lien Notion dans chaque WorkItem, nous offrons à l’équipe une vue complète de la fonctionnalité en cours de développement. Cette pratique nous permet d’effectuer des revues préliminaires et d’identifier d’éventuelles contradictions entre les spécifications et le workItem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*3S9XXX1qZk1YqpilDDvusA.jpeg" /></figure><p><strong>b) Définir des critères d’acceptance :</strong></p><p>Impliquez le PO, le développeur et le QA dans la définition des critères d’acceptance pour chaque workItem. Ces critères devraient être spécifiques, mesurables et convenus par tous. En définissant les critères ensemble, vous vous assurez que les attentes sont claires et qu’il y a moins de place pour les malentendus ou les interprétations différentes.</p><p><strong>c) Lancement des tests d’intégration en « localhost » et/ou sur les environnements de test :</strong></p><p>Encouragez les Développeurs à effectuer des tests d’intégration locaux avant de soumettre leur travail sur l’environnement de test. Cela permettra d’identifier rapidement les problèmes potentiels et de réduire le nombre de retours en arrière.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/431/1*OjqrVnxHxCWy2jpphNRZHw.jpeg" /><figcaption>l’intérêt des tests d’intégration</figcaption></figure><blockquote>En mettant en œuvre ces mesures, vous favorisez une collaboration plus étroite entre le PO, le développeur et le QA, ce qui permet de réduire la boucle de feedback et d’accélérer le processus de delivery. Les discussions préliminaires et la définition commune des critères d’acceptance aident à éviter les erreurs de communication et les interprétations divergentes, tandis que les tests d’intégration locaux et sur les environnements de test assurent une détection précoce des problèmes. En réduisant les allers-retours, vous gagnez en efficacité et en rapidité, tout en améliorant la qualité globale des livrables.</blockquote><h3>Suivi d’impact des améliorations :</h3><p>Une fois les améliorations mises en place, il est effectivement important de suivre leur impact sur le delivery à l’aide de KPI (Key Performance Indicators). Voici quelques exemples de KPI nous avons utilisé pour évaluer l’efficacité des améliorations.</p><p>Nous avons centralisé les différentes métriques en utilisant un tableau de bord Power BI. Cela nous permet d’avoir une vue consolidée et facilement accessible de nos indicateurs importants en un seul endroit :</p><p>1- <strong>Temps de déploiement :</strong></p><p>Mesurez le temps nécessaire pour déployer une fonctionnalité depuis son développement jusqu’à sa mise en production. Un temps de déploiement réduit indique une amélioration de l’efficacité du processus de delivery.</p><p>2- <strong>Taux d’US avec critères d’acceptance remplis :</strong></p><p>Suivez le pourcentage d’User Stories (US) qui remplissent les critères d’acceptance définis en amont. Un taux élevé indique une meilleure collaboration entre le PO, le développeur et le QA, ainsi qu’une compréhension plus claire des exigences.</p><p>3- <strong>Nombre de bugs en production :</strong></p><p>Suivez le nombre de bugs signalés après la mise en production d’une fonctionnalité. Une réduction de ce nombre indique une amélioration de la qualité du logiciel et de la fiabilité des déploiements.</p><h3>Conclusion :</h3><p>Après 6 mois d’amélioration et de suivi des KPI, nous sommes ravis de constater les résultats positifs des efforts d’amélioration continue :</p><ul><li>Tout d’abord, nous avons réussi à réduire le temps de déploiement de façon significative, avec une baisse de 50% dans certaines équipes. Cela signifie que nous sommes capables de mettre nos fonctionnalités en production plus rapidement, ce qui améliore notre réactivité et notre capacité à livrer de la valeur aux utilisateurs.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*fUZmzL0YOM544zstTSPdgQ.png" /><figcaption>Le temps de déploiement chez une des équipes</figcaption></figure><ul><li>Ensuite, le taux d’US avec critères d’acceptance remplis a considérablement augmenté, atteignant désormais un impressionnant taux de 80%. Cela démontre que nous accordons une plus grande attention à la qualité et à l’adéquation de nos fonctionnalités par rapport aux attentes des utilisateurs.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/501/1*TRwWOfX4XXLoMS_hzX87Uw.png" /></figure><ul><li>Enfin, nous avons réussi à maintenir et à maîtriser le nombre de bugs créés en production. Cela témoigne de notre engagement envers la qualité et de l’efficacité de nos processus de développement et de test.</li></ul><blockquote>Félicitations à l’ensemble des équipes pour ces réalisations remarquables. Nous tenons à saluer l’énorme travail accompli et la collaboration exceptionnelle entre les Product Owners, les Développeurs et les Quality Assurance Engineers pour identifier les problèmes, proposer des améliorations et les mettre en place. Votre dévouement, votre engagement et votre esprit d’équipe ont été essentiels pour obtenir ces résultats positifs. Continuons à travailler ensemble avec cette même énergie et cette même passion pour maintenir cette dynamique et continuer à améliorer notre delivery.</blockquote><blockquote>Bravo à tous !</blockquote><p><strong>Sources :</strong></p><p><a href="https://medium.com/@Remi91394/component-team-vs-feature-team-que-choisir-93638f420de5">https://medium.com/@Remi91394/component-team-vs-feature-team-que-choisir-93638f420de5</a></p><p><a href="https://latavernedutesteur.fr/2017/11/03/que-faire-lorsque-lequipe-de-test-est-un-goulot-detranglement/">https://latavernedutesteur.fr/2017/11/03/que-faire-lorsque-lequipe-de-test-est-un-goulot-detranglement/</a></p><p><a href="https://www.codexa.fr/conduite-de-reunion/pizza-team-le-nouveau-concept-de-reunions/">https://www.codexa.fr/conduite-de-reunion/pizza-team-le-nouveau-concept-de-reunions/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce91f928e3e0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/younited-tech-blog/optimisation-de-la-livraison-logicielle-surmontez-les-d%C3%A9fis-de-la-phase-de-d%C3%A9ploiement-ce91f928e3e0">Optimisation de la livraison logicielle : Surmontez les défis de la phase de déploiement</a> was originally published in <a href="https://medium.com/younited-tech-blog">YounitedTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Les communautés de pratique chez Younited [Partie 1]]]></title>
            <link>https://medium.com/younited-tech-blog/les-communaut%C3%A9s-de-pratique-chez-younited-partie-1-bd649182e4f5?source=rss----b5e215f370b0---4</link>
            <guid isPermaLink="false">https://medium.com/p/bd649182e4f5</guid>
            <category><![CDATA[collaboration]]></category>
            <category><![CDATA[culture]]></category>
            <category><![CDATA[innovation]]></category>
            <category><![CDATA[community-of-practice]]></category>
            <category><![CDATA[knowledge-management]]></category>
            <dc:creator><![CDATA[Agnes Josserand]]></dc:creator>
            <pubDate>Mon, 19 Jun 2023 13:27:21 GMT</pubDate>
            <atom:updated>2023-06-19T13:27:20.887Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*maeqqUaeCZASHv1c-NfbIw.jpeg" /></figure><p>En 1991, E. Wenger et J. Lave publiaient un ouvrage décrivant le concept de communauté de pratique comme étant « un groupe de personnes ou d’institutions qui partagent un intérêt commun envers la même pratique, ainsi qu’une volonté partagée d’améliorer leur expertise et leur expérience de celle-ci ».</p><p>En 2018, notre CTO, Stéphane Alizon lançait l’initiative de fonder des communautés de pratique au sein de l’équipe Tech et de leur allouer un créneau hebdomadaire.</p><p>En 2023, les communautés existent toujours. Au fil des années, elles se sont réinventées sous plusieurs formats afin de réussir à apporter toujours autant de valeur aux collaborateurs ainsi qu’à l’entreprise.</p><p>Le propos de cet article est de présenter le mode de fonctionnement de nos communautés, de partager notre expérience sur les difficultés rencontrées et sur les solutions apportées pour les pérenniser au cours du temps.</p><h3>Les communautés, une réponse aux enjeux d’organisation de Younited</h3><p>Dans un contexte d’hyper croissance, il est nécessaire de combiner rapidité d’exécution et partage de savoir et de bonnes pratiques.</p><p>Notre organisation est basée sur des équipes pluridisciplinaires autonomes regroupant différents rôles : Product Managers, Product Owners, Quality Assurance Engineers, Développeurs. Ces collaborateurs interagissent au quotidien au sein de leur équipe. En revanche, ils ont, par essence, moins d’interactions avec leurs pairs des autres équipes.</p><p>Le manque de synergie peut avoir des effets critiques pour l’entreprise à la fois sur la cohérence du produit et de ses pratiques, le niveau de qualité ou encore les choix technologiques.</p><p>Les enjeux qui émergent sont de deux types :</p><ul><li>D’une part, les membres ont besoin d’échanger avec leurs pairs, pour apprendre et pour bénéficier de conseils de la part de ceux qui rencontrent le même type de problématique.</li><li>D’autre part, l’entreprise a besoin de s’assurer que les collaborateurs progressent dans la même direction, profitent de l’intelligence collective, échangent sur leur pratique, les font évoluer et les harmonisent. C’est également un facteur de motivation pour les collaborateurs et une façon de fidéliser les équipes.</li></ul><p>Pour répondre à ces enjeux, des communautés de rôles ont été mises en place avec un créneau d’une demi-journée par semaine ce qui représente un budget considérable et une vraie mine d’or pour les collaborateurs.</p><h3>Principes et modes de fonctionnement des communautés chez Younited</h3><p>Bien que les communautés reposent sur des principes communs, elles ont également la liberté de mettre en place un fonctionnement et un format approprié à leurs propres besoins.</p><h4>Les principes communs</h4><p>Avant tout, le temps de communauté doit être un moment privilégié et agréable pour ses membres.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/609/1*Gkiyj-XMBi30GUVgN4IUVg.jpeg" /></figure><p>Dans la plupart des communautés, on retrouve :</p><ul><li>Des partages d’expériences : les membres transmettent ce qu’ils ont appris, exposent les difficultés qu’ils ont pu rencontrer et les solutions trouvées</li><li>Des workshops : partage de connaissances et ateliers de mise en pratique</li><li>De la veille : exploration de nouvelles technologies ou méthodologies</li><li>Des prises de décision : le groupe définit des best practices, émet des recommandations et prend des décisions</li></ul><p>Les règles d’or pour les membres sont :</p><ul><li>Fais un break par rapport au delivery</li><li>Prends du temps pour apprendre</li><li>Innove</li><li>Partage tes connaissances</li><li>Have fun</li></ul><p>Les communautés ont lieu toutes les semaines. Les membres restent libres de participer.</p><h3>Les différentes communautés et leur fonctionnement</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cnxKsFXpbJJT_640pMHGmQ.jpeg" /></figure><p>Nous avons mis en place deux types de communautés :</p><ul><li>Des communautés de rôles regroupant des membres de même rôle (par exemple : ProductOwner, QualityAssurance Engineer,…)</li><li>Des communautés d’intérêt rassemblant des rôles différents autour d’un sujet commun</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rkcp0Ms9S2NViJAoTpv6iw.png" /></figure><p><strong>Exemples de communautés de rôle</strong> :</p><ul><li>La communauté de développeurs</li></ul><p>Tout commence par une session de partage de connaissances qui regroupe tous les développeurs</p><p>Et se poursuit ensuite par petits groupes, pour faire de la veille ou développer de nouvelles applications</p><p>Exemples de réalisation :</p><p>Younifaker : application permettant de générer des jeux de données utilisés pour les tests. Ce créneau de communauté a permis aux développeurs d’innover, de concevoir et de maintenir cette application qui est désormais indispensable pour les équipes</p><p>Younidlove : dans un registre différent, portant cette fois plus sur la culture Younited, Younidlove est une application qui permet de faire plaisir à vos collègues. L’application est branchée à Slack et vous demande toutes les semaines d’écrire un message aux personnes que vous souhaitez remercier, féliciter ou autre. Elle le recevra le lundi matin pour bien démarrer la semaine 😊</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/528/1*L_xAx5ln8Kc4U9TKY8EBDQ.png" /></figure><ul><li>La communauté de Product Owners</li></ul><p>A tour de rôle, chaque membre est responsable d’animer entièrement la communauté.</p><p>Les moments incontournables sont : un ice-breaker pour mettre tout le monde de bonne humeur, une session de partage de connaissances, un atelier pour faire contribuer les pairs et faire émerger de nouvelles idées.</p><p>Régulièrement, des sessions sont organisées avec des intervenants extérieurs ou avec d’autres communautés d’autres entreprises. (Par exemple, sur des sujets d’agilité, d’organisation Product Owner &amp; Product Manager, fast codev,…)</p><ul><li>La communauté Quality Assurance :</li></ul><p>Elle repose sur les principes suivants : partage, explore, apprends.</p><p>Elle comprend de nombreuses sessions de partage de connaissances et de workshops.</p><p><strong>Exemples de communautés d’intérêt</strong> :</p><ul><li>La communauté cybersécurité : regroupe des membres de rôles différents (CISO, DevSecOps, développeurs,,…). Ils se réunissent pour partager des problématiques, émettre des recommandations, valider des choix et prendre des décisions.</li><li>La communauté de développement Front : regroupe des développeurs et des Quality Assurance Engineers. Les missions principales sont : d’accompagner les équipes sur les développements d’application front, d’analyser la testabilité des fronts, de définir des recommandations, de choisir et de refuser des technologies.</li></ul><p>La communauté est amenée également à développer de nouveaux outils (exemple de réalisation: l’interface permettant de gérer les features flags).</p><p>La suite de l’article concerne <a href="https://medium.com/p/aee2145b1508/">le partage d’expérience sur les difficultés rencontrées et les solutions apportées</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bd649182e4f5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/younited-tech-blog/les-communaut%C3%A9s-de-pratique-chez-younited-partie-1-bd649182e4f5">Les communautés de pratique chez Younited [Partie 1]</a> was originally published in <a href="https://medium.com/younited-tech-blog">YounitedTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>