<?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[Stories by Pierrick Blons on Medium]]></title>
        <description><![CDATA[Stories by Pierrick Blons on Medium]]></description>
        <link>https://medium.com/@pierrickblons?source=rss-b790a40e2e97------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*C-dVCq0lsaOaVEwvPlJhmQ.jpeg</url>
            <title>Stories by Pierrick Blons on Medium</title>
            <link>https://medium.com/@pierrickblons?source=rss-b790a40e2e97------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 14:37:47 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pierrickblons/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Value types — Tactical DDD with typescript (part 2)]]></title>
            <link>https://medium.com/@pierrickblons/value-types-tactical-ddd-with-typescript-part-2-861bbeffa71a?source=rss-b790a40e2e97------2</link>
            <guid isPermaLink="false">https://medium.com/p/861bbeffa71a</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[tactical-ddd]]></category>
            <category><![CDATA[ddd]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[zod]]></category>
            <dc:creator><![CDATA[Pierrick Blons]]></dc:creator>
            <pubDate>Mon, 15 Sep 2025 19:21:07 GMT</pubDate>
            <atom:updated>2025-09-15T19:22:30.438Z</atom:updated>
            <content:encoded><![CDATA[<h3>Value types — Tactical DDD with typescript (part 2)</h3><p><em>After digging into primitives, let’s have a look at value types.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/433/1*67p_bY3HiKGupZCwDthUhA.png" /><figcaption>Sample typescript code</figcaption></figure><h4>This article is part of the Tactical DDD with Typescript series</h4><ul><li><a href="https://medium.com/@pierrickblons/primitives-tactical-ddd-with-typescript-345e78d9feb7"><em>01 — Primitives</em></a></li><li><em>02 — Value types</em></li><li><em>03 — Entitites</em></li><li><em>04 — Aggregates</em></li><li><em>05 — Repositories</em></li><li><em>06 — Data contracts</em></li></ul><h3>Value types</h3><p>After digging into the primitives, the next step is to look into value types.</p><p>Eric Evans gives some clues to describe a value object in the blue book (Domain Driven Design: Tackling Complexity in the Heart of Software):</p><blockquote>These objects describe some characteristic of a thing. — Eric Evans</blockquote><blockquote>These objects have characteristics of their own and their own significance to the model. These are the objects that describe things. — Eric Evans</blockquote><blockquote>A Value Object can be an assemblage of other objects. — Eric Evans</blockquote><p>Basically a value type is a type without an id which can describe things.</p><p>As we are going to use types in Typescript, I will use the term Value Types instead of Value Object in this article.</p><p>You can think of adresses, email, value, content…</p><p><strong>Basic usage with typescript</strong><br>In our previous example, we started using primitives used in a context of a customer giving comments, let’s add a rating along with the comment. With a business rule of having the value between 1 and 10.</p><pre><br>export type RatingWithComment = {<br> value: number,<br> comment: string,<br>}<br><br>export const rate = (rating: RatingWithComment) =&gt; {<br> if(rating.value &lt; 1 || rating.value &gt; 10) {<br> throw new Error(‘Value must be between 1 and 10’)<br> }<br> // Some business code here handling the rating.<br>}</pre><p>The problem here, is that the business rule has to be enforced every time we deal with a rating value.</p><h4>Smart constructors</h4><p>That’s when we bring **smart constructors** to the rescue (and branded types).</p><p>This concept from Scott Wlaschin in Domain Modeling made Functional book, helps to ensure the integrity of the values.</p><p>Example of a smart constructor for creating a Rating Value</p><pre><br>export type RatingValue = number &amp; { __brand: ‘ratingValue’ }<br><br>export const createRatingValue = (value: number) =&gt; {<br> if(value &lt; 1 || value &gt; 10) {<br> throw new Error(‘Value must be between 1 and 10’)<br> }<br> return value as RatingValue<br>}</pre><p>With this you need to ensure you always call the <em>createRatingValue</em> function to create a rating value.</p><p>You could ease the usage of smart constructors by wrapping them with always the same name for all your value types</p><pre><br>export const RatingValue = {<br> create: createRatingValue<br>}<br><br>const ratingValue : RatingValue = RatingValue.create(7) // do not throw<br>const failingRatingValue : RatingValue = RatingValue.create(12) // will throw Error</pre><h4>Zod</h4><p>The value types is where zod shines. By using zod schemas you will get the smart constructor for free.</p><p>Implementation with zod</p><pre><br>const RatingValueSchema = z.int().min(1).max(10).brand(‘ratingValue)<br>export type RatingValue = z.infer&lt;typeof RatingValueSchema&gt;<br><br>const ratingValue = RatingValueSchema.parse(7)<br>const failingRatingValue = RatingValueSchema.parse(42)<br></pre><p>And you can export the type from the Schema to not couple your function signatures with zod.</p><pre><br>export type RatingWithComment = {<br> value: RatingValue,<br> comment: string,<br>}<br><br>export const rate = (rating: RatingWithComment) {<br> // You are safe rating.value will always be between 1 and 10<br> // Some business code here<br>}</pre><h4>Conclusion</h4><p>Value types describing your entities are critical in your models, they are often reused and combined together to shape your model.</p><p>When implementing them, by ensuring at compile and runtime with typescript that they are what we expect them to be, will help debugging your code and fix production issues faster. For instance if the data in the datastore of our rating has been modified by an external tool or manually and all the values are now out of the range, your code will tell you exactly what’s going on.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=861bbeffa71a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Primitives — Tactical DDD with typescript]]></title>
            <link>https://medium.com/@pierrickblons/primitives-tactical-ddd-with-typescript-345e78d9feb7?source=rss-b790a40e2e97------2</link>
            <guid isPermaLink="false">https://medium.com/p/345e78d9feb7</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[ddd]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[zod]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Pierrick Blons]]></dc:creator>
            <pubDate>Sun, 14 Sep 2025 10:09:28 GMT</pubDate>
            <atom:updated>2025-09-14T10:09:28.350Z</atom:updated>
            <content:encoded><![CDATA[<h3>Primitives — Tactical DDD with typescript</h3><p><em>Do you use primitives a lot in your code? Have you wondering sometimes what exactly was passed to a function when debugging?</em></p><figure><img alt="Typescript code used in the article as an image" src="https://cdn-images-1.medium.com/max/668/1*T3KKeyg3dMQHSEiep5kHbg.png" /></figure><h4><em>This article is part of the Tactical DDD with Typescript series</em></h4><ul><li><em>01 — Primitives</em></li><li><em>02 — Value types</em></li><li><em>03 — Entitites</em></li><li><em>04 — Aggregates</em></li><li><em>05 — Repositories</em></li><li><em>06 — Data contracts</em></li></ul><h3>Let’s discuss about primitives</h3><p>In order to have a more expressive code from a domain point of view and to reduce possible mistakes, avoiding using primitives helps a lot.</p><p>The idea to not mix strings or integer for different things, will reduce the possible confusion in the code base.</p><p>When you manipulate two different entities with uuid identifiers for instance, you might end up passing the identifier from one entity to a function accepting another. As both types are the same, strings in this case, the compiler will not help you identifying the issue.</p><h3>Using primitives</h3><p>Primitives usage in typescript</p><pre>export type user = {<br> id: string<br> info: string<br>}<br><br>export type comment = {<br> id: string<br> info: string<br>}<br><br>const addComment({ id, info}, { id: string, comment: string})<br>{<br> // create a comment<br>}<br><br>const customer = { id: ‘1’, info: ‘new customer’}<br>addComment(customer) // the compiler will not catch the problem</pre><h3>Branded types</h3><p>To make the compiler your friend in typescript you can leverage branded types instead of using primitives.</p><p>Example with branded types</p><pre>type CustomerId = string &amp; { __brand: ‘customerId’ }<br>type CustomerInfo = string &amp; { __brand: ‘CustomerInfo’ }<br><br>export type Customer = {<br> id: CustomerId<br> info: CustomerInfo<br>}<br><br>type CommentId = string &amp; { __brand: ‘CommentId’ }<br>type CommentInfo = string &amp; { __brand: ‘CommentInfo’ }<br><br>export type Comment = {<br> id: CommentId<br> info: CommentInfo<br>}</pre><p>When writing function you’ll be able to be more specific and expect only CommentId for instance.</p><pre>const addCommentSafe = ({ id, info }: { id: CommentId; info: CommentInfo }) =&gt; {<br> console.log(`Adding comment ${id} about ${info}`)<br>}<br><br>const safeComment = {<br> id: ‘c1’ as CommentId,<br> info: ‘This is a comment’ as CommentInfo,<br>} satisfies CommentSafe<br><br>addCommentSafe(safeComment)<br><br>export const safeCustomer = {<br> id: ‘123’ as CustomerId,<br> info: ‘Some info’ as CustomerInfo,<br>}<br><br>addCommentSafe(safeCustomer) // compiler will identify that it’s not a comment here</pre><h3>Generic branded types</h3><p>Using branded types can be simplified with generic types. The usage of Guids is a good example.</p><p>In our example, both customerId and commentId could be uuid and written like this</p><pre>type Guid&lt;T&gt; = string &amp; { __guid: T }<br><br>type CustomerId = Guid&lt;’CustomerId’&gt;<br>export type CustomerWithGuid = {<br> id: CustomerIdGeneric<br> info: CustomerInfo<br>}<br><br>type CommentId = Guid&lt;’CommentId’&gt;<br>export type CommentWithGuid = {<br> id: CommentIdGeneric<br> info: CommentInfo<br>}</pre><p>At usage, branded types add complexity at initialization, you need to use the `as` keyword to tell typescript which type is a value. It might be harder to read for some people.</p><pre>const safeComment = {<br> id: ‘c1’ as CommentId,<br> info: ‘This is a comment’ as CommentInfo,<br>} satisfies CommentSafe</pre><h3>Zod</h3><p>If you don’t know what zod is, please have a look at their documentation <a href="https://zod.dev/">https://zod.dev/</a></p><p>Here is how to implement the zod schema definition from our previous types.</p><pre>const CustomerIdSchema = z.string().brand&lt;’CustomerId’&gt;()<br>export type CustomerId = z.infer&lt;typeof CustomerIdSchema&gt;<br><br>const CustomerInfoSchema = z.string().brand&lt;’CustomerInfo’&gt;()<br>export type CustomerInfo = z.infer&lt;typeof CustomerInfoSchema&gt;<br><br>export const CustomerSchema = z.object({<br> id: CustomerIdSchema,<br> info: CustomerInfoSchema,<br>})<br>export type Customer = z.infer&lt;typeof CustomerSchema&gt;<br><br>const CommentIdSchema = z.string().brand&lt;’CommentId’&gt;()<br>export type CommentId = z.infer&lt;typeof CommentIdSchema&gt;<br><br>const CommentInfoSchema = z.string().brand&lt;’CommentInfo’&gt;()<br>export type CommentInfo = z.infer&lt;typeof CommentInfoSchema&gt;<br><br>export const CommentSchema = z.object({<br> id: CommentIdSchema,<br> info: CommentInfoSchema,<br>})<br>export type Comment = z.infer&lt;typeof CommentSchema&gt;</pre><p>At this time, writing zod schemas looks more complex than writing pure typescript types. For this example it’s true. You need to write much more code for the same result. For each schema you need to infer the typescript types and the readability of the code is much more complex.</p><p>We will see in the next articles what zod will brings us.</p><pre>const addCommentZod = ({<br> id,<br> info,<br>}: {<br> id: ZodCommentId<br> info: ZodCommentInfo<br>}) =&gt; {<br> console.log(`Adding comment ${id} about ${info}`)<br>}<br><br>addCommentZod({<br> id: CommentIdSchema.parse(‘c1’),<br> info: CommentInfoSchema.parse(‘This is a comment’),<br>})</pre><p>But at usage, zod is giving us the parse function. By using it you will be sure that your code is type safe and validated against the schema you described.</p><h3>Conclusion</h3><p>Here we saw that there are many ways to avoid using primitives and make the compiler your friend while coding.</p><p>This will help you to trust the compiler more when coding and reduce debugging (or console.log) to be sure you are using the right types with the right values.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=345e78d9feb7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The planning trap]]></title>
            <link>https://medium.com/@pierrickblons/the-planning-trap-96a4bb6396d0?source=rss-b790a40e2e97------2</link>
            <guid isPermaLink="false">https://medium.com/p/96a4bb6396d0</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[product-team]]></category>
            <category><![CDATA[sociotechnical-system]]></category>
            <category><![CDATA[systems-thinking]]></category>
            <dc:creator><![CDATA[Pierrick Blons]]></dc:creator>
            <pubDate>Wed, 21 Feb 2024 21:17:21 GMT</pubDate>
            <atom:updated>2024-02-22T10:34:00.977Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This article is a follow-up of our exploration into </em><a href="https://medium.com/@pierrickblons/the-fallacy-of-sacrificing-quality-to-build-stakeholder-trust-a8b38f475e7b"><em>The fallacy of sacrificing quality to build stakeholder trust</em></a><em>.</em></p><p>In the previous article, we highlighted some retroactive loops that intensify pressure when sacrificing quality. Here, we delve into systems thinking and its application to our product team under high pressure.</p><p>We will model the stakeholder system to understand why organization can sometimes have a Pavlovian reaction of creating more planning.</p><h3><strong>Understanding system boundaries in systems thinking models</strong></h3><p>Before digging into the sources of pressure, it is crucial to investigate the concept of system boundaries. Donella Meadow explains the boundaries as follows in Thinking in Systems, a primer.</p><blockquote>Boundaries are of our own making, and they can and should be reconsidered for each new discussion.</blockquote><blockquote>Donella Meadow, Thinking in Systems</blockquote><p>When employing systems thinking to discuss a problem, like here about the pressure on product team, we must establish boundaries within the system. Trying to model all those interactions would result in a gigantic and overly complex model.</p><p>If you are familiar with Domain Driven Design (DDD), you can think of bounded contexts, it is very similar. The goal of bounded contexts is to set boundaries for the model you are designing. This will protect you from designing a too wide and complex model. The same applies for systems thinking.</p><p>Finding the appropriate boundary for your model requires experimentation and iteration. Do not be afraid to practice and redraw many models. Moreover, it is important to recognize that any systems thinking model is highly subjective, reflecting the modeler or the group of modelers way of seeing the problem. Forming a diverse group or seeking feedback outside helps mitigate biases and identifies potential blind spots.</p><h3><strong>Exploring the stakeholder system</strong></h3><p>Now, let’s return to our examination of the stakeholder system. Why do they exert pressure on teams?</p><p>In good faith, stakeholders aim to satisfy customers and improve the organization’s efficiency. This could be anything like improving EBITDA, raising funds, practicing golf… Let’s start building our model from this.</p><p>We can directly correlate business efficiency with stakeholder trust in the teams. As the organization produces more value, the trust in the teams increases.</p><p>To make the diagram easier to read, the team system described in the previous article is shown as a cloud.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/716/1*wKgQA3AQMxJ_8C5i-rjGmQ.png" /><figcaption>Business efficiency as a starting point in the stakeholder model</figcaption></figure><p>However, when issues arise, there is a surge in customer complaints. CxOs phones start ringing. Stakeholders find themselves managing those concerns. This consumes time that could instead be dedicated to run the business more efficiently.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/729/1*jAzdr6TB6SUxYJzcbPe6NA.png" /><figcaption>Direct calls to stakeholders are usually from VIP customers</figcaption></figure><p>The support team will be impacted as well. The number of newly created support tickets is rising too. The support is overwhelmed by the workload. They start involving their management to be sure things are under control within the organization. As for the direct calls, the stakeholders’ time will be used to address those concerns.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nIyfSTfRbHzBtEpSc4au8A.png" /><figcaption>The support team feedback loop</figcaption></figure><p>Let’s reintroduce our previous model of the team system. As now effects will propagate to it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mrLBpgyJfhnbmC6pCD8jsA.png" /><figcaption>The stakeholder and the team system model</figcaption></figure><p>Consequently, the support staff and management will handle the issue directly with the product teams to ensure the right actions are prioritized. This results in product team spending time synchronizing with the support team impacting the capacity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PrK-DAlKJuIoyyt6HnaO2Q.png" /><figcaption>Collaboration between support and product team</figcaption></figure><p>Trust in the team diminishes quickly as the direct calls, support teams and middle management has to involve the stakeholders. Now they can look at the product teams low quality delivery to get some explanations why customers are complaining so much.</p><h3><strong>Model simplification</strong></h3><p>Having model this dynamic, let’s simplify our model focusing on the link between Stakeholder trust and user satisfaction. All the effects involved can be summarized to this:</p><p><em>The more your stakeholders trust the team, the more users will be satisfied and vice et versa.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/386/1*b7c7nxNdU47UhdkkKN8o-g.png" /><figcaption>Stakeholder trust in the product teams directly impacts user satisfaction</figcaption></figure><p>This illustrates another important aspect of systems thinking models. You can have different levels of zoom into a model. As for the boundaries, you need to find the right zooming level to help the discussion.</p><p>Do you think you could convince with this simple model any CxOs? Telling them to fully trust their teams in difficult moments because it will make their users happy. I guess not. That is why it is important to explain and share your model to illustrate the effects in detail before jumping to this kind of conclusion.</p><p>Unfortunately, sometimes this virtuous path is not the one stakeholder are following and they can ask a simple question that can worsen the situation.</p><p>When the bug will be fixed? Can the team commit to a specific date by estimating the time to fix the issues?</p><h3><strong>The more planning reaction</strong></h3><p>Why are they asking about specific date or a bug fix or a specific feature?</p><p>One of the goals could be to introduce delay into their feedback system. By telling customers that the bug will be fixed next Monday, stakeholders are buying time to handle the issue within the organization. But you might expect a rippling effect. If the situation is not fixed by the announced time, customer non satisfaction will reach even higher levels.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/623/1*Y_6o7_QSdjEENm-qfF0UmA.png" /><figcaption>How the numbers of calls respond to the introduction of a delay in the system, like telling the customer it’s going to be fixed on Monday</figcaption></figure><p>With this strategy, the stakeholders can redirect their attention to the product teams by questioning why the team failed to improve the situation with the latest deployments.</p><p>The misunderstanding originates from the fact that the team was delivering new features quickly. And it’s now failing to make a single change without making the situation worse for everyone. The users are not satisfied, the team is under high pressure and the management is trying to elaborate plans to make things better for everyone.</p><p>As Mary Poppendieck explains in her presentation “Tyranny of the ‘The Plan’”, they are trying to control the future.</p><blockquote>One the reasons why we schedule is to control the future, to make things happen at a certain point in time. But the problem is we know that detailed schedules are deterministic, we’ve rolled them up from a work breakdown structure and they don’t allow for variation.</blockquote><blockquote><em>Mary Poppendieck, </em><a href="https://chrisgagne.com/1255/mary-poppendiecks-the-tyranny-of-the-plan/"><em>The tyranny of ‘The Plan’</em></a></blockquote><p>Trying to control the future through planning is the usual response in this case. The stakeholders will ask for more commitments from the product team, aka strict deadlines. The middle management will be asked to track the team’s plans for the next weeks. Building a detailed schedule to be able to announce a ‘realistic’ resolution time to customers.</p><p>Predicting when things are going to happen, is the second reason Mary Poppendieck’s highlights:</p><blockquote>Why we schedule is to predict when things are going to happen. It would be nice to know. It’s kind of important sometimes. Then again, we know that when you base schedules on experience […] then they’re reliable.</blockquote><blockquote><em>Mary Poppendieck, </em><a href="https://chrisgagne.com/1255/mary-poppendiecks-the-tyranny-of-the-plan/"><em>The tyranny of ‘The Plan’</em></a></blockquote><p>She admits that it is important to make a plan. But the main point is that you have to base a plan from experience to make it kind of reliable. In this context the team is unfortunately in a place where it can’t rely on its experience. The bugs are still not fixed, or the features are not covering the entire needs required by the customer. So, designing a rigid plan in this case is simply trying to elaborate a plan to please the management. It will most likely not be achieved and will impact stakeholder’s trust in the team even more .</p><p>The other important impact for the team is to spend more time working on this unrealistic plan which will reduce its capacity and increase context switches.</p><p>Continuing to deliver high quality software will become even harder for the team. The capacity is drained by planning activities (add some daily synchronization meetings here, building a powerpoint to communicate effectively the plan…) and the pressure ultimately increases.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*STsqH3xZBAAe8fTL2ajqbg.png" /><figcaption>More time spent on planning to give visibility for the coming weeks</figcaption></figure><h3><strong>How to overcome this challenge?</strong></h3><p>Now the reinforcing feedback loops are blocking the team making progress. The group is demotivated and will not be able to deliver anything quickly. At this time, the team might completely give up. The management might want to bring external consultants in or have to replace team members. The time to market is not even a question anymore. If the business survives here, hopefully, the time for being able to ship something is a question of months not weeks.</p><p>Which leverage point can we see in the model to mitigate the problem?</p><p>Capacity.</p><p>What is impacting the capacity in this model? Planning and prioritization activities as well as dealing with bugs. As the bugs are quite out of control now, we cannot really do anything about it. The principal candidate is to reduce the planning and prioritization activities.</p><p>So, giving some slack to the team so it can focus on what is the most critical to do right now. It is to bring the product back on track to delivering changes. Reducing the work in progress, tackling one issue at a time. You might not want to completely remove all the prioritization work because if you don’t fix the right issues then it’s a bad usage of already scarce development time. As always, it’s a tradeoff to find the right balance here.</p><p>In the end it really is about trusting the team to do its job.</p><p>But this will work if the team is able to produce high quality software. Maybe at the same time, the team is trying to tackle other challenging sociotechnical matters like:</p><ul><li>High coupling in the product.</li><li>Onboarding a new teammate.</li><li>Broken testing strategy.</li><li>Learning new technology.</li></ul><p>and more…</p><p>With these insights, hopefully, the team now has the capacity to focus on the most impactful fixes or features improvement. We are ready to dig into the internal challenges of the product team which can affect the quality.</p><h3><strong>Do you want to practice systems thinking?</strong></h3><p>There are plenty of other loops we can think of in the stakeholder system.</p><p>You can try to include the sales or a partnership team? How are they affected? How will they impact the described system above? Or integrating the communication aspects with social media for instance.</p><p>Feel free to share in comment or on <a href="https://fosstodon.org/@pierrickblons">mastodon</a> your results.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96a4bb6396d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The fallacy of sacrificing quality to build stakeholder trust]]></title>
            <link>https://medium.com/@pierrickblons/the-fallacy-of-sacrificing-quality-to-build-stakeholder-trust-a8b38f475e7b?source=rss-b790a40e2e97------2</link>
            <guid isPermaLink="false">https://medium.com/p/a8b38f475e7b</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[product-team]]></category>
            <category><![CDATA[quality-software]]></category>
            <category><![CDATA[systems-thinking]]></category>
            <dc:creator><![CDATA[Pierrick Blons]]></dc:creator>
            <pubDate>Wed, 07 Feb 2024 12:28:53 GMT</pubDate>
            <atom:updated>2024-02-21T21:19:51.842Z</atom:updated>
            <content:encoded><![CDATA[<p>Have you ever experienced high pressure on your team?</p><p>I guess at some point you had to handle pressure at least from stakeholders. But what do product teams can do to cope with it?</p><p>Usually this will drive teams to make decisions that prioritize short-term gains over long-term sustainability. However, the seemingly innocuous act of sacrificing quality to rebuild the trust and let the pressure cool down on the team can have far-reaching and complex consequences.</p><p>Let’s leverage system thinking to explore the dynamics at play when using quality as a leverage point.</p><h4>The easy choice of sacrificing quality</h4><p>One of the easy option to rebuild this trust is for the team to deliver new features quicker. To do so product teams are sometimes forced to reduce the quality of the software.</p><p>Let’s use systems thinking diagram to show this choice. You can read it as the following: the more pressure on the team will bring less quality in the produced software.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/179/1*neMgaf9-jF1_y3Pso7q9-A.png" /><figcaption>More pressure pushing team to reduce quality</figcaption></figure><p>How can you reduce quality?</p><p>There are many ways to reduce the quality of the software to save time and try to push in production new feature quickly such as:</p><ul><li>Unit testing</li><li>General testing practices</li><li>UI/UX</li><li>Performance</li><li>Security</li><li>Design or architecture — increasing the coupling of the system for instance.</li></ul><p>The first quick win is that you will reduce the time to market. Let’s complete our diagram with the time to market. This can be interpreted as : the lesser the quality is, the quicker the time to market will be. Or the other way around the higher the quality the more time it takes to ship a feature.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/439/1*SGNqJwnUmlq_4Yj2Ww38qA.png" /><figcaption>Reducing quality leading to quicker time to market</figcaption></figure><p>This leads to the outcome we are looking for, building more stakeholder trust to reduce the pressure on the team. We just identified our first reinforcing feedback loop in our system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*ENVsYCcu1zqz904jduNimg.png" /><figcaption>The reinforcing feedback loop reducing the pressure on the team.</figcaption></figure><h4>What are the real impacts on the team ?</h4><p>The truth is that real life is more complex than this model. There is never a single loop describing an entire system.</p><p>So what are the other consequences of reducing quality?</p><p>By investing less in unit testing (or other kinds of testing practices) you will reduce the confidence that your code is actually behaving as expected. So now bugs are more prone to appear in your product.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*my2R2qucsRyXSDZIwxN-Hg.png" /><figcaption>Reducing quality will leads to more impactful bugs in production</figcaption></figure><p>So now the team will spend more time fixing bugs which directly impacts the team capacity to work on new features. With less time dedicated to work on new features, the time to market will be longer. We have identify our first balancing loop in the system which will not let the previous model to grow exponentially.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/755/1*uFUivkQsREL9jjfknD-0QQ.png" /><figcaption>Bugs will impact the available capacity of the team to deliver quicker</figcaption></figure><h4>The impact on the surrounding environment and the consequences for the team</h4><p>The more critical bugs will be introduce in the product the more customer will start to complain. This will impact directly the customer satisfaction. And it will eventually leads to calls directly to the CEO or the product team directly.</p><p>That’s another loop impacting the capacity of the team and the time to market ultimately.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/1*wYdSc9VCGyx4XXPbPJMrGA.png" /><figcaption>User satisfaction will impact stakeholders trust</figcaption></figure><h4>Conclusion</h4><p>At this point we identified the consequences of sacrificing quality. Sure it may help in a very short-term to rebuild your stakeholder trust as you will ship new features faster.</p><p>But you will not be protected from the other balancing feedback loops that will kick in the system. As you will produce more bugs this will ultimately impact the team capacity to deliver high quality features at a sustainable pace and increase the pressure from the stakeholders.</p><p>So the challenge is to find the way to write high quality feature at a sustainable pace that will both satisfy stakeholder expectations and ensure customer satisfaction.</p><p>In the next article we will review our current model to explore ways to tackle this challenge. By studying how organizations often react when pressure increase, we will try to spot potential leveraging points for the team to keep the pressure under control.</p><p>You can keep reading on the following article <a href="https://medium.com/@pierrickblons/the-planning-trap-96a4bb6396d0">The Planning Trap</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8b38f475e7b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Discovering F# : Explicit casting]]></title>
            <link>https://medium.com/@pierrickblons/discovering-f-explicit-casting-1a69ece2cecc?source=rss-b790a40e2e97------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a69ece2cecc</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[fsharp]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Pierrick Blons]]></dc:creator>
            <pubDate>Fri, 26 Nov 2021 16:11:07 GMT</pubDate>
            <atom:updated>2021-11-26T16:11:07.936Z</atom:updated>
            <content:encoded><![CDATA[<h3>Discovering F# : Explicit casting</h3><p><em>The “Discovering F#” articles are written while I’m learning F#. The main goal is to write down the different not so obvious way of writing F# code when you are coming from C#.</em></p><blockquote>Disclaimer: I’m still very new to F# so please feel free to comment if you see better ways of doing things described in those articles.</blockquote><p>Today I was using a C# class inheriting from System.Dynamic.DynamicObject class in an F# application.</p><p>So you can write the following kind of code in F#</p><pre>let additionalInformations = AdditionalInformations()<br>additionalInformations?Version &lt;- “V1”</pre><p>or in C#</p><pre>var additionInformations = new AdditionInformations()<br>additionalInformations.Version = “V1”</pre><p>The smart thing with this class is it’s actually build on top of a dictionary and provides explicit cast from Dictionary&lt;string, object&gt; to or from AdditionInformations.</p><p>So instead of working with dynamic objects for performance reason you can simply work with a dictionary and cast it into the AdditionalInformations.</p><p>The code is very similar in both language</p><p>F#</p><pre>let additionalInformations = new Dictionary&lt;string,obj&gt;()<br>additionalInformations.Add(&quot;Version&quot;, &quot;V2&quot;)</pre><p>C#</p><pre>var additionalInformations = new Dictionary&lt;string,obj&gt;();<br>additionalInformations.Add(&quot;Version&quot;, &quot;V2&quot;);</pre><p>And then you can simply cast as you usually do in C#</p><pre>(AdditionalInformations)additionalInformations</pre><p>But I had no clue on how to write this in F#, after reading the <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/casting-and-conversions">https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/casting-and-conversions</a> article it still wasn’t very clear.</p><p>Thanksfully I’m surrounded by F# gurus so I quickly got some help :)</p><p>When inspecting the class definition within the IDE, you get the following description for the explicit cast operators:</p><figure><img alt="Explicit cast operators defined in AdditionalInformations class" src="https://cdn-images-1.medium.com/max/1024/1*MzmoBVOjRsaGg6M9K_zrrw.png" /></figure><p>And instead of looking for a way of doing it the C# way, it was down to use the actual function from the AdditionalInformations type.</p><p>So you can write the following F# code:</p><pre>AdditionalInformations.op_Explicit additionInfo</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a69ece2cecc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Playing around with Entity Framework 7 and ASP.NET5]]></title>
            <link>https://medium.com/@pierrickblons/playing-around-with-entity-framework-7-and-asp-net5-ec5a5d8de549?source=rss-b790a40e2e97------2</link>
            <guid isPermaLink="false">https://medium.com/p/ec5a5d8de549</guid>
            <category><![CDATA[entity-framework]]></category>
            <category><![CDATA[aspnet5]]></category>
            <category><![CDATA[dotnet]]></category>
            <dc:creator><![CDATA[Pierrick Blons]]></dc:creator>
            <pubDate>Tue, 29 Dec 2015 21:35:18 GMT</pubDate>
            <atom:updated>2015-12-29T21:35:18.137Z</atom:updated>
            <content:encoded><![CDATA[<p>It’s always an adventure to dig into new piece of technology. Especially when it’s still being built.</p><p>Thankfully Microsoft has moved to the open source most of it’s new development so you can get deep into the source code to understand how things are working.</p><h4>Naming convention</h4><p>Right now the CoreClr is changing names. If you had previously created a class library project you should have ended up with frameworks names like that in the project.json</p><pre>  &quot;frameworks&quot;: {<br>    &quot;dnx451&quot;: { },<br>    &quot;dnxcore50&quot;: { }<br>  }</pre><p>And now if you create a new project you’ll get this</p><pre>&quot;frameworks&quot;: {<br>  &quot;net451&quot;: { },<br>  &quot;dotnet5.4&quot;: { }<br>  }<br>}</pre><p>Those little changes are messing up almost everything, from the xunit runner to some other references. So I decided to wait a little before migrating everything. I don’t want to loose all my integration and unit test.</p><p>The thing is that the same thing is going on with Entity Framework 7. If you follow most of the current documentation it will tells you to add the reference to</p><pre>&quot;dependencies&quot;: {<br>  ...<br>  &quot;EntityFramework.SqlServer&quot;: &quot;7.0.0-rc1-final&quot;<br>},</pre><p><em>Source: </em><a href="https://github.com/aspnet/Docs/blob/1.0.0-rc1/mvc/tutorials/mvc-with-entity-framework.rst"><em>https://github.com/aspnet/Docs/blob/1.0.0-rc1/mvc/tutorials/mvc-with-entity-framework.rst</em></a></p><p>But the reality is that you have to reference EntityFramework.MicrosoftSqlServer because the previous package has been renamed after the beta8.</p><p>So if you start to split your different layers into multiple class libraries be careful when referencing EntityFramework 7 because you might end up with intellisense telling you to use methods which throw compilation errors… (Sorry forgot to get a screenshot).</p><h4>EntityFramework Commands</h4><p>After sorting this out, let’s have a look to the new dnx commands for Entity Framework.</p><p>If you’ve read carefully, you’ll notice that I’ve split my layers in different class libraries. Basically I’m using the usual DataAccess for the DbContext and the Model for my entities, then I have my API project to expose REST APIs. (And few more like Services, Repositories not useful for the current discussion…)</p><p>The idea is to have also the Migrations in the DataAccess class library.</p><p>So let’s popup a beautiful command line and run ‘dnx ef’</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/552/1*ZlPxqtzs2iN3X34iFpBv2Q.png" /></figure><p>The the first idea was to run the add migration from the DataAccess project. Unfortunately this is not going to work as the ‘dnx ef migrations add’ command will rely on the Startup.ConfigureServices method.</p><p>You might endup with the error: “No DbContext was found. Ensure that you’re using the correct assembly and that the type is neither abstract nor generic.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*MTUoK-g6xs9DTNpPyiv5Zg.png" /></figure><p>So you actually have to install the EntityFramework commands to the API project. Then running your ‘dnx ef migrations add &lt;MigrationName&gt;’ with the -p options. You simply have to give to the -p option the name of your DataAccess project. And you’ll get the nice confirmation message</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/440/1*9Hymo_lSZ7ZkyN3VD_iOrw.png" /></figure><h4>Conclusion</h4><p>If you are playing around with EF7 I strongly recommend browsing on the github project page. Bricelam from Microsoft is really active there and you’ll find very precious information.</p><p>Useful links:</p><ul><li><a href="https://github.com/aspnet/EntityFramework">aspnet/EntityFramework</a></li><li><a href="http://www.bricelam.net/">Brice&#39;s Blog</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec5a5d8de549" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying ASP.NET5 to Azure Web App]]></title>
            <link>https://medium.com/@pierrickblons/deploying-asp-net5-to-azure-web-app-676dc61a5171?source=rss-b790a40e2e97------2</link>
            <guid isPermaLink="false">https://medium.com/p/676dc61a5171</guid>
            <category><![CDATA[aspnet5]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[azure]]></category>
            <dc:creator><![CDATA[Pierrick Blons]]></dc:creator>
            <pubDate>Mon, 28 Dec 2015 21:12:30 GMT</pubDate>
            <atom:updated>2015-12-28T21:18:39.308Z</atom:updated>
            <content:encoded><![CDATA[<p>I’ve been playing around continuous integration and deployment with Visual Studio Team System with ASP.NET5 projects.</p><h4>Context</h4><p>As I don’t want to spend too much money on fancy App plan with multiple slots, I’ve set up two service plans one for production with a custom domain and one for testing purpose with no custom domain.</p><p>First of all before going further, I still haven’t spent some time on the Release tab which might have some other ways to achieve that. If you used it for ASP.NET5 applications feel free to share your results!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/365/1*j-0ntbEsLY6MWKipvu7nqQ.png" /><figcaption>New release tab on VSTS</figcaption></figure><p>So I’m sticking to the only resource available so far</p><p><a href="https://msdn.microsoft.com/en-us/Library/vs/alm/Build/azure/deploy-aspnet5">Build and Deploy your ASP.NET 5 Application to an Azure Web App</a></p><h4>Issue</h4><p>This worked great for the integration environment.</p><p>When I switch to the production web application then I started to get the following error from webdeploy in the PowerShell step executing PublishAspNet5Website.ps1</p><p>Error Code: ERROR_DESTINATION_NOT_REACHABLE</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/544/1*wvc_dbvqQGYDiJV0gbGFrA.png" /></figure><p>Basically the script wasn’t using the scm URI used by webdeploy.</p><h4>Solution</h4><p>So after looking at the Prebuild.ps1 script, I found a very important comment in the PreBuild.ps1 script</p><pre># get the scm url to use with MSDeploy.  By default this will be the second in the array<br>$msdeployurl = $website.EnabledHostNames[1]</pre><p>By default, indeed it will return the scm at the second position but if you setup a custom domain then it will be in third position.</p><p>So now you know how to fix it!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=676dc61a5171" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>