Clean Code by Robert Cecil Martin – Review

Clean Code is an excellent book that all programmers should read. However its not for complete beginners. First chapters are covering basic: naming conventions, comments, functions… later it goes through good coding practices and rules that apply to all programming languages.

Advertisements

Clean Code: A Handbook of Agile Software Craftsmanship by Robert Cecil Martin

Clean Code Bookcover

Clean Code is an excellent book that all programmers should read. However its not for complete beginners. First chapters are covering basic: naming conventions, comments, functions…  later it goes through good coding practices and rules that apply to all programming languages. Code is written in Java what makes more of a “Clean Java Code” It uses Java for all of the examples and some of the chapters are dedicated to Java-specific issues. This can be a limitation to the users.

The writing style of the book. Its simple, clean, and well crafted. This book’s biggest strength is that it includes tons of code examples, including some fairly long and in depth ones. Instead of just listing rules or principles of clean code. There are a number of lengthy examples in the book, demonstrating code before and after cleaning with a detailed description of the rationale for each small change.

The Agile origins of the book are seen with the strong emphasis on testing, and Test Driven Development (JUnit framework).  Author emphasises the importance of witting clean code that will last for a long time, over iterations and between programmers.

CONCLUSION

This book is perfect for Java developer but it can be very helpful for junior developer who want to take coding practices to next level. I recommend this book to everyone who wants to post their code problem on the programming forum 😀 Stay Awesome!

 

 

Jekyll in action

Jekyll is a free, open source, static site generator written in Ruby by Tom Preston-Werner, GitHub’s co-founder. Website created in Jekyll can be hosted on platforms like GitHub or Google Firebase. It’s commonly used by bloggers with experience in programming.

 

WTF is Jekyll?

3083652Jekyll is a free, open source, static site generator written in Ruby by Tom Preston-Werner, GitHub’s co-founder.  Website created in Jekyll can be hosted on platforms like GitHub or Google Firebase.  It’s commonly used by bloggers with experience in programming.

Jekyll is different than Content Management Systems like WordPress. It doesn’t have build in graphical interface, but it can be implemented(more about this later).

Instead of using databases, Jekyll takes the content, renders Markdown or Textile and Liquid templates, and produces a complete, static website ready to be served. Writing page from scratch can be challenging, but Jekyll have countless themes available online:

If you want you can buy themes on Market.envato.com.

Advantages of Jekyll

Jekyll is fast. Faster than any WordPress site. Static website once is generated it can not change. It doesn’t require connection to a Database what makes it super fast. Loading speed can be effected by things like large images, this is factor to look out for.

Jekyll is Simple. Jekyll doesn’t add any bloat to the website or blog you are working on. Many of the Jekyll Themes are very minimal and content oriented. take a look at Netflix website powered by Jekyll.

Jekyll is secure. Static websites will not have any database to manipulate. So Jekyll a 100 times safer than WordPress. But nothing is un-hackable. Not having database makes it easier to use for people with no experience in Back-end development.

Installation

Installation is one of the trickiest things in Jekyll. Jekyll is based on Ruby  and it require few things to run:

  • Ruby (including development headers, v1.9.3 or above for Jekyll 2 and v2 or above for Jekyll 3)
  • RubyGems
  • Linux, Unix, or macOS
  • NodeJS, or another JavaScript runtime (Jekyll 2 and earlier, for CoffeeScript support).
  • Python 2.7 (for Jekyll 2 and earlier)

After meeting all the requirements you can install it like any other Ruby Gem:

$ gem install jekyll

Installation process was greatly explained in many articles in the past, more information about the installation process you can find on official documentation:

This works only if you are Mac/Linux user. If you are Windows user it’s little more complicated…

 

Hosting

octojekyllGitHub gives option to host static websites for Free including domain based on the account name. GitHub Pages are public web pages for users, organisations, and repositories. GitHub Pages are powered by Jekyll behind the scenes, so in addition to supporting regular HTML content, they’re also a great way to host your Jekyll-powered website for free.

Tutorial explaining this process can be found on GitHubSupport page

Jekyll comes with plugin for importing content from WordPress.com.

CMS

Creating posts in Text Editor with Markup language and generating new website with each update can be frustrating. Companies like CloudCannon.com offer solution to this problem. Using CMS gives you or your client direct access to the server and option of editing the page and adding new content really easy without and technical knowledge. However basic account costs 25$/month.

