Forem: Rafal Pienkowski

My DDD journey

Rafal Pienkowski — Mon, 13 Apr 2020 17:47:34 +0000

Introduction

For some time, I have an interest in the Domain-Driven Desing. In my case, it didn't come from DDD's popularity nor something called CV-Driven development. Trust me or not, I want to write quality software, and I believe that DDD is the right (but the only one) technique to achieve that.

From some time, I want to write something about this technique. I warn you that I don't consider myself as a DDD expert. There are a lot of smarter than me in this business. After all, I decided to describe how is my adventure with DDD looks like. As you can image the cover photo presents how the journey looked like. I want to show my subjective point of view. I want to share things which caused me problems, my failures and some wins. I could be pleasant if I could share your experience with me. It would be rapt if I inspire you or if you could take a lesson from my failures. In the end, Domain-Driven Design is a highly effective technique. In my opinion it worth to make an effort and get familiar with it.

I think that it's not so hard to catch the main idea of DDD. I like the definition of DDD which I have written by Margaret Rouse:

"Domain-driven design (DDD) is a software development philosophy centered around the domain, or sphere of knowledge, of those that use it. The approach enables the development of software that is focused on the complex requirements of those that need it and doesn't waste effort on anything unneeded. The clients of domain-driven design are often enterprise-level businesses."

As you can see, it doesn't seem to be a big deal. In my case, understanding the problem and practising were two different things.
For a long time, I've felt as easy explaining to my colleagues why they should take advantage of DDD, how could it have a salutary effect of their code. As you can probably gather, that didn't equal that I fully understood the DDD itself. Of course, I knew basic concepts, building blocks but joining all dots together is a separate thing.

Books are a solid starting point.

I prefer to learn from books. Especially I like the fact that I can quickly come back to them when I face some problem. There are many publications about DDD. I obliged to start with the canon of literature: Eric Evans "blue book" Domain-Driven Design: Tackling Complexity in the Heart of Software.

That work was groundbreaking. By this position, Eric Evans spread the idea of Domain-Driven Desing. I like the way how building blocks are described there. After the lecture, you should have a solid foundation about them. In my opinion, the examples used to present the application of DDD are quite complicated. Neither printed circuit board nor shipping is not a piece of cake. A reader has to keep in mind that the book's first edition was in 2003. Although the idea didn't change since that time, in later years, new techniques like Event Sourcing came into play. The last thing, which even Evans admitted to, is the composition of chapters. The book starts with tactical DDD, and that leads to a situation where readers don't pay enough attention to the strategic part of DDD. In the end, we have a state when you know building block, but even if you use them in your work, they don't bring any value to the whole solution. Please don't be such a reader. Fortunately, the next position is free of this drawback.

Vaughn Vernon's "red book" Implementing Domain-Driven Design is, in my opinion, the book that should be your first lecture.

It's more up to date (released in 2013). The agile project domain is approachable. I think it's more natural to developers and requires less effort to understand. Vaughn focuses more on strategic design. The book shows how vital strategic DDD is. Bounded contexts and integrations between them widely described. There is an excellent chapter dedicated to Domain Events. At the end of the title, in the appendix, we can find a section devoted to Event Sourcing. I think Implementing Domain-Driven Design, should be at the top of your reading list if you plan to start dive into DDD.

Vaughn Vernon also wrote the Domain Driven Design Distilled. This short title (about 170 pages) purpose was to show the basics of DDD. In my opinion, don't waste your time and money on it.

Last time I read an excellent book by Alexey Zimarev Hands-On Domain-Driven Design with .NET Core: Tackling complexity in the heart of software by putting DDD principles into practice.

This title contains code examples written in C#. I like the way Alexey introduce how to combine DDD with Event Sourcing. I think that is quite a hot topic. First of all, almost every system we try to implement is based on events. Besides that, ES solves the issue related to storing the aggregate roots and entities. It is not a simple task. If you want to save an object into a database, you have to expose its data. That requires the usage of getters, which is in contradiction to the exposing behaviour and hiding structure principle. But there's no such thing as a free lunch. ES requires you to change your mind. You store a sequence of events which allow you to recreate the object, but unlike way you may use to there is the current state of an object serialized in a table. You can take advantage of ES, but please keep in mind that this is connected with higher entry threshold for your colleagues.
BTW "Hands-On Domain-Driven Design with .NET Core" has a dedicated GitHub repository. Although all samples are in C#, I would recommend this position to everyone.

In the next course I am going to read:
Patterns, Principles, and Practices of Domain-Driven Design
and Domain-Driven Design: The First 15 Years. After the lecture, I will be able to tell you something about them.

To sum up, both books give strong basics. Don't kid yourself that after the lecture of them, you become a DDD ninja. You won't. I advise rereading those books after some time once again. If you have some practical knowledge, they will gain even more value for you.

Not only books

Of course, there are other ways of learning, like audiobooks or video recordings from conferences. I don't like audiobooks, but I watched a few of them. In my opinion, that is a good starting point if you consider if DDD is for you. You invest a few hours and gain a quite extensive point of view.

Another alternative is e-learning. For example, there is a whole DDD path on the Pluralsigh. I prefer to learn from books. I didn't take part in any of online course about DDD, so I'm not in a position to tell you anything significant about it. If you have some experience with that form of education, or could you share a helpful online course, please write about it in a comment.

Simple domain

After we've gained the solid theory background, it's the time to get to know our domain. Here is the story which stands behind our system.

"Our company is responsible for supplying the configuration to the clients. First, an operator creates a draft. A draft could go live immediately. It could be scheduled to become go live in the future. That configuration we called planned. Live could be archived. An archive is the final step of each configuration's live cycle.

