Programming with Palermo

Code Sample

In this episode, Jeffrey will go through pull requests, which of course come off feature branches. He will walk you through the entire process from creating an issue for a particular change to a code base and then branch from that issue. Working from that branch, he will talk about the sequencing of things- private builds, test-driving a change, etc.

You will learn the process of committing code back into the branch, followed by creating a pull request to help do some evaluations. You will learn the importance of a formal checklist in the evaluation of a pull request

After evaluating, merging, and completing the pull request, you will learn how to look at how the integration builds and operates on the feature branch as well as on the master branch.

Thanks to Clear Measure for sponsoring this sample and episode of Programming with Palermo.

This program is syndicated on many channels. To send a question or comment to the show, email [email protected]. We'd love to hear from you.

To use the private and confidential Chaplain service, use the following Gentleman: 512-619-6950 Lady: 512-923-8178

Code Sample

In this episode, Jeffrey is going to look at the full system acceptance test suite that was created in the last episode and get it running a command line. This will include prepping it to run in a build.

You will begin by making it possible to run your private build on your local workstation by running click-to-build dot bat just by running your PowerShell build script. It's great to launch the application locally and then go over to in-unit or ReSharper or the Visual Studio test runner and run the test suite, but we want it convenient. We want to make sure it is convenient for the developers on our team. If it is not convenient, developers on the team won't run it all the time. We want the developers on our team to run it all the time. This is done by making it a single command or a single DoubleClick.

Thanks to Clear Measure for sponsoring this sample and episode of Programming with Palermo.

This program is syndicated on many channels. To send a question or comment to the show, email [email protected]. We'd love to hear from you.

To use the private and confidential Chaplain service, use the following Gentleman: 512-619-6950 Lady: 512-923-8178

Code Sample

In this episode, Jeffrey shows how to implement a Model View Controller pattern in Blazor WebAssembly using the BlazorMVC library.

To recap previous episodes- We've been doing a lot with our sample application, a church bulletin application, that would print bulletins for a church service or project all the events happening at the church on a screen- Bible studies, events, etc. It's a very simple application right now in Blazor WebAssembly.

We've done a lot with the structure of this application. The previous episodes will show you a multi-part series on things like how to implement onion architecture; the proper visual studio solutions structure; automated builds; integration tests; unit tests; the private build. Jeffrey goes through getting the build running as an integration build on both Azure Pipelines and GitHub actions. Be sure to check them out!

In this episode, Jeffrey is going to refactor some of the default templates in a Blazor WebAssembly new project template and he's going to pull out the controlling logic from the view logic. He's going to use a library called Blazor MVC to implement a model view controller pattern into this application so that, as you move forward, you don't end up with super huge Blazor component files that have decision logic and code working with data mixed in the same file as HTML code and CSS code, essentially making the screen look like it's supposed to look.

MVC is a really old pattern and if you've never heard of MVC before, do a little bit of research on the history of the model view controller pattern going back to the 1970s. This episode assumes you have some knowledge of the pattern. You will learn how to pull out the logic that works with data and decision tree logic. You will learn how to separate controllers from views and see how that's implemented using the Blazor MVC open source library that's available on NuGet.

Thanks to Clear Measure for sponsoring this sample and episode of Programming with Palermo.

This program is syndicated on many channels. To send a question or comment to the show, email [email protected]. We'd love to hear from you.

To use the private and confidential Chaplain service, use the following

Gentleman: 512-619-6950 Lady: 512-923-8178

Code Sample

In this episode, you're going to take a dive into using selenium for full system testing or acceptance testing, sometimes those two words get interchanged. This is an important type of test for pretty much any application. In test-driven development, you have different layers of testing, just like an onion architecture you have different layers of code. You have the inner code and then you layer on additional code to the outside as you get closer to interfaces. The same thing in testing, you have unit tests, which test your core and every method of every class. You should have a unit test that doesn't depend on interfaces, doesn't depend on external dependencies. You have integration tests that make sure that every one of these interfaces does work with the outside world, whether it be a database or a web service, you want to make sure that your application knows how to call those interfaces. Those are integration tests.

Unit tests don't call outside of their own memory spaces or their own process. Integration tests do call from your application process to some other process. The simplest form is just your code calling a database.