Alternative option is provided by SiteLeaf. Another option for personal use is free Prose.io

Conclusion

This post is a beginning of new series of articles about web development. If you are looking for more unique way of blogging this can be option for you. However it requires a knowledge of  front end development and it can be too complicated for people not familiar with web development. This can be simplified with CMS’s for small monthly fee. I hope this article was helpful and now you have new tool under you belt.

Here is example of my Portfolio website built with Jekyll.

 

 

Update

Blog Update

 

Edit: I’m back to blogging on WordPress


I’m moving my blog into (GitHub , click). I’ll separate the future content into two blogs. For subjects related to Games Development I will continue to  use WordPress-this blog. And the second blog for more advanced software development topics like low level languages(CIL, MSIL, Assembly, ), algorithms and discrete mathematics.

Work in progress…

C# Decorator Design Pattern

C# Decorator Design Pattern tutorial

Link to Source code

In this article You will learn how to implement decorator pattern in C#. Decorator pattern allows to modify an object dynamically it simplifies the code by adding new functionality at runtime. Adding new functionality to the object doesn’t effect the initial class structure.

In my example I’ll simulate the process of enchanting an item in RPG game.

UML Diagram:

l11

Component

This interface will be used as base for decorator and concrete items. It contains methods that will return properties of an item.

public interface IItem
{
    string GetName();
    int GetValue();
}

Base Items like armor or Sword will implement this interface and return fixed values.

class Sword : IItem
{
    public string GetName()
    {
        return "Iron Sword";
    }

    public int GetValue()
    {
        return 20;
    }
}

Decorator

This is the key part of the pattern, it maintains a reference to a Component object and defines an interface that conforms to Component’s interface. In my example this will be represented as an Enchantment of the item. Decorator will have form of abstract class and will have protected constructor

A protected member is accessible within its class and by derived class instances.

abstract class Enchantment : IItem
{
  IItem _item = null;

  protected int _Value = 0;

  protected Enchantment(IItem baseItem)
  {
    _item = baseItem;
  }

  public string GetName()
  {
    return (_item.GetName() +" +1 ");
  }

  public int GetValue()
  {
    return (_item.GetValue() + _Value);
  }
}

Class that extends the Decorator can change the protected values in parent to eventually change the return values.

class Magic : Enchantment
{
  public Magic(IItem baseComponent): base(baseComponent)
  {
    this._Value = 30;
  }
}

Client

Last part of an application. Here the instance of an item is created and modified. In this example you can see how the values changed after adding decorator.

class Program
{
  static void Main(string[] args)
  {
    IItem newItem = new Sword();
    Console.WriteLine(newItem.GetName() + " Value: " + newItem.GetValue().ToString());

    newItem = new Magic(newItem);
    Console.WriteLine(newItem.GetName() + " Value: " + newItem.GetValue().ToString());

    Console.ReadLine();
  }
}

To conclude, Decorator can attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to sub-classing for extending functionality. I hope that this was understandable and it will help you with your projects. This was probably the last design pattern to cover on my blog, last in this month at least. Stay Awesome!

C# Prototype Design Pattern

C# Prototype Design Pattern tutorial

Link to source code

This is the last creational pattern in this series. And it’s used to create clones of objects without using references. C# is giving us helpful method MemberwiseClone() that is doing all cloning in the background. Later in the article I’ll cover the difference between Shadow and Deep Cloning.

The MemberwiseClone method creates a shallow copy by creating a new object, and then copying the nonstatic fields of the current object to the new object. If a field is a value type, a bit-by-bit copy of the field is performed. If a field is a reference type, the reference is copied but the referred object is not; therefore, the original object and its clone refer to the same object.

In my example I’m creating copy of the Enemy object that will keep the same ID as the base object.

UML diagram

 

l10

Prototype

First thing to do is the interface that will be implemented by concrete class. This is an interface which is used for the types of object that can be cloned itself.


public abstract class AbstractEnemy
{
  int _id;

  public int Id
  {
    get { return _id; }
    set { _id = value; }
  }
  public abstract AbstractEnemy Clone();
}

This time implementation will be very simple thank to the MemberwiseClone() method.