"Our system should be aware of the author and date when each configuration's stage was reached. Their first names, with the maximum length of 50 characters, enable to identify the authors. Our system allows storing configuration data limited to 250 characters. Our clients don't care about the date's precision. Information about hours, minutes and seconds is useless for them."

I'm aware that the presented story is a distilled version of a real-life scenario. I bet it wouldn't look like when you start working with your business. It usually takes days or weeks to produce a similar description. We don't have that much time.

To make this easier below is an image which shows the live cycle of configuration made with Miro. In my opinion, Miro is a great tool. It's suitable for the documentation. It also enables life cooperation on documents. Miro is a recommendable platform.

The shared understanding

First of all, we need to build a shared understanding of our business. Without proper comprehension, we won't be able to write good software. There is no better way to learn how to business works than by talking to business people. Quite obvious, don't you think. Based on my experience talking is way, way better form of communication than the written form like documentation, diagrams etc. I don't say that documents and charts are wrong. They are handy to build understanding.

We should focus on the language we use. It shortens the distance between domain experts and developers is the foundation of DDD. The best way to achieve this is to talk to each other in the same language. Eric Evans called it "Ubiquitous language". Using the same language avoids misunderstanding. Reflecting business terms in code makes it simpler to maintain. We can forget about translating from a "technical jargon" to a "business terms". Forget about enums, flags, statuses etc. Name those objects like business people are doing on every day.

What I've forgotten is that langue is ubiquitous. It means that not only a business person is allowed to add words to it. It's perfectly fine if a developer proposes a new term. Still, business is the most important, but we as technical people could also help and add throw in one's two cents.

Event Storming

Extracting the domain experts language is challenging. There are many technics which make this process more peaceful. Recently the most popular is Event Storming invented by Alberto Brandolini. You could read Alberto's unfinished book. Don't worry, Alberto follow the Pareto Principle, and the current content of his book is enough to get the idea and perform a workshop. Of course, facilitating such a workshop requires skills and knowledge, but Rome wasn't built in a day. Also, Mariusz Gil has an excellent repository dedicated to the topic. This repo is an Event Storming in a nutshell with many materials and links to external articles.

I read Alberto's book and took part in a 3-day workshop only about Event Storming technique. I conducted some event storming sessions. My experience is that the most interested in facilitating are developers. It was taff to convince business people to take part in it. I talked with many developers, and they said that it's a common issue that business doesn't trust us. "Busines," thinks that this is another fancy developer's pet toy, which doesn't bring any value to them.

Focus on strategy, a tactic will come by itself

Sun Tzu great Chinese general and author of the book: "The Art of War" said:

I bring up this saying to highlight how vital strategic DDD is. We are familiar with our business domain. However, it's description is a little bit shallow. I did it intentionally because I saw similar stories many times, and I think that they omit the most crucial information. In my opinion, we necessarily need to find out functional and non-functional requirements. Such insights are essential to build full understanding and consciously decide about the architecture of our system.

For instance, we could assume that the live configurations should have such features like high availability and low latency. We don't have to care about writes, but reads are crucial. Let's face it, code which is written concerning the DDD rules could not be the best solution. DDD is best when we talk about write operations. DDD ends with a system which is easy to maintain and extend.
On the other hand, it is not optimized for fast reads. Instead of instantiating repository, which loads our the aggregate root, it would be more efficient just to perform a simple SQL query. Maybe the classic relational database wouldn't meet the performance expectations, and you would have to take advantage of Redis with a denormalized data model. BTW, did you think about Command Query Responsibility Segregation CQRS? If your answer is yes, that's good for you. Commands work perfectly with DDD. I'm not going into details about CQRS. Of course, feel free to explore it on our own.

Let's take a closer look at the second example. The business comes to us with a new feature request. The system has to support media attachments like images and media files. That doesn't mean that we should store blob in our domain model. Depending on the business needs, there could exist an invariant saying that regular customers are allowed to add three images, while enterprise customers are can add up to five files. We could add an attachment's identifier to our entity. The module responsible for storing and serving files is a different context. Probably we wouldn't need DDD there. A simple CRUD application will be good enough.

That brings me to a quite common misconception that DDD everywhere. I made that mistake a couple of times. I learnt about DDD, and I saw aggregate roots, entities and value objects everywhere. I'm not saying that code written concerning DDD is slower. No. It doesn't mean any such thing, but undeniably to write this code you need more of your time. That is a big waste. Instead of writing the code which probably will never be changed, you could focus on the crucial part of your's company areas—the areas which bring money to your company and also to you. I've heard that DDD relates to maximum ten-fifteen percent of the whole system.

Last but not least, modelling an aggregate isn't a straightforward task. There is nothing to cheat that you will model the domain in the final shape on the first try. Domain modelling is an iterative process. My advice is not only to focus on the model's sketch on the whiteboard. Recalling the onion architecture domain model is placed in the middle without any dependencies. This implicates that writing some sample code, for instance, some unit tests, is an easy task. We could quickly validate our model and make corrections to it. In my opinion, nighter UI nor an API is required for that. That causes that any changes concern only on a small independent piece of code.

I think that I stop for now. Firstly I want that strategic DDD stick in your mind. Please think about it and don't make my failures. Secondly, it isn't my intention to bore you to death. I plan to focus more on the code itself in the next part of my story. I hope you will be with me.

I will be delighted if you share a story about your DDD journey.

Pictures come from Undraw.

Easy to create .gitignore for the dotnet developers

Rafal Pienkowski — Sun, 01 Dec 2019 19:41:35 +0000

