2017-03 on Funky Si's Blog (Dev)

Interfaces

funkysi1701@gmail.com (funkysi1701) — Mon, 27 Mar 2017 20:00:45 +0000

I am trying to understand interfaces and when to use them in my code.

An interface defines a contract and any class that implements that interface agrees to fulfil that contract.

Lets look at an example as this tends to be how I learn best.

Most applications require some sort of data to work from so lets start by defining IData which can load data.

public interface IData
{
 Blog LoadData(string Connectionstring);
}

My interface defines one method LoadData and outputs an object called Blog (I will explain why in a minute)

A common data source is a SQL database so we could define a SQL class that implements IData.

public class SQL : IData
{
 public Blog LoadData(string Connectionstring)
 {
 Blog blog = new Blog();
 using (SqlConnection con = new SqlConnection(Connectionstring))
 {
 con.Open();
 //etc

We could also get data from an RSS feed of a blog (hence why I called the object Blog earlier)

public class XML : IData
{
 public Blog LoadData(string Connectionstring)
 {
 XmlDocument myXmlDocument = new XmlDocument();
 myXmlDocument.Load(Connectionstring);
 Blog blog = new Blog();
 foreach (XmlNode RootNode in myXmlDocument.ChildNodes)
 {
 //etc

Both classes implement IData and have a method called LoadData which has a string parameter and outputs a blog object. The string parameter is either a connection string to a SQL database or the URL of the rss feed. Not sure if there is a better way of doing this bit, maybe the name of the string needs making more generic.

Now we have some classes that implement an interface what can we do with them. Lets write a class called GetData which gets data but doesn’t care if it comes form the rss feed or a SQL database.

public class GetData
{
 private IData _repo;
 public GetData(IData repo)
 {
 _repo = repo;
 }

 public Blog LoadData(string Connectionstring)
 {
 var original = _repo.LoadData(Connectionstring);
 return original;
 }
}

When we call GetData we can either pass in XML or SQL as the class is not tied to either implementation. We could even write other classes that implement IData for testing purposes.

My full code can be found on github .

The advantages of writing code in this way include code that is easier to extend, easier to test and easier to maintain. This is only the start of my understanding and I am sure this is going to be a topic I come back to in the next few weeks.

SOLID and other programming terms

funkysi1701@gmail.com (funkysi1701) — Mon, 20 Mar 2017 20:00:45 +0000

This week I have been looking at improving my understanding of a few programming terms, like SOLID and I will try and define them so I can look back here when I get confused.

MVC

I have previously blogged about MVC , but my understanding was not 100% correct so I will refine this here.

Model – Now this is where my understanding was not quite correct. I thought the model was the actual source data, eg an XML file, SQL database etc. The model is the business logic so this is a processed version of the source data. MVC does not care where data is stored it can be flat files, SQL, XML or anything really.

View – This displays data to the user and typically is the HTML/CSS markup. Only display related logic would get included in the view.

Controller – This is another place I had got a bit confused. I had thought all the logic lived here. This is incorrect controllers are only concerned with getting data between Model and View.

SOLID

SOLID are five principles of object oriented programming and design.

S is for Single Responsibility Principle. A class or piece of code should be responsible for doing one thing.

O is for Open/Closed Principle. Code should be open for extensions but closed for modifications. Often this refers to the way you can implement an interface and add extra functionality.

L is for Liskov Substitution Principle. Objects in a program can be replaced with subtypes of that object with out changing functionality.

I is for Interface Segregation Principle. Large interfaces should be split down into small interfaces so that clients only know about methods that are of interest.

D is for Dependency Inversion Principle. High and Low level modules should depend on abstractions.

I need to look into SOLID some more but here are some examples .

DRY

DRY is simply Don’t Repeat Yourself. It is often easy to spot when a function call will help you not have to use the same bit of code in different places. I am often spotting places where I can put this into action.

Test Driven Development or TDD

funkysi1701@gmail.com (funkysi1701) — Mon, 13 Mar 2017 20:00:45 +0000

A few weeks back I attended a talk at Agile Yorkshire about Test Driven Development or TDD by Dr Oliver Shaw. I was impressed at how easy Oliver made it look, so as I have never tried it I thought I should give it a try.

Test Driven Development or TDD is a way of development which starts with writing a Unit Test. First you write a failing test, then you write the code to make it pass, then you refactor your code. This can be remembered by thinking of Red, Green, Refactor. Red being the failing test, Green being getting the test to pass, and Refactor being the refactoring.

During the demonstration Oliver used a language called scala and a system that automatically reran all the tests after every change. I code with Visual Studio in C# is there a way I can get my tests to run automatically as well?

A bit of googling and configuring I can answer this as Yes.

The nuget package called Giles is a watcher which will rerun your tests similar to how Oliver did it with his scalar environment. Fans of Buffy the Vampire Slayer will get the joke of why a watcher is called Giles. I couldn’t get this to work with MSTest but works fine with NUnit. There is a powershell script giles.ps1 which you need to run and will update every so often with how many tests have passed or failed. However you may not see this if you are coding in Visual Studio but there is a way to get a notification.

If you install the application Growl you can get notifications from Giles which pop up and then disappear. So whatever you have on screen you can find out almost instantly if you have broken tests.

Another thing that I wanted to configure is a way of viewing code coverage and which methods are tested and which aren’t. If you are familiar with VSTS after a build it gives you a percentage score for test coverage. I don’t find this overly useful as it doesn’t tell you what is covered and what isn’t. Also what if you want to use Github, how do you calculate the code coverage then?

The nuget packages OpenCover and ReportGenerator allow a html report of code coverage to be produced. I created a batch script that can be run whenever you require this information.

[path]\OpenCover.Console.exe -target:"[path]\nunit3-console.exe" -targetargs:"[path]\Test.dll" -output:"[path]\coverage.xml" -register:user
[path]\ReportGenerator.exe "-reports:[path]\coverage.xml" "-targetdir:[path]"

The commands are fairly straightforward, the only tricky bit is sorting out all the filepaths to the different programs.

Now that I have all this plumbing setup time to give TDD a try and see what I can build.

GitHub, Bitbucket, or VSTS compared

funkysi1701@gmail.com (funkysi1701) — Mon, 06 Mar 2017 20:00:45 +0000

As a developer using source control and git is bread and butter of what we do. Github is probably the most popular and widely known hosting service for source control but I have also used Bitbucket and Visual Studio Team Services. Lets have a look at each one and what they offer. Note while I have included prices I have only tried out the free versions.

Github

URL: https://github.com/
Private Repositories: Not Available for free
Public Repositories: Unlimited
Team Size: Unlimited
Prices: $7 per month for unlimited private repositories, $25 per month for 5 users then $9 per month per user

This is probably the most widely used service for hosting code. Over 13 million repositories of code. This is an ideal solution if you want your code to be publicly viewable, but take care not to publish passwords, private keys or your companies trade secrets. Every developer should have a Github account for displaying bits of code they are proud of.

There are a number of externally built APIs that link into Github for doing extra features, like building, code coverage etc

Bitbucket

URL: https://bitbucket.org/
Private Repositories: Unlimited
Public Repositories: Unlimited
Team Size: Less than 5
Prices: $10 per month for 10 Users, $100 per month for 100 Users, $200 per month for Unlimited Users

At my last job we used Bitbucket extensively for all our projects. All the code was private so only the team could access it, however before I left we were approaching the 5 user limit (but looking at these prices cost seems very reasonable)

Visual Studio Team Services

URL: https://azure.microsoft.com/services/devops/
Private Repositories: Unlimited
Public Repositories: Not Available
Team Size: Less than 5
Prices: $30 per month for 10 users, and other features paid for via Azure Invoices

Visual Studio Team Services or VSTS is Microsoft’s version control solution and I have only just started using it, however what I have seen I like. There are lots of options for building your code so VSTS is more than just hosting your code it is verging on a Continuous Integration/Delivery solution. Being a Microsoft product there are numerous links to Azure and it is easy to deploy stuff to that platform.

All three have options for tracking issues but VSTS have options to add Stakeholder users which would allow none developers to add and keep track of issues and progress with them.

If I want to run tests, look at code coverage VSTS is probably the solution I would go for, if I want something that is public I would go for Github. What do you think which of these is your favourite?