class Enemy : AbstractEnemy
{
  public override AbstractEnemy Clone()
  {
      Console.WriteLine("cloning enemy...");
      return this.MemberwiseClone() as AbstractEnemy;
  }
}

One last thing to create is the Client Class that will create instance of an enemy and perform the cloning procedure.

Client

static void Main(string[] args)
{
   Enemy enemy = new Enemy();
   enemy.Id = 1;

   Console.WriteLine("Enemy Copy ID: " + enemy.Id.ToString());

   Enemy clonedEnemy = enemy.Clone() as Enemy;

   Console.WriteLine("Enemy Copy ID: " + clonedEnemy.Id.ToString());
 }
 }

 

Difference between Shadow and Deep Cloning

The problem with the memberwise copy is that it creates a shallow copy of the object i.e. if the object contains any reference types then only the address of that reference type will be copied from source to target and both the versions will keep pointing to the same object. Changing properties of inner-class of one object will change them for other class as well.

  • A shallow copy copies all reference types or value types, but it does not copy the objects that the references refer to. The references in the new object point to the same objects that the references in the original object points to.

  •  Deep copy of an object copies the elements and everything directly or indirectly referenced by the elements.

Solution to this problem is to create  new Copy() method that will involve copying the inner class properties to new object. or to include copy() method to all object sub classes, just as it was implemented in previous example.

 


 public override AbstractEnemy Clone()
 {
    Enemy cloned = this.MemberwiseClone() as Enemy;
    cloned.Equipment = new Equipment();
    cloned.Equipment.Armor = this.Equipment.Armor;

     return cloned as AbstractEnemy;
 }

To conclude, this pattern specifies the kind of objects to create using a prototypical instance, and create new objects by copying this prototype. I hope you learned something new. In next series of articles I’ll start moving into low level languages. Stay Awesome!

C# Abstract Factory Pattern

C# Abstract Factory Pattern tutorial

Link To source Code

In previous post i introduced you to the concept of Factory Method. Abstract factory is very similar, but this time we will encapsulate all classes, by cremating interfaces for  Product and Factory. This pattern is also called as Factory of factories, because this patterns acts a superFactory which creates other factories. Abstract factory pattern in useful when the client needs to create objects which are somehow related, without specifying the concrete class.  With this pattern objects can interact with each other through common interfaces.

As usual I am using example from game development. In my example I’ll create Abstract Factory that will spawn enemies and give them specific weapon and armor.

UML diagram

l9

 

Factory

First thing to crate is the interface for Factory, that will be used to specify the equipment of each enemy.


 interface IEnemyFactory
    {
       IWeapon GetWeapon();
       IArmor GetArmor();
    }

Concrete classes will be named as the type of enemy that will be created. In my Example i have two enemies Mage and Warrior.


class Mage : IEnemyFactory
{
    public IWeapon GetWeapon()
    {
        return new Wand();
    }

    public IArmor GetArmor()
    {
        return new Cloak();
    }
}

class Warrior : IEnemyFactory
{
    public IWeapon GetWeapon()
    {
        return new Sword();
    }

    public IArmor GetArmor()
    {
        return new BodyArmor();
    }
}

Product

In next step we will create interface for items that will be given to the enemies. Both types share the same types of equipment, weapon and armor.


interface IWeapon
 {
     string Item();
 }
interface IArmor
 {
     string Item();
 }

In Concrete classes methods will return string values that will be printed to the console.


class Sword : IWeapon
 {
     public string Item()
     {
         return "Iron Sword";
     }
 }

class Wand : IWeapon
 {
     public string Item()
     {
          return "Magic Wand";
     }
 }
 class BodyArmor : IArmor
 {
      public string Item()
      {
          return "Iron Body Armor";
      }
 }

class Cloak : IArmor
 {
     public string Item()
     {
          return "Magic Cloak";
     }
 }

Client

Client is the last part is to create. Here we will create instance of the factory and spawn our enemies.