TL;DR Starting from .Net Core 3.0, you can take advantage of the build in the .Net framework gitignore file template just by typing dotnet new gitignore in your terminal.

I assume you are familiar with the idea of a gitignore file. In short words, a .gitignore file is a plain text file in which each line contains a pattern for files or directories to be ignored by the git.

I am a dotnet developer. I don't know if you had this problem, but every time I wanted to create a new repository on the git repository, I lacked the build-in .gitignore file. Russ Hammett made me realize that the GitHub platform has prepared a gititnore file. Interestingly it isn't named C#, CSharp, dotnet. Nope, none of those things. It's called VisualStudio. Quite obvious.Once again thanks Russ.

I like to have a tidy repository without /obj/* and /bin/* objects, or other IDE specific things included. Storing such files is both messy and could be dangerous. For instance, you could forget to clean from those artifacts your super-secret password.

One of the possible solutions was to copy a .gitignore file from one repository to another. Not a very elegant but effective solution. Another option is to use sites like https://www.gitignore.io/.

Today that has changed. The .Net Core 3.0 SDK gives us a hand. I bet you now dotnet new command. It has a lot of parameters like mvc, webapp, or webapi. Starting from SDK 3.0, there is a new parameter gitignore, which creates a dotnet gitignore file.



dotnet new gitignore

The created file is a good starting point. It contains rules for the most popular IDEs like Visual Studio, Rider, Visual Studio Code, and tools like NCrunch, R#, Visual Studio profiler, or StyleCop. Of course, you can add your own rules to it.

There is still missing documentation on the docs Microsoft site, but you can check it on yourself by typing in your command prompt:



dotnet new

and going through the documentation which is attached there. Here is

I think that the online documentation will be completed soon. Meanwhile, you can take advantage of the build-in gitignore feature, and you don't have to copy the file from other repositories.

P.S. Don't forget about other dotnet cli commands and options.

Cheers!

Don't starve your Cookie Monster

Rafal Pienkowski — Mon, 25 Mar 2019 20:52:51 +0000

First of all I want to say a few words about the cover image. I bet almost all of you know a Muppet called Cookie Monster. As well as Cookie Monster doesn't like when there are no cookies, our threads don't like to be blocked.

Work with threads isn't simple. That is quite obvious for everyone who tried it. One of a vast number of issues is an exclusive lock of a given resource which provides us thread synchronization.

The easiest way to synchronize the access to a resource is to use the lock statement on a guard variable. Just like the example below:

var guard = new object();
lock(guard)
{
    // access the critical path
}

If you think that harmless lock couldn't be dangerous, you are wrong. This simple and it might seem an easy way to the threads synchronization may end with a DEADLOCK.

You may ask how this is possible. To understand the problem, we need to dive deeper and understand how the compiler process the code given above.

var guard = new object();
try
{
    Monitor.Enter(guard);
    // access the critical path
}
finally
{
    Monitor.Exit(guard);
}

The lock statement has been replaced with the Monitor.Enter() method. How does this method work? A thread requests the lock on a resource and waits until the access will be obtained. How this can produce a deadlock. Let's take a look at this example of two threads synchronization on two guard variables.

Thread A locks guard X
Thread B locks guard Y
Thread A wants to lock guard Y, but guard Y is locked by thread B
Thread B wants to lock guard X, but thread A locks guard X

Our threads A and B are waiting and waiting until the end of the world just as Cookie Monster is sadly waiting for cookies.

We can prevent this situation by merely using another method from *the Monitor * class. The method is named TryEnter. Why it's so special? It could take as an argument the specified amount of time indicating how long the attempts will be repeated. After the given time thread will proceed further — no more deadlocks.

var guard = new object();
try
{
    Monitor.TryEnter(guard, TimeSpan.FromSeconds(15));
    // access the critical path
}
finally
{
    Monitor.Exit(guard);
}

A good practice is to ensure that the lock is released by calling the Monitor.Exit method on given guard.

I know that the lock statement is shorter than using explicit Monitor.TryEnter method, but the effort devoted to writing some extra lines of code could turn to you on a Sunday evening during the production deploy.

To sum up.

Avoid using the lock statement and start using Monitor.TryEnter. Your threads will be grateful.

All the gifs came from giphy.com.

Doubles can be dangerous

Rafal Pienkowski — Mon, 11 Mar 2019 20:24:52 +0000

Introduction

In my career, I've heard many times:

"Always use the proper data type."

or according to mine.Net experience:

"Never use double to math calculations."

Sounds familiar to you? Do you think it is silly? Do you think you don't care about it? I assume that you've heard similar statements and please don't think that it's only claptrap. If you don't agree with me or you want to know why using doubles is so dangerous this post is made for you.

Simple experiment

Let's start with a simple experiment. Of course, you can do it on your own. Take a look at the following code:

Do you guess how the result will be? Let check this out:

rafpie@Oxygen ~/Desktop/double dotnet run
Math is broken. 0.1 + 0.2 isn't 0.3. That's odd!?!?

Our experiment proofs that math is broken. What!?! That isn't possible. We were taught that 0.1 + 0.2 = 0.3. What the hell is going on here?

The crucial point is how our computer represents doubles. I assume that you're familiar with the number's binary representation if not here is an article about that. TThe representation of 0.1 in the binary model is as follows:

Mostly we focus on the integer part (the left side of the chart), but for now, the right side is more important. To receive 0.1 we have to sum the corresponding powers of two:

1/2^4 + 1/2^5 + 1/2^8 + 1/2^9 + 1/2^12 + 1/2^13+....

Let's sum first six elements:

1/16 + 1/32 + 1/256 + 1/512 + 1/4096 + 1/8192 =0,099975586

As you can see, we received an approximated result. That leads us to the simple conclusion:

Never compare double values with the == operator!

In the best-case scenario, you will miscalculate the high of your quarterly bonus, in the worst-case scenario someone can die. I'm deadpan here. On February 25, 1991 (the Gulf War) an American Patriot missile battery used double values in the calculation. Due to inaccuracy, 28 soldiers lost their lives. More info you can find here.

The solution

You can ask how we can overcome this problem. The answer is to use decimal values. The value with the decimal type is stored as a large integer with the decimal point shifted. That means, 0.1 is stored as 1, 0.123 is stored as 123. If you don't trust me, modify our previous example and change datatype from double to decimal (Notice, you have to add M after the number to indicate the literal decimal value).

The result will be compatible with the expected one:

rafpie@Oxygen ~/Desktop/decimal dotnet run
0.1 + 0.2 is 0.3

Uff, math works.

Summary

I hope that I explained to you why we should be careful with double values. As you can see this could have significant impact correctness of the program's calculations.
I premise on double type built-in the .Net Framework. If someone knows how this problem is addressed in other programming languages, please share that with us.

Note: Background images cames from the pixabay.

Turn VM off and give my money back

Rafal Pienkowski — Mon, 25 Feb 2019 11:18:49 +0000

Introduction

In the previous episode, I get familiar with payment methods and cloud model which are available in Azure. Now I'm going to take a closer look to cost optimization of Virtual Machines (VM), which are in my opinion, the base of IaaS.

Virtual Machine

First of all, you need to know that a "typical" Virtual Machine in the Azure consists of several components:

storage account - is used for backups/snapshots and the disk for the VM
disk - optional disk which could be attached to the VM
virtual machine
network interface - enables the VM to communicate with virtual network
network security group - is used to allow or deny network traffic to the VM

You must keep in mind that "typical" VM is, in fact, a combination of several elements. Why it's so important? Only in the case of VM itself, the fees are calculated for every second it's being used. When the VM is down no charges are applied. So what that gives to us? The answer is simple. Shut down your VM when you don't need it. For instance, if we have a VM dedicated for the dev team. It could be taken down during off hours. I don't mean to go to the Azure portal once or twice a day and doing it manually. Oh no, this isn't my intention. We should automatize our job as far as it's possible. Azure Automation comes with help. You don't have to have expert knowledge to do that. You can do it by clicking in the Azure Portal. The article: Start/Stop VMs during off-hours solution in Azure Automation is an excellent starting point.

The scheduler available in the Azure portal isn't perfect. Available schedule options are one time, monthly, weekly, daily, hourly. It isn't enough to shut down our VM during the weekends or national holidays. Fortunately, we can write our own runbooks and customize the scheduler's behavior. Here is an example. The nice thing is that we can automate the schedule creation as well. To do that we need to use Azure Resource Manager (ARM) template. ARM is a topic for a separate post, so, for now, I'll only give a link to the Deploy an Azure Resource Manager template in an Azure Automation PowerShell runbook article for interested.

So let's calculate possible saving resulting from switching of the VM. For the calculation, I took DS3 V2 VM (O/S Windows), and I assumed that the VM would be running every working day for 13 hours. In an average month has 23 working days, so we have 299 hours. The table below compares the cost of the VM working 24/7 with the VM running only during work hours. In short, we can save more than 200$ monthly.

But what in case, when our VM have to work 24/7? After all, this is not an unusual case. In that scenario, Azure Reserved VM Instances (RIs) comes into play.

How RI works? We are requesting VM for a specific time (one or three years) and paying in advance for it. In the case of DS3 v2 (Windows), VM mentioned earlier, reserving it for one year gives us ~35% savings (~45% when reserved for three years). The exciting part is that taking VM with Linux O/S gives us more benefits (~40% and ~59% respectively).

Other benefits of RI:

VM which is bought in RI doesn't have to work 24/7
we can exchange VM types within RI
VM ordered as Reserved Instance may work longer that RI duration
we can anytime cancel RI order, but we have to keep in mind that Microsoft will charge a fee of 12% of unused funds

For those, who already have a license with the Software Assurance for MS Windows Server or MS SQL Server, Azure Hybrid benefit could be an exciting option. It's based on the bring your own license (BYOL) model. In short, you already have a license which you could use on your on-prem environment. This license could be used in the Azure cloud environment and thereby we don't have to pay twice for the same. The azure Hybrid benefit can save up to 40% of VM's costs.

Summary

That will be all for now. In the next episode, I'm going to focus on components of the Platform as a Service model (App Service and Azure SQL Database).

See you in the next episode.

P.S. All photos used in this post came from unsplash.com.

Azure cost optimization

Rafal Pienkowski — Wed, 20 Feb 2019 15:38:04 +0000

Introduction

I want to introduce by this post a whole series of blog posts covering some tips for the cost optimization which we can apply in the Azure Cloud.

It's possible that you have already implemented all of my suggestions. In that case, good for you! Otherwise, you're still able to become a hero in your company, save some money which you have to pay for Azure's invoices, and spend it for some nice stuff like a new board game in your office or a corporate retreat. Or maybe you've heard that MS Azure solutions can make your software more reliable or code deployment into the Azure's App Service with conjunction with Azure DevOps is much simpler than your current CI/CD process, but after raw cost calculation, your boss declined your suggestion to use Azure because the cost of the cloud is too high? Hmm? Sounds familiar to you? If so, I invite you to read further. Those tips aren't secret knowledge and are easy to implement.

After this lengthy introduction, it is high time for specific advice.
First of all, we need to answer two simple questions. Are you ready? Let's go with the first question.

What licensing model do you have?

Depending on the model you've chosen, you can decrease the monthly cost of Azure. A short recap of available models and their brief description.

Pay-As-You-Go
Most popular one. It's easy to set up. What we only need is an available credit card which will be bounded with our subscription. Every 30 days you will receive an invoice for used resources and necessary funds will be withdrawn from your credit card. You're paying only for used resources. The nice thing is that upgrading from Azure Free Account to PAYG is easy. And that's all. In this billing method, we don't have much room to reduce the cost.
Azure in Open (AIO)
In this model, you're buying scratch cards from Microsoft partner. Each card is worth 100$. AIO is quite similar to the Pay-As-You-Go model. The difference is that you have to pay before we use the resource. We can save some money by buying scratch cards in bulk. Depending on your partner and the number of scratches you want to get you can negotiate the discount. In the AIO model, you have to activate the scratch in three years and use available resources in one year.
Cloud Solution Provider (CSP)
The CSP works like the Pay-As-You-Go model. The main difference is that you're paying directly to the MS partner instead of Microsoft. Worth to mention is that our support tickets are going to the partner instead of Microsoft support.
Enterprise Agreement (EA)
If your solution regularly consumes a significant amount of money (about 17 500 $/ year), you can try to go into the Enterprise Agreement model. In this model, you're buying access to the Azure from Microsoft's Partner. The EA is set up for a one or three year period. You're paying in advance for the given period (of course if you use bought resources before the end of the agreement, you can set up new agreement). Here you've got the greatest opportunities in discount negotiations. An interesting thing is you gain access to the new management portal (https://ea.azure.com/) instead of the classic one (https://portal.azure.com/).

Did you find your licensing model? I hope so. Now it's the time for the second question.

What type of cloud environment are we using?

This is a quite fundamental question. Why? Because depending on the environment, type pricing plan is constructed and going further an invoice is created. Let me do a short recap of available cloud models and how they're related with "traditional" on-premise environment.

Main models:

Infrastructure as a Service (IaaS)
I would say this is model could be treated as the first step into cloud computing. In short words, we're placing our Virtual Machine (VM) image into the cloud. We're responsible for i.a. O/S installation and maintenance required frameworks, runtime installation, and patching, etc. We have to care about many things, but we receive a low entry threshold. We can take our VM image and put it into the cloud. In the context of money saving, we should take a look at Microsoft.Compute pricing plan (we're billed based on the time we use the resource). I'll describe in details in the next episode.
Platform as a Service (PaaS)
In this case, we are partially giving away the responsibility for the preparation and maintenance of our environment. For instance, all things related to the O/S and runtime are no longer our problem. The end with applying patches to our O/S. Now that is our vendor's problem. According to the Service Level Agreement (SLA) vendor ensures the availability of the platform. But we need to keep in mind that in the PaaS model we're losing some influence on the infrastructure itself and we have to adjust our solution to a given platform. According to Azure documentation: "Platform as a service (PaaS) is a complete development and deployment environment in the cloud." An example of such a resource in MS Azure is App Service or Azure SQL Database. Mainly in the PaaS model, we are paying for the whole time when the service is created, even if we are not using it.
Function as a Service (FaaS)
I'd say that this is a specific subset for PaaS. The responsibility for the Data and Application is moved to the vendor. For example, instead of writing a whole application to serve some HTTP request we can use Azure Functions. In that case, Microsoft takes care of the part responsible for calling our function when a request came to the server.
Software as a Service (SaaS)
In the SaaS model, we're purchasing access to software. Excellent examples are Office 365 or Spotify. In short words, we're paying for the ability to use given a program for some time.

Below is the image comparing the mentioned models.

With answers to the two main questions, we're ready for further steps. I hope you are not too bored.

In the next episode, I'll describe how we can save some money consuming cloud in the Infrastructure as a Service model. I'll tell you how to reduce cost working with the Virtual Machines hosted in the Azure.

See you in the next episode!

P.S. All photos used in this post came from unsplash.com.

Microservices by example with DevMentors

Rafal Pienkowski — Tue, 22 Jan 2019 11:04:43 +0000

Introduction

I think that almost everyone has heard about the Microservice Architecture. It isn't my intention to glorify or reprove this architecture's approach. As any solution microservices have their good and bad sites. Let's get familiar with the Microservice architecture to make up our mind. So I came to the heart of the matter. I want to tell you about a project called "Distributed .Net Core - DShop" in brief DShop. It is a project driven by two enthusiasts of microservice's solutions and Microsoft technologies: Dariusz Pawlukiewicz and Piotr Gankiewicz. They are the founders of DevMentors. Why do I think it's worth to mention this particular project? There are a few reasons why people interested in microservices, CQRS, C#, and DDD should take a look at this project (even if you are not familiar with C#, but you know another C-family programming language ex. C++, Objective-C, Java, etc., you would find something interesting for you).

Five reasons why you should get interested in this project:

1) Microservice Architecture is a hot topic

This is my subjective opinion, and I assume that yours too otherwise you wouldn't read my text. I think that microservices as an architectural pattern are interesting. I'm not saying that they are a silver bullet and they can solve any problem, but in my opinion, it's good to know what benefits and what issues are bounded with the Microservice Architecture. The best way is to give it a try, and DShop is an excellent opportunity for that.

2) DShop is open sourced

You can find all the microservices which are taking part in the solution in public Github repositories. Anyone can look over the source code and grab those parts which he or she considers attractive. Of course, the most efficient way of getting to know the project is to contribute. Feel free to make a pull request.

devmentors / DNC-DShop

Distributed .NET Core

What is Distributed .NET Core?

It's an open source project (and a course available soon at devmentors.io), providing in-depth knowledge about building microservices using .NET Core framework and variety of tools. One of the goals, was to create a cloud agnostic solution, that you shall be able to run anywhere.

We encourage you to join our Discourse forum available at forum.devmentors.io.

For this particular course, please have a look at the topics being discussed under this category.

What topics will be discussed?

A lot of them, covering different aspects of building distributed services, whether it comes to implementing the code, managing services discovery and load balancing, configuring logging or monitoring, and eventually deploying to the VM using Docker.

Just to name a few:

RESTful API implementation with ASP.NET Core
Domain Driven Design fundamentals
SQL and NoSQL databases (SQL Server, MongoDB, InfluxDB…

View on GitHub

3) A vibrant community

Dariusz and Piotr are two pillars of the project, but everyone is being invited to the project's contribution. There are several forms to get involved in the project like forum, Gitter or Twitter. Feel free to take the most suitable communication channel for you. You can ask a question to guys or propose a change.

4) An Youtube channel

Honestly, I think that this the most significant feature of the DShop project. Why do I feel so? IMHO it brings the educational value. In each episode, Dariusz and Piotr are explaining the core concepts of a Microservice Architecture by an example. They are making a quick introduction to the problem and solving it before our eyes. Yes, guys are coding and recording at the same time. At the moment of writing this post, seven episodes are recorded. They are listed below:

Episode 1 - Intro, HTTP, requests flow, Infrastructure with Docker
Episode 2 - CQRS - Write side, Discounts service, MongoDB repository
Episode 3 - Subscribing RabbitMQ messages, API gateway
Episode 4 - Asynchronous microservices integration via events
Episode 5 - CQRS - Read side, Internal HTTP communication
Episode 6 - Sevice discovery & load balancing with Consul and Fabio
Episode 7- Handling asynchronous requests, SignalR, Polly

Below is the link to the first episode.

5) DShop is still being developed

The project isn't dead. Dariusz and Piotr are enhancing the project. They are adding new features, refactoring old code, recording new youtube's episodes. I keep my fingers crossed to keep them enthusiastic and continue they work.

Closing

It's obvious that the Microservice Architecture isn't an easy topic. Dariusz and Piotr assumed that average contributor has basic knowledge about Docker and RabbitMq. They don't dive deep into details of those technologies. In my opinion, it's good to get familiar with these tools (especially Docker). With this knowledge, we can focus on the architecture rather than the tool itself. Please don't worry, without the experience in Docker and Rabbit you will be able to understand the main concepts, but it could be a little harder.

The last thing I'd like to mention is that I'm glad there are developers like Dariusz and Piotr which want to share their knowledge with the community. Thanks them for that.

The hidden value of the Value Object

Rafal Pienkowski — Fri, 17 Aug 2018 15:47:45 +0000

Introduction

After my lecture on Vaughn Vernon's "Implementing Domain-Driven Design.", I've decided to write a post which will be connected with DDD and draw attention to the underestimated Value Objects. In my experience, developers are abusing Entities in their projects. Very often that behavior ends with an occurrence of many anemic domain models without or with little business logic. In my opinion, some of the anemic domain models could be quickly transformed into the Value Objects.

Note: All examples are written in C#, and they are using newest C# syntax. I hope they would be easy to understand also for developers who are using different languages.

Example:

Let's start with the simple example of a Car entity like in the code snippet below.

public class Car
{
    /* Properties */
    public string Color { get; set; }
    public bool Metallic { get; set; }

    public string FuelType { get; set; }
    public int EngineCapacity { get; set; }
    { ... }

    /* Methods */
    public void Drive(int distance) { ... }
    { ... }
}