Full system tests take all the pieces of the application and the dependencies that you interface with. It runs the complete application and executes a particular feature or function. In this episode, you're going to take that style and add on to the example we've been using in previous episodes and add a selenium test. We will talk about the ins and outs of full system acceptance testing using selenium. Selenium is just a tool. What's important is that you know how to create these full system tests that run an application just like they're intended to be run in production. Whatever the method of using the application is, you need full system tests that cover everything that is to be supported. If it is a screen used by users, you must pop open the screens and touch them. If data comes from place A to place B in your system, you will design a full system test that runs that to make sure that it works. This is going to be super quick, drinking from the fire hose, but after this, you are going to be able to add Selenium to your application and start creating full system tests- technical type tests or acceptance tests that are more user scenario based.

Thanks to Clear Measure for sponsoring this sample and episode of Programming with Palermo.

This program is syndicated on many channels. To send a question or comment to the show, email [email protected]. We'd love to hear from you.

To use the private and confidential Chaplain service, use the following

Gentleman: 512-619-6950 Lady: 512-923-8178

Code Sample

In this episode, Jeffrey is going to finish the Onion Architecture series with .NET 6. This is the culmination of a 6-part series creating, from scratch, a .NET 6 application using Onion Architecture. It's been built up starting with the core, the private build, a continuous integration build, unit tests, and integration tests. An interface to the SQL server database has been added on and then capped off with a Blazor WebAssembly application. This series will finish with refactoring dependency resolution. Making sure the references are correct from one project to the other is very important with Onion Architecture.

Project references are really important! You don't want to accidentally have any interfaces referencing other interface projects. Every major interface gets its own project because the Onion Architecture is not for tiny applications. If you have a tiny application, then just create one project, and put it all in there and you're done. Onion Architecture is for applications where the code base is going to grow. You're going to have multiple people on the team, and you want it to be obvious which project code goes into it. You don't want to have IntelliSense suggesting the use of certain classes; objects, APIs, interfaces, etc., that are not appropriate to put in certain places therefore we break it out into projects.

We have intentional project references and then it forces us to stay true to the architecture that we decided we were going to go after. This episode will add the Lamar IOC container project and introduce the health check service APIs. This will introduce a project to start things up, make sure everything's factored in its own place and then clone the repository, run the private bill, open visual studio, run the project, and by the end of it, you can use this code as a skeleton for any of your applications. If you're using .NET 6 Blazor WebAssembly or SQL Service Entity Framework, it has a power shell. In previous episodes, you can learn how to get it running on Azure pipelines and GitHub actions.

If you have any questions or comments for the show, please email [email protected]

Thanks to Clear Measure for sponsoring this sample and episode of Programming with Palermo.

This program is syndicated on many channels. To send a question or comment to the show, email [email protected]. We'd love to hear from you.

To use the private and confidential Chaplain service, use the following Gentleman: 512-619-6950 Lady: 512-923-8178

Code Sample

In this episode, Jeffrey is going to cap off the basic Onion Architecture implementation on .NET 6 by adding to the application a Blazor user interface in the simplest way, to can see how the core of our Onion Architecture structure is created and then add interfaces. First, with an interface to a database. Second, with an interface to a person.

Interfaces are added in the same manner, but the user interface is typically added last because the rest of the structure needs to get up and running first and then wire it in. Interestingly, in .NET UI projects, typically the UI project also has responsibility for starting up the application, which is a very, explicit responsibility.

It is important to be aware of two responsibilities here. When adding a project to visual studio, the first responsibility is to start up the application, regardless of what it does. The second responsibility is to have an interface for a user, where a human being is actually bringing up a screen, looking at some things that interact, typing in some text boxes, and hitting some buttons. You're responsible for starting up the application and letting the user interact with it. The same thing with a web service API application or even a backend job that just listens for messages coming on a queue. That's the way visual studio tooling is always used and the way the dominant framework works. In Onion Architecture, those are treated differently. You're going to see how to do it and how to make sure not to muddle user interface responsibilities with startup responsibilities.

Thanks to Clear Measure for sponsoring this sample and episode of Programming with Palermo.

This program is syndicated on many channels. To send a question or comment to the show, email [email protected]. We'd love to hear from you.

To use the private and confidential Chaplain service, use the following Gentleman: 512-619-6950 Lady: 512-923-8178

Code Sample