class Client
{

IEnemyFactory factory=null;

//SpawnEnemy method will decide what type of enemy will be created

//Based on string input

public void SpawnEnemy(string enemy)
 {
   if (enemy == "Warrior")
   {
     factory = new Warrior();
     Console.WriteLine("New Warior equipment:");
     Console.WriteLine(factory.GetWeapon().Item());
     Console.WriteLine(factory.GetArmor().Item());
     Console.WriteLine("_____________________");
   }
   else if (enemy == "Mage")
   {
     factory = new Mage();
     Console.WriteLine("New Mage equipment: ");
     Console.WriteLine(factory.GetWeapon().Item());
     Console.WriteLine(factory.GetArmor().Item());
     Console.WriteLine("_____________________");
   }
   else
   {
      Console.WriteLine("Wrong type");
   }
 }

 //Main method
 static void Main(string[] args)
 {
     Client client = new Client();
     client.SpawnEnemy("Mage");
     client.SpawnEnemy("Warrior");
     Console.Read();
 }
}

To conclude, Abstract Factory  provides an interface for creating families of related or dependent objects without specifying their concrete classes. This pattern is very useful but in large projects it may increase the complexity of the code. I hope you learned something new today. In next article You will learn how to implement another pattern. Stay Awesome!

 

C# Command Design Pattern

C# Command Design Pattern Tutorial

Link to Source Code

Command pattern allows you to store list of code that is executed many times or at a later time. It also gives you easy way to implement Undo() that can just have opposite effect or undo multiple command, if commands are stored in list. This pattern is supports encapsulation, which is always a good thing. It may look complicated, it involves multiple classes:

Receiver – that performs the Action associated with the request.

Invoker  –that asks the command to carry out the request

Command -this is an interface which specifies the Execute and/or Undo operation.

Client – creates instance of an invoker, command and receiver and connects them.

As usual I’ll be using example related to video games. In my example I created simulation where Enemy can enter the field on the battlefield that can Heal him or it can add a Buff. I have two types of enemies Goblin and dragon, just to demonstrate the example of multiple receivers. When enemy exits the field the opposite action is triggered.

 

UML Diagram

l7

Receiver

Lets start by creating interface for Enemies. Every enemy that implements this interface can either take damage, heal, and Turn Buff OFF and ON.


interface IEnemy
{
  string Damage();
  string Heal();
  string BuffON();
  string BuffOFF();
}

Each method will return a string with massage about current status.

Here is implementation of the interface in one of the Enemy Class. Second One is very similar and you can find it in source code.


class Goblin : IEnemy
{
  public string BuffOFF()
  {
    return "Goblin enters the field-Buff is ON";
  }

  public string BuffON()
  {
    return "Goblin exits the field-Buff is OFF";
  }

  public string Damage()
  {
    return "Goblin exits the field- takes damage";
  }

  public string Heal()
  {
     return "Goblin enters the field- heals";
  }

Command

This interface will specify how retriever will respond to execute()and undo() commands.

interface ICommand
{
  void Execute();
  void UnDo();
} 

implementation of this interface requires a instance of an IEnemy receiver, in class constructor we pass the receiver that will be manipulated by the command. Again I’m showing here just one of two Classes, because both are identical.


class Heal : ICommand
{
  IEnemy _receiver;
  // Constructor
  public Heal(IEnemy receiver)
  {
    _receiver = receiver;
  }

  public void Execute()
  {
    Console.WriteLine(_receiver.Heal());
  }
  public void UnDo()
  {
    Console.WriteLine(_receiver.Damage());
  }
}

 

Invoker

In my example i’m simulating situation when enemy enters the field on the map, that triggers the commands. In the invoker we pass instance of command that we want to execute.


class Field
{
  private ICommand _command;

  public void SetCommand(ICommand command)
  {
    this._command = command;
  }

  public void EnterField()
  {
  _command.Execute();
  }
  public void ExitField()
  {
  _command.UnDo();
  }
}

Client

This is the last part of the program that connect everything together. In this specific example I chose the situation when Enemy Goblin Enters the Field, what trigger the Heal command. After leaving the field Goblin Takes Damage.


static void Main()
{
  // Create receiver, command, and invoker
  IEnemy receiver = new Goblin();
  ICommand command = new Heal(receiver);
  Field invoker = new Field();

  // Set and execute command
  invoker.SetCommand(command);
  invoker.EnterField();
  invoker.ExitField();

  Console.ReadKey();
}

This was just a simple demonstration of the pattern, one way of extending the functionality of it is to store command in the generic list, this way we can undo multiple commands or execute command already executed in the past. I hope you like will find it useful. In my next article I’ll cover on of the last design patters. Stay Awesome!