We will focus on properties related to car's color. I mean Color and Metallic property. For simplification, color is represented by string type.

Characteristic of the Value Object:

1) Measures, quantifies or describes the subject of a domain

In our example, Color and Metallic are the best candidates for the Value object. Both are describing the look of the vehicle. So extract the new class:

public class Color
{
    public string Hue { get; set; }
    public bool Metallic { get; set; }
}

Whenever Hue or Metallic changes we receive a new color, so let's go to the next point.

2) Is immutable

Immutability means that object state cannot be changed after it's initialization. In Java or C# this could be achieved by passing all parameters to the constructor of a value object. Based on the values of parameters state of the object will be set up. Of course based on values some additional properties could be calculated.
Notice: The object itself can't call property setters either by the public, nor the private methods. This is forbidden.

Let's enhance our example according to previous thoughts.

public class Color
{
    public Color(string hue, bool metallic)
    {
        Hue = hue;
        Metallic = metallic;
        if (hue == "white" && !metallic)
        {
            BasicPallete = true;
        }
     }

    public string Hue { get; }
    public bool Metallic { get; }
    public bool BasicPallete { get; }
}

In the example above we've calculated the BasicPallete property. For example, it could influence a car's price calculation.

3) Composes linked attribute values into the integral unit

This means that all properties are bounded, and each provides the crucial part of the information which describes the whole value of the object. Individual property value doesn't provide comprehensive information about the object. In our case knowledge about that if a color is metallic or not doesn't give us information about its hue. The same situation is when we know hue, but we don't know if it's metallic or not.