In this episode, Jeffrey is going to dive deeper into using .NET 6 with Onion Architecture or using Onion Architecture and applying it to .NET 6. He is going to build upon the existing application that has been started in previous episodes to create church bulletin software that can print PDFs of the bulletins for a Sunday morning worship service and drive digital signage on a billboard or screen of any kind for the announcements or events happening.

The application has already been mapped with entity framework and now you are going to build upon that to create queries and the actual usage of entity framework. It will have were statements, filtering, and build the data access layer.

You will be watching Jeffrey code and understand how he thinks about things. He intentionally is working sequentially to help introduce helper classes, as they are needed in the application, to understand and see what is being done.

Thanks to Clear Measure for sponsoring this sample and episode of Programming with Palermo.

This program is syndicated on many channels. To send a question or comment to the show, email [email protected]. We'd love to hear from you.

To use the private and confidential Chaplain service, use the following Gentleman: 512-619-6950 Lady: 512-923-8178

Code Sample

In part three, we add data access for the first time. We use an integration test to test-drive the implementation of entity framework and our database migration tool. By the end, we are creating our database schema and writing and reading records with our database. We also are running our integration test suite on our build server both in GitHub Actions as well as Azure Pipelines. Both support a SQL database server locally on the build server.

Thanks to Clear Measure for sponsoring this episode of Programming with Palermo.

This program is syndicated on many channels. To send a question or comment to the show, email [email protected]. We'd love to hear from you.

To use the private and confidential Chaplain service, use the following Gentleman: 512-619-6950 Lady: 512-923-8178

Code Sample

In this episode, you will continue with part two of .NET 6 using Onion Architecture. We laid out the core project, the first unit test, and the private bill and now we will review those builds and get them working on windows images. You will also see the difference between GitHub Actions and Azure Pipelines, the difference in speed when building, and the Yammel format of both.

After that, we will go into documenting and diagramming the architecture for this church bulletin application. It's so important to communicate to future team members what your architectural decisions are and that is why we document, diagram, or sketch out any decisions about how the application will be used, where it is going to be hosted and the structure of the visual studio solution. This is done once at the beginning of a project and then incrementally as architectural decisions are made. This way, anyone else that comes to contribute to the software immediately understands what the overall intent is. You have a vision in your head on day one with a little tiny bit of code then on day two and day three and day four, the vision grows and develops into a full vision for the software that needs to be realized. The communication tool of the vision becomes important for any team member to break it down.

This episode also introduces the two most widely used mechanisms for going from high level down to detailed architecture and design diagrams- Philippe Kruchten's 4+1 View Model and Simon Brown's C4 Model for architectural diagrams.

You will learn PlantUML for creating diagrams that you can save in a Git repository that is a text format. These are similar in a textual format when you make a change to them, you can diff them and you can see them, and they are friendly to pull requests. There's some very simple tooling in VS code that allows us to automatically generate an image diagram from the textual representation that we will go through and use to create the architectural diagrams. You will create five layers of architectural blueprints describing what you're going to end up with as you create this church bulletin application.

Thanks to Clear Measure for sponsoring this episode of Programming with Palermo.

This program is syndicated on many channels. To send a question or comment to the show, email [email protected]. We'd love to hear from you.

To use the private and confidential Chaplain service, use the following Gentleman: 512-619-6950 Lady: 512-923-8178

Code Sample

In this episode, you are going to set up a new code base with .NET 6 using the Onion Architecture pattern. Jeffrey will use some new project things, that might be in preview, from GitHub and see what works right out of the box with GitHub Actions and what might not.

You will be creating a new repository and going through the necessary steps to creating a brand new Visual Studios solution. Using Visual Studio is rarely a one-and-done, perfect application right out of the box. This episode will create the first stage of continuous integration, which is a private build, looking at how to manage namespaces and assembly names, getting project references, and getting the first unit test running against the first class.

You will also set up the core of an Onion Architecture. It won't set up any interfaces with databases or interfaces with a person. This will simply focus on the inner core of the Onion Architecture. Subsequently, future episodes in this series will add on interfaces and dependency injection, managing references going towards the center.

Thanks to Clear Measure for sponsoring this episode of Programming with Palermo.

This program is syndicated on many channels. To send a question or comment to the show, email [email protected]. We'd love to hear from you.

To use the private and confidential Chaplain service, use the following Gentleman: 512-619-6950 Lady: 512-923-8178