Worth is a perfect example cited often by this point. Let's take 100 USD as an example. Currency and amount are linked together. Let's imagine that someone has changed the currency from USD to MXN (Mexican Peso) in our object. That change has the significant impact. 100 MXN is worth approximately 5.25 USD. Oneone wants to be a victim of such a small change.

4) Is replaceable in the situation when the measurement changes

In our case car is an entity and color is a value object in our domain. Someday we decide to change the color of our car. Let's say we've bought a green non-metallic vehicle, but after a few years, we want to have a green metallic one. We cannot just add metallic gloss to existing painting. We need to repaint it with the new green metallic paint.

Color color = new Color("green", false);
//color.Metallic = true;  -> This is not allowed

color = new Color("green", true);

5) Could be compared with other value objects

In languages like C# when we try to compare two objects by default, the comparison covers the location in memory of two objects (called Reference Equality). Two objects can have the same property values, but the will not be equal. This is the wrong assumption regarding the Value Objects. In that case, we need to have equality of given type and all property values (called Value Equality).

According to our example, two colors are the same if they have the same hue and are metallic or not. Two cars which are green and metallic have the same color.

So let enhance our class and implement the Value Equality:

public class Color
{
    public Color(string hue, bool metallic)
    {
        Hue = hue;
        Metallic = metallic;
        if (hue == "white" && !metallic)
        {
            BasicPallete = true;
        }
    }

    public string Hue { get; }
    public bool Metallic { get; }
    public bool BasicPallete { get; }

    public override bool Equals(object obj)
    {
        return this.Equals(obj as Color);
    }

    public bool Equals(Color otherColor)
    {
        if (Object.ReferenceEquals(otherColor, null)) return false;
        if (Object.ReferenceEquals(this, otherColor)) return true;
        if (this.GetType() != otherColor.GetType()) return false;

        return (Hue == otherColor.Hue) && (Metallic == otherColor.Metallic);
    }

    public static bool operator ==(Color leftColor, Color rightColor)
    {
        if (Object.ReferenceEquals(leftColor, null))
        {
            // null == null = true
            return (Object.ReferenceEquals(rightColor, null));
        }
        return leftColor.Equals(rightColor);
    }

    public static bool operator !=(Color leftColor, Color rightColor)
    {
        return !(leftColor == rightColor);
    }

    public override int GetHashCode()
    {
        return (Hue.GetHashCode() * 0x100000) + (Metallic.GetHashCode() * 0x1000) + BasicPallete.GetHashCode();
    }
}

6) Has side-effect-free behavior

This is the fundamental rule. Without it, Value object could be treated as a simple container for attributes. To understand it we should start with understanding side-effect-free function. Function without site effect has a result but doesn't modify its state. Such a function are fundamental in Functional Programming Paradigm.

All methods exposed by a value object should be a function without side effect, which doesn't violate the value object's immutability.

Let's take the car's repainting example. We can achieve repainting by adding such a function to our class.

public class Color
{
    public Color(string hue, bool metallic)
    {
        Hue = hue;
        Metallic = metallic;
        if (hue == "white" && !metallic)
        {
            BasicPallete = true;
        }
     }

    public string Hue { get; }
    public bool Metallic { get; }
    public bool BasicPallete { get; }

    public Color Repaint(string hue, bool metallic)
    {
        return new Color(hue, metallic);
    }

    // Value Equality part
    {...}
}

As we can see, there is a similar effect like in car's repainting case. But the connection between method and value object is stronger and side-effect-free. We don't modify the state of the color object. Instead of that, we've created the new one with demanded values.

Color color = new Color("green", false);
color = color.Repaint("green", true);

Summary

Of course, I didn't cover all topics related to Value Objects, all the more DDD, but I hope this post will inspire you to use it more often in your projects.

P.S.

Please don't go from one extreme to the other.

Do we need standup?

Rafal Pienkowski — Mon, 13 Aug 2018 12:45:31 +0000

Some time ago I read an interesting article about agile methodology made by an engineering lead at Spotify. As we know, agile is a tool which should suit needs of a team. The author of the article has run a six-month experiment and has reduced number of meetings in his agile team.

He has introduced, let's call it "minimal meeting" rule which covers:

No stand-ups
No planning at regular intervals
No retros
All meetings are optional

The article describes the author's motivation which was standing behind his decision, so I don't like to repeat his arguments. You can read it of our own.

My opinion

"Minimal meeting" rule is too extreme for me because I'm working in teams which are located in offices across various locations. In my opinion, enforcing team members to communicate with each other is essential in daily work, and I can't imagine such a free approach to team meetings.

On the other hand, this experiment is an excellent example of how agile the Agile methodology is and how it could be adapted to current team needs.

Let's discuss

I'm extremely curious what is your opinion. Do you think will the "minimal meeting" rule work in your teams? Would you like to perform such an experiment in your organizations?

GitHub & Docker Hub a reasonable marriage

Rafal Pienkowski — Tue, 07 Aug 2018 15:01:10 +0000

Some time ago I posted an article about configuring CI/CD with Wercker.

CI/CD with Wercker

Rafal Pienkowski ・ Mar 9 '18

#productivity #devops #docker #deployment

Now I decided to try out a Docker Hub's automated build functionality. I need to say that I'm positively surprised. It's easy and can be useful in some scenarios.

The option for an "Automated Build" is a bit hidden after "Create" button, but the whole process of creation of a new Docker Hub automated build is easy and can see in the picture below:

Notice: As you can see there is an option to take a Bitbucket repository too.

The process ends with an automated build instead of a repository. Compared to a repository automated build contains more options:

Dockerfile We can see what docker file has been used
Build Details We have the history of our builds. We can also look into details of every build. Additionally, we have a link to the GitHub repository with source code.
Build Settings We can change the image's tag depending on source code branch, trigger build manually or set up a build trigger depending on a tag in the source code.

By default, the build will be triggered after every commit to the master branch on the GitHub. It takes some time to start a build and publish an image into our repository. The whole setup of an automated build ends with proper Dockerfile creation. Dockerfile can be tested on our local machine before we make a commit into the GitHub repository.

In my opinion, copying README.md file from GitHub and pasting it into Full Description in the Repo info tab is the killer feature. I love it.

Does it cover all requirements?

The simple answer is no. Sorry, but in my opinion, the functionality doesn't meet all expectations for a production-ready solution. For instance, we couldn't set up a CI workflow with steps containing build, unit and integration tests and deploy to a repository which is crucial nowadays.

For whom the functionality is dedicated?

I think that for any Proof of Concept (PoC) project, a side project which can be developed separately or in case we need to prepare some dedicated docker images for our use.

Last words

That is my subjective opinion. Feel free to disagree with me. I'm also interested in your opinion especially if you took advantage of that functionality. If you have any other ideas for usage of this functionality, give your suggestion in the comments.

Cheers.

Can you share your favorite quote or rule related to IT?

Rafal Pienkowski — Fri, 08 Jun 2018 08:38:30 +0000

I like quotes and funny rules. A good quote makes our presentation more interesting, draws attention to the presenter and makes the presentation unforgettable. Ridiculous or easy-to-remember rules help us keep in mind essential things.

Below one of my favorites:

Quote

"A language that doesn't affect the way you think about programming is not worth knowing."
Alan Perlis
Rule

"A team shouldn't be larger than what two pizzas can feed."
Jeff Bezos

Now it's your turn to share your quotes and rules related to IT ;)

Poor man's dotnet solution setup

Rafal Pienkowski — Sun, 15 Apr 2018 11:06:02 +0000

Some time ago I started my journey into a Linux with dotnet Core.

Initially, I planned to describe how to set up a working solution, but I've found an article about this here on dev.to. In my opinion. Rui covers almost all important things which I had planned to describe. If you don't know how to start ASP.NET Core Development in Linux, I encourage to read his article. Well done Rui!

Because I have nothing to add in that subject, I've decided to focus on another one. In my previous article some of you've suggested me to use Jetbrain's Rider IDE. Maybe in the future, I'll buy it, especially if I decide to switch from Windows to Linux/iOS. I think that in such case is reasonable to spend about 350$ for an IDE. For now, for my side projects, I'm going to focus on VS Code.

The thing which made me crazy was a project initialization. I fed up with continuous typing of the same command-line commands to set up a new solution. Like every developer, I'm a lazy person.

To avoid doing this boring stuff over and over again, I've decided to write a bash script which will do all that tedious staff instead of me. The source code of it could be found on my GitHub repo.

This script creates a basic solution's folder structure. It initializes main project and dedicated test project. Created test project contains the reference to the main project. It has also referenced two advantageous (at least in my opinion) NuGet packages: FluentAssertions and Moq. It creates sln file which could be beneficial for devs which plan to open the solution via full Visual Studio. In the end, Visual Studio Code will be opened.

Usage:

dotnet-solution [solution-name] [main-project-name] <<template>>

The template is passed to the [dotnet new] command. It will be used to create the new dotnet project based on it. More about templates you can be found under this link.

Example:

dotnet-solution adventure-works AdventureWorks.Common classlib

Solution structure which will be created by the example above. I've intentionally omitted some meaningless folders.

+-- adventure-works
|   +-- src
|       +-- AdventureWorks.Common
|       |   +-- Class1.cs
|       |   +-- AdventureWorks.Common.csproj
|   +-- test
|       +-- AdventureWorks.Common.Tests
|       |   +-- UnitTest1.cs
|       |   +-- AdventureWorks.Common.Tests.csproj
+-- adventure-works.sln

For those who are not familiar with Linux/Unix systems, to add a specific extension to your bash shell you need:

download it to your machine
copy to /usr/bin catalog (admin rights will be required)
make it executable by chmod command (admin rights will be required)

    chmod +x dotnet-solution

Feel free to copy, use and modify those scripts. I'm also open to all your suggestions and propositions. Please keep in mind that was my first steps in bash scripting. I hope it can be handy for you.

Forem: Rafal Pienkowski

My DDD journey

Introduction

Books are a solid starting point.

Not only books

Simple domain

The shared understanding

Event Storming

Focus on strategy, a tactic will come by itself

Easy to create .gitignore for the dotnet developers

Don't starve your Cookie Monster

Doubles can be dangerous

Introduction

Simple experiment

The solution

Summary

Turn VM off and give my money back

Introduction

Virtual Machine

Summary

Azure cost optimization

Introduction

What licensing model do you have?

What type of cloud environment are we using?

Microservices by example with DevMentors

Introduction

1) Microservice Architecture is a hot topic

2) DShop is open sourced

devmentors / DNC-DShop

Distributed .NET Core

What is Distributed .NET Core?

What topics will be discussed?

3) A vibrant community

4) An Youtube channel

5) DShop is still being developed

Closing

The hidden value of the Value Object

Introduction

Example:

Characteristic of the Value Object:

1) Measures, quantifies or describes the subject of a domain

2) Is immutable

3) Composes linked attribute values into the integral unit

4) Is replaceable in the situation when the measurement changes

5) Could be compared with other value objects

6) Has side-effect-free behavior

Summary

Links:

Do we need standup?

My opinion

Let's discuss

GitHub & Docker Hub a reasonable marriage

CI/CD with Wercker

Rafal Pienkowski ・ Mar 9 '18

Does it cover all requirements?

For whom the functionality is dedicated?

Last words

Can you share your favorite quote or rule related to IT?

Poor man's dotnet solution setup