In this quick tutorial we'll go over how to open Command Prompt, some basic commands and flags, and how to delete files and folders in Command Prompt.

If you're already familiar with basic DOS commands, feel free to skip ahead.

How to open Command Prompt

To open Command Prompt, press the Windows key, and type in "cmd".

Then, click on "Run as Administrator":

After that, you'll see a Command Prompt window with administrative privileges:

Screenshot of Command Prompt window

If you can't open Command Prompt as an administrator, no worries. You can open a normal Command Prompt window by clicking "Open" instead of "Run as Administrator".

The only difference is that you may not be able to delete some protected files, which shouldn't be a problem in most cases.

How to delete files with the del command

Now that Command Prompt is open, use cd to change directories to where your files are.

I've prepared a directory on the desktop called Test Folder. You can use the command tree /f to see a, well, tree, of all the nested files and folders:

To delete a file, use the following command: del "<filename>".

For example, to delete Test file.txt, just run del "Test File.txt".

There may be a prompt asking if you want to delete the file. If so, type "y" and hit enter.

Note: Any files deleted with the del command cannot be recovered. Be very careful where and how you use this command.

After that, you can run tree /f to confirm that your file was deleted:

Also, bonus tip – Command Prompt has basic autocompletion. So you could just type in del test, press the tab key, and Command Prompt will change it to del "Test File.txt".

How to force delete files with the del command

Sometimes files are marked as read only, and you'll see the following error when you try to use the del command:

To get around this, use the /f flag to force delete the file. For example, del /f "Read Only Test File.txt":

How to delete folders with the rmdir command

To delete directories/folders, you'll need to use the rmdir or rd command. Both commands work the same way, but let's stick with rmdir since it's a bit more expressive.

Also, I'll use the terms directory and folder interchangeably for the rest of the tutorial. "Folder" is a newer term that became popular with early desktop GUIs, but folder and directory basically mean the same thing.

To remove a directory, just use the command rmdir <directory name>.

Note: Any directories deleted with the rmdir command cannot be recovered. Be very careful where and how you use this command.

In this case I want to remove a directory named Subfolder, so I'll use the command rmdir Subfolder:

But, if you remember earlier, Subfolder has a file in it named Nested Test File.

You could cd into the Subfolder directory and remove the file, then come back with cd .. and run the rmdir Subfolder command again, but that would get tedious. And just imagine if there were a bunch of other nested files and directories!

Like with the del command, there's a helpful flag we can use to make things much faster and easier.

How to use the /s flag with rmdir

To remove a directory, including all nested files and subdirectories, just use the /s flag:

There will probably be a prompt asking if you want to remove that directory. If so, just type "y" and hit enter.

And that's it! That should be everything you need to know to remove files and folders in the Windows Command Prompt.

All of these commands should work in PowerShell, which is basically Command Prompt version 2.0. Also, PowerShell has a bunch of cool aliases like ls and clear that should feel right at home if you're familiar with the Mac/Linux command line.

Did these commands help you? Are there any other commands that you find useful? Either way, let me know over on Twitter.

Linux is one of the most popular Unix based operating systems. It's open source, and is used all over the world across many industries.

One amazing feature of the Linux operating system is the Command Line Interface (CLI) which allows users to interact with their computer from a shell. The Linux shell is a REPL (Read, Evaluate, Print, Loop) environment where users can enter a command and the shell runs it and returns a result.

The ls command is one of the many Linux commands that allow a user to list files or directories from the CLI.

In this article, we'll go in depth on the ls command and some of the most important flags you'll need day-to-day.

Prerequisites

• A computer with directories and files

• Have one of the Linux distros installed

• Basic knowledge of navigating around the CLI

• A smile on your face :)

The Linux ls Command

The ls command is used to list files or directories in Linux and other Unix-based operating systems.

Just like you navigate in your File explorer or Finder with a GUI, the ls command allows you to list all files or directories in the current directory by default, and further interact with them via the command line.

Launch your terminal and type ls to see this in action:

How to list Files in a Directory with Options

The ls command also accepts some flags (also known as options) which are additional information that changes how files or directories are listed in your terminal.

In other words, flags change how the ls command works:

 ls [flags] [directory]

PS: The word contents used in throughout the article refers to the files and directories being listed, not the actual contents of the files/directories ?

List files in the current working directory

Type the ls command to list the contents of the current working directory:

List files in another directory

Type the ls [directory path here] command to list the contents of another directory:

List files in the root directory

Type the ls / command to list the contents of the root directory:

List files in the parent directory

Type the ls .. command to list the contents of the parent directory one level above. Use ls ../.. for contents two levels above:

List files in the user's home directory (/home/user)

Type the ls ~ command to list the contents in the users's home directory:

List only directories

Type the ls -d */ command to list only directories:

List files with subdirectories

Type the ls * command to list the contents of the directory with it's subdirectories:

List files recursively

Type the ls -R command to list all files and directories with their corresponding subdirectories down to the last file:

If you have a lot of files, this can take a very long time to complete as every single file in each directory will be printed out. You can instead specify a directory to run this command in, like so: ls Downloads -R

List files with their sizes

Type the ls -s command (the s is lowercase) to list files or directories with their sizes:

List files in long format

Type the ls -l command to list the contents of the directory in a table format with columns including:

• content permissions

• number of links to the content

• owner of the content

• group owner of the content

• size of the content in bytes

• last modified date / time of the content

• file or directory name

List files in long format with readable file sizes

Type the ls -lh command to list the files or directories in the same table format above, but with another column representing the size of each file/directory:

Note that sizes are listed in bytes (B), megabytes (MB), gigabytes (GB), or terabytes (TB) when the file or directory's size is larger than 1024 bytes.

List files including hidden files

Type the ls -a command to list files or directories including hidden files or directories. In Linux, anything that begins with a . is considered a hidden file:

List files in long format including hidden files

Type the ls -l -a or ls -a -l or ls -la or ls -al command to list files or directories in a table format with extra information including hidden files or directories:

List files and sort by date and time

Type the ls -t command to list files or directories and sort by last modified date in descending order (biggest to smallest).

You can also add a -r flag to reverse the sorting order like so: ls -tr:

List files and sort by file size

Type the ls -S (the S is uppercase) command to list files or directories and sort by size in descending order (biggest to smallest).

You can also add a -r flag to reverse the sorting order like so: ls -Sr:

List files and output the result to a file

Type the ls > output.txt command to print the output of the preceding command into an output.txt file. You can use any of the flags discussed before like -la — the key point here is that the result will be outputted into a file and not logged to the command line.

Then you can use the file as you see fit, or log the contents of the file with cat output.txt:

.

Conclusion

There are tons of other commands and combinations you can explore to list out files and directories based on your needs. One thing to remember is the ability to combine multiple commands together at once.

Imagine you want to list a file in long format, including hidden files, and sort by file size. The command would be ls -alS, which is a combination of ls -l, ls -a, and ls -S.

If you forget any command or are unsure about what to do, you can run ls --help or man ls which will display a manual with all possible options for the ls command:

Thanks for reading!

If you want to learn how these functions work behind the scenes and how you can use their full power, then this article is for you.

We will start by diving into concepts that are essential to work with listdir and system:

• The built-in Python os module and how to import it.
• The concepts of "directory" and "current working directory".
• How to check and change your current working directory.
• The difference between an absolute path and a relative path.

Then, we will dive into the functions themselves:

• How to work with the listdir function and when to use it.
• How to work with the system("ls") function and when to use it.
• Examples of both of them and how they work behind the scenes.

Let's begin! ⭐

🔸 The OS Module

The two functions that we will discuss: listdir() and system() belong to the os module. This module includes functions that are used to interact with your operating system, performing actions like:

• Making a new directory.
• Renaming an existing directory.
• Removing a directory.
• Displaying the path to your current working directory.
• Much more!

💡 Tips:

• A directory is what we commonly know as a "folder", where we usually store related files and/or other directories, creating a hierarchy of directories within directories that are called subdirectories. An example of a directory is your "Documents" folder.
• A module is a file that contains related Python code.

How to Import the OS Module

To use the os module in your script, you need to "import" it. Importing a module means gaining access to all the functions and variables that are stored within the module. We import a module when we want to use its code in our script.

To import the os module, you simply need to include this line at the top of your Python script or run this line in the interactive shell:

import os

This will give you access to all the functions defined in the os module.

💡 Tip: this module was already installed when you installed Python 3, so you will be able to use it immediately.

To be able to use the functions from the os module, you will need to add the prefix os. before the name of the function that you want to call, like this:

os.<function>(<params>)

For example:

os.mkdir("New Folder")

How to Import Individual Functions

If you are only going to work with one or two functions from the module, you can import them individually using this syntax:

from <module> import <function1>, <function2>, ...

For example:

from os import listdir, system

In this case, you can call the functions in your script as you normally would, without adding the os. prefix, like this:

<function>(<params>)

For example:

mkdir("New Folder")

🔹 Current Working Directory

Now let's see a very important concept that you need to know before you start working with listdir and system. Your current working directory, as the name implies, is the directory (folder) where you are currently working.

You can check your current working directory with this function from the os module:

os.getcwd()

This will show you the path to your current working directory.

💡 Tip: cwd means "current working directory."

From the Interactive Shell

If I run this command in the interactive shell (Windows), I see this:

>>> os.getcwd()
'C:\\Users\\estef\\AppData\\Local\\Programs\\Python\\Python38-32'

This is the full path to my current working directory:

'C:\\Users\\estef\\AppData\\Local\\Programs\\Python\\Python38-32'

From a Script

If I run this command from a script, like this:

import os
print(os.getcwd())

I see:

C:\Users\estef\Documents\freeCodeCamp\freeCodeCamp News\listdir vs system

The full path to the script (its location in the system, in the hierarchy of directories).

💡 Tip: If you run a script (a Python file), your current working directory is the directory where the script is currently in.

How to Change your Current Working Directory

You can change your current working directory with this command from the os module:

os.chdir(<path>)

You will need to specify the path to the new working directory, passing it as an argument, formatted as a string. It can be either an absolute path or a relative path.

💡 Tip:

• An absolute path specifies all the sequence of directories that you need to go through to reach your target directory. This path starts from the root directory of your system.

For example:

>>> import os
>>> os.chdir(r"C:\Users\estef\Documents\FreeCodeCamp\freeCodeCamp News\9 - listdir vs system")

# Checking current working directory:
>>> os.getcwd()
'C:\\Users\\estef\\Documents\\FreeCodeCamp\\freeCodeCamp News\\9 - listdir vs system'

Notice that I added an r before the absolute path to convert the string into a raw string. If you use \ and you don't add the r, you will get an error because the \ symbol will be treated as a special character.

Alternatively, you could replace the backslashes \ with forward slashes / in the path:

>>> os.chdir("C:/Users/estef/Documents/FreeCodeCamp/freeCodeCamp News/9 - listdir vs system")

# Checking current working directory
>>> os.getcwd()
'C:\\Users\\estef\\Documents\\FreeCodeCamp\\freeCodeCamp News\\9 - listdir vs system'

• A relative path specifies the path that you want to follow to find the target directory, but now the path starts from your current working directory. It's shorter and simpler than the absolute path.

For example, if your current working directory contains a subdirectory (folder) Directory 1, you can move to this directory using a relative path (imagine it as a folder within another folder, and we are going deeper and deeper into the hierarchy), like this:

>>> import os
>>> os.chdir(".\Directory 1")

# Check current working directory
>>> os.getcwd()
'C:\\Users\\estef\\Documents\\FreeCodeCamp\\freeCodeCamp News\\9 - listdir vs system\\Directory 1'

💡 Tip: The dot (.) at the beginning of the relative path .\Directory 1 represents the current working directory. A double dot ( ..) is used to move up the hierarchy, to the "parent" directory.

Now that you have all the background knowledge that you will need to truly understand how listdir and system work, let's see them in detail.

🔸 Listdir

We will start with the listdir function. Let's reveal its mysteries. ?

Purpose and Return Value

According to the Python Documentation, the purpose of this function is to:

Return a list containing the names of the entries in the directory given by path.

Basically, this function returns a list with the names of all files and directories that are currently found within a particular directory that you specify when you call the function.

💡 Tip: The list will not have a specific order, even if you usually sort the elements alphabetically.

Syntax and Parameter

To call listdir, will need to use this syntax:

The parameter path is precisely that, the absolute or relative path to the directory that you want to visualize. In Python 3.2 and above, this parameter is optional. By default, the path will lead to your current working directory if you don't pass an argument.

Remember that you must import the os module before calling this function.

💡 Tip: If you use this import statement from os import listdir to import the function individually, you can omit the os. prefix, like this:

Use Cases and Advantages

The function listdir is very helpful because it works on any operating system where Python runs, so if Python is installed on your device, this function will work correctly.

Now let's talk a little bit about its return value. Since it returns a list, we can store this list in a variable and work with it in our program.

For example, let's say that we want to do something with all the files from a given directory, such as converting images to black and white or modifying their content. We could do it using a for loop, like this:

images = os.listdir(<path>)

for image in images:
    # Do something to the image

Of course, you would need to define what happens within the loop, but this is an example of what you could do with this function.

This is awesome, right?

But having files and directories in the same list can be a little bit problematic if we want to work with a for loop, right? We would need to add a conditional to check the type of each element. How can we make a list that only contains file names (no directories) or vice versa?

Let's see! ✨

Only Include Files

If you want to "filter" the list returned by os.listdir() to include only files (no directories) you can use this line of code:

list(filter(os.path.isfile, os.listdir(<path>)))

💡 Tip: You can customize the <path> argument or omit it to use your current working directory.

Let's see an example with my current working directory (I'm using Windows):

My directory (folder) has:

• Two subdirectories (folders within the main folder)
• One PowerPoint file
• One image (.png file)
• One Python script

If I call the listdir function from the script.py file and print the list returned:

print(os.listdir())

This is the output:

['Diagrams.ppt', 'Directory 1', 'Directory 2', 'listdir vs system.png', 'script.py']

You can see that all files and directories from my current working directory were included.

To filter the list to only contain files, we can use this statement:

print(list(filter(os.path.isfile, os.listdir())))

Now the output is:

['Diagrams.ppt', 'listdir vs system.png', 'script.py']

Notice how the directories were "filtered", exactly what we wanted.

Only Include Directories

Similarly, if you want to "filter" the list to include only directories, you can use this line of code:

list(filter(os.path.isdir, os.listdir(<path>)))

Now the output is:

['Directory 1', 'Directory 2']

Exactly what we wanted. But how does this statement work behind the scenes? Let's see.

How filter() Works Behind the Scenes

The filter function is called using this syntax:

filter(<function>, <list>)

It basically "filters" the elements of the second argument (the list) based on the truth value returned by calling the function passed as the first argument (os.path.isfile() or os.path.isdir() in their respective commands):

print(list(filter(os.path.isfile, os.listdir())))

list(filter(os.path.isdir, os.listdir()))

These two functions:

os.path.isfile(<path>)

os.path.isdir(<path>)

Return True if the argument is a file or a directory, respectively.

Based on these truth values, the elements of the list will be included (or not) in the final "filtered" list. The elements of the list returned by os.listdir() are passed one by one to these functions to check if they are files (or directories, respectively).

For example: If we have this line of code:

filter(os.path.isfile, os.listdir())))

And os.listdir() returns this list:

['Diagrams.ppt', 'Directory 1', 'Directory 2', 'script.py']

The first element of the list ('Diagrams.ppt') is passed as argument to os.path.isfile() to check if it's a file :

os.path.isfile('Diagrams.ppt') # True

The function call returns True, so it's a file and it's included in the list.

But if the element is a directory:

os.path.isfile('Directory 1') # False

The function call returns False, so it's not included in the list. This process continues for every element in the list until the new list only contains file names.

Then, since filter() returns an iterable, we make a list from this iterable using list():

list(filter(os.path.isfile, os.listdir()))

And we print it since we are working with a Python file (script):

print(list(filter(os.path.isfile, os.listdir())))

💡 Tip: You can visually identify if an element of the list represents a file or a directory by seeing if it has an extension (type) after its name. For example: Diagrams.ppt has a .ppt extension that tells you that it's a PowerPoint file but a directory doesn't have an extension, like 'Directory 1'.

🔹 System("ls")

Now that you know how to work with listdir, let's see how the system() function works behind the scenes and how you can use it.

Purpose

According to the Python Documentation, the purpose of the system() function is to:

Execute the command (a string) in a subshell

Basically, this function takes a command (as a string) and executes it.

In this case, the command that we are passing is 'ls' , a Unix command used in Linux to display the content of a directory as standard output.

Unlike listdir, the system() function will not return a list if we pass the 'ls' command, it will only display the list of files and directories as standard output. Therefore, you should use it if you only want to visualize the list without actually working with it in your program.

Syntax and Parameter

To call this function, you will need to use this syntax:

Its only argument is the command that you want to execute formatted as a string (surrounded by double quotes or single quotes).

Particularly, the ls command lets you see the content of your current working directory.

For example: if this is my working directory (three Python files and one subdirectory):

And I call the system() function, like this:

>>> import os
>>> os.system("ls")

This is the output:

'Directory 1'  'file 1.py'  'file 2.py'   main.py
0

We can see the standard output in the console (the list of files and directories):

'Directory 1'  'file 1.py'  'file 2.py'   main.py

and the return value:

0

💡 Note: For these examples of the system() function, I'm working with an online command line tool called Repl.it since my computer has Windows installed and the command ls is not recognized by the default command prompt.

Limitations

One of the main limitation of this function is that the command passed as argument has to be recognized by the operating system or environment that you are working with.

For example, the ls command will not be recognized in Windows by default in the command prompt. You will see this error if you try to run it:

'ls' is not recognized as an internal or external command, operable program or batch file.

A similar command in Windows would be the 'dir' command:

os.system('dir')

💡 Tip: There are alternative ways to run the ls command on Windows, such as using terminal programs that recognize Unix commands, but by default Windows does not recognize the 'ls' command.

Return Value

According to the Python documentation:

On Unix, the return value is the exit status of the process encoded in the format specified for wait().

and...

On Windows, the return value is that returned by the system shell after running command.

💡 Tip: Note that this function does not return a list. It simply displays the list as standard output, so you can't store it in a variable like you did with listdir.

Variations of the ls command

A key feature of os.system('ls') is that it has many helpful and interesting options to customize how present the output. Let's see some of them.

Option 1: We can show more information about files and directories such as their size, location, and modification date and time using the command ls -l.

>>> import os
>>> os.system('ls -l')
total 12
drwxr-xr-x 1 runner runner  0 Apr  3 18:23 'Directory 1'
-rw-r--r-- 1 runner runner 11 Apr  3 18:38 'file 1.py'
-rw-r--r-- 1 runner runner 11 Apr  3 18:38 'file 2.py'
-rw-r--r-- 1 runner runner 11 Apr  3 18:38  main.py
0

Option 2: To be able to visually recognize directories faster, we can use ls -F, which adds a forward slash / to the end of their names (see 'Directory 1/' below).

>>> import os
>>> os.system('ls -F')
'Directory 1'/  'file 1.py'  'file 2.py'   main.py
0

Option 3: To sort the files by size, we can use the command ls -lS.

>>> import os
>>> os.system('ls -lS')
total 12
-rw-r--r-- 1 runner runner 11 Apr  3 18:38 'file 1.py'
-rw-r--r-- 1 runner runner 11 Apr  3 18:38 'file 2.py'
-rw-r--r-- 1 runner runner 11 Apr  3 18:38  main.py
drwxr-xr-x 1 runner runner  0 Apr  3 18:23 'Directory 1'
0

There are many more options for customization that can be helpful for your particular goal. Here you can find more information about the -ls command and how you can use its full power.

🔸 Summary of listdir vs. system("ls")

• Purpose: listdir returns the list of file names and directories in the path specified (by default, the current working directory) while system("ls") only displays them as standard output.
• Operating System: listdir can be used independently of the operating system that you are working with. In contrast, system('ls') has to be executed in an operating system or environment that recognizes the 'ls' command.
• Customization: you can filter the list returned by listdir if you need to remove files or directories using the filter() function and you can pass options to customize the output of system('ls').

I really hope that you liked my article and found it helpful. Now you can work with these functions in your Python projects. Check out my online courses. Follow me on Twitter. ⭐️

What is a Design Pattern?

Design patterns are design level solutions for recurring problems that we software engineers come across often. It’s not code - I repeat, ❌CODE. It is like a description on how to tackle these problems and design a solution.

Using these patterns is considered good practice, as the design of the solution is quite tried and tested, resulting in higher readability of the final code. Design patterns are quite often created for and used by OOP Languages, like Java, in which most of the examples from here on will be written.

Types of design patterns

There are about 26 Patterns currently discovered (I hardly think I will do them all…).

These 26 can be classified into 3 types:

1. Creational: These patterns are designed for class instantiation. They can be either class-creation patterns or object-creational patterns.

2. Structural: These patterns are designed with regard to a class's structure and composition. The main goal of most of these patterns is to increase the functionality of the class(es) involved, without changing much of its composition.

3. Behavioral: These patterns are designed depending on how one class communicates with others.

In this post, we will go through one basic design pattern for each classified type.

Type 1: Creational - The Singleton Design Pattern

The Singleton Design Pattern is a Creational pattern, whose objective is to create only one instance of a class and to provide only one global access point to that object. One commonly used example of such a class in Java is Calendar, where you cannot make an instance of that class. It also uses its own getInstance()method to get the object to be used.

A class using the singleton design pattern will include,

Singleton Class Diagram

1. A private static variable, holding the only instance of the class.
2. A private constructor, so it cannot be instantiated anywhere else.
3. A public static method, to return the single instance of the class.

There are many different implementations of singleton design. Today, I’ll be going through the implementations of;

1. Eager Instantiation

2. Lazy Instantiation

3. Thread-safe Instantiation

Eager Beaver

public class EagerSingleton {
    // create an instance of the class.
    private static EagerSingleton instance = new EagerSingleton();

    // private constructor, so it cannot be instantiated outside this class.
    private EagerSingleton() {  }

    // get the only instance of the object created.
    public static EagerSingleton getInstance() {
        return instance;
    }
}

This type of instantiation happens during class loading, as the instantiation of the variable instance happens outside any method. This poses a hefty drawback if this class is not being used at all by the client application. The contingency plan, if this class is not being used, is the Lazy Instantiation.

Lazy Days

There isn’t much difference from the above implementation. The main differences are that the static variable is initially declared null, and is only instantiated within the getInstance() method if - and only if - the instance variable remains null at the time of the check.

public class LazySingleton {
    // initialize the instance as null.
    private static LazySingleton instance = null;

    // private constructor, so it cannot be instantiated outside this class.
    private LazySingleton() {  }

    // check if the instance is null, and if so, create the object.
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

This fixes one problem, but another one still exists. What if two different clients access the Singleton class at the same time, right to the millisecond? Well, they will check if the instance is null at the same time, and will find it true, and so will create two instances of the class for each request by the two clients. To fix this, Thread Safe instantiation is to be implemented.

(Thread) Safety is Key

In Java, the keyword synchronized is used on methods or objects to implement thread safety, so that only one thread will access a particular resource at one time. The class instantiation is put within a synchronized block so that the method can only be accessed by one client at a given time.

public class ThreadSafeSingleton {
    // initialize the instance as null.
    private static ThreadSafeSingleton instance = null;

    // private constructor, so it cannot be instantiated outside this class.
    private ThreadSafeSingleton() {  }

    // check if the instance is null, within a synchronized block. If so, create the object
    public static ThreadSafeSingleton getInstance() {
        synchronized (ThreadSafeSingleton.class) {
            if (instance == null) {
                instance = new ThreadSafeSingleton();
            }
        }
        return instance;
    }
}

The overhead for the synchronized method is high, and reduces the performance of the whole operation.

For example, if the instance variable has already been instantiated, then each time any client accesses the getInstance() method, the synchronized method is run and the performance drops. This just happens in order to check if the instance variables’ value is null. If it finds that it is, it leaves the method.

To reduce this overhead, double locking is used. The check is used before the synchronized method as well, and if the value is null alone, does the synchronized method run.

// double locking is used to reduce the overhead of the synchronized method
public static ThreadSafeSingleton getInstanceDoubleLocking() {
    if (instance == null) {
        synchronized (ThreadSafeSingleton.class) {
            if (instance == null) {
                instance = new ThreadSafeSingleton();
            }
        }
    }
    return instance;
}

Now onto the next classification.

Type 2: Structural - The Decorator Design Pattern

I’m gonna give you a small scenario to give a better context to why and where you should use the Decorator Pattern.

Say you own a coffee shop, and like any newbie, you start out with just two types of plain coffee, the house blend and dark roast. In your billing system, there was one class for the different coffee blends, which inherits the beverage abstract class. People actually start to come by and have your wonderful (albeit bitter?) coffee. Then there are the coffee newbs that, God forbid, want sugar or milk. Such a travesty for coffee!! ??

Now you need to have those two add-ons as well, both to the menu and unfortunately on the billing system. Originally, your IT person will make a subclass for both coffees, one including sugar, the other milk. Then, since customers are always right, one says these dreaded words:

“Can I get a milk coffee, with sugar, please?”

???

There goes your billing system laughing in your face again. Well, back to the drawing board….

The IT person then adds milk coffee with sugar as another subclass to each parent coffee class. The rest of the month is smooth sailing, people lining up to have your coffee, you actually making money. ??

But wait, there’s more!

The world is against you once again. A competitor opens up across the street, with not just 4 types of coffee, but more than 10 add-ons as well!

You buy all those and more, to sell better coffee yourself, and just then remember that you forgot to update that dratted billing system. You quite possibly cannot make the infinite number of subclasses for any and all combinations of all the add-ons, with the new coffee blends too. Not to mention, the size of the final system.

Time to actually invest in a proper billing system. You find new IT personnel, who actually knows what they are doing and they say,

“Why, this will be so much easier and smaller if it used the decorator pattern.”

What on earth is that?

The decorator design pattern falls into the structural category, that deals with the actual structure of a class, whether is by inheritance, composition or both. The goal of this design is to modify an objects’ functionality at runtime. This is one of the many other design patterns that utilize abstract classes and interfaces with composition to get its desired result.

Let’s give Math a chance (shudder?) to bring this all into perspective.

Take 4 coffee blends and 10 add-ons. If we stuck to the generation of subclasses for each different combination of all the add-ons for one type of coffee. That’s:

(10–1)² = 9² = 81 subclasses

We subtract 1 from the 10, as you cannot combine one add-on with another of the same type, sugar with sugar sounds stupid. And that’s for just one coffee blend. Multiply that 81 by 4 and you get a whopping 324 different subclasses! Talk about all that coding…

But with the decorator pattern it will require only 16 classes in this scenario. Wanna bet?

Decorator Design Pattern Class diagram

Class diagram according to coffee shop scenario

If we map out our scenario according to the class diagram above, we get 4 classes for the 4 coffee blends, 10 for each add-on and 1 for the abstract component and 1 more for the abstract decorator. See! 16! Now hand over that $100.?? (jk, but it will not be refused if given… just saying)

As you can see from above, just as the concrete coffee blends are subclasses of the beverage abstract class, the AddOn abstract class also inherits its methods from it. The add-ons, that are its subclasses, in turn inherit any new methods to add functionality to the base object when needed.

Let’s get to coding, to see this pattern in use.

First to make the Abstract beverage class, that all the different coffee blends will inherit from:

public abstract class Beverage {
    private String description;

    public Beverage(String description) {
        super();
        this.description = description;
    }

    public String getDescription() {
        return description;
    }

    public abstract double cost();
}

Then to add both the concrete coffee blend classes.

public class HouseBlend extends Beverage {
    public HouseBlend() {
        super(“House blend”);
    }

    @Override
    public double cost() {
        return 250;
    }
}

public class DarkRoast extends Beverage {
    public DarkRoast() {
        super(“Dark roast”);
    }

    @Override
    public double cost() {
        return 300;
    }
}

The AddOn abstract class also inherits from the Beverage abstract class (more on this below).

public abstract class AddOn extends Beverage {
    protected Beverage beverage;

    public AddOn(String description, Beverage bev) {
        super(description);
        this.beverage = bev;
    }

    public abstract String getDescription();
}

And now the concrete implementations of this abstract class:

public class Sugar extends AddOn {
    public Sugar(Beverage bev) {
        super(“Sugar”, bev);
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + “ with Mocha”;
    }

    @Override
    public double cost() {
        return beverage.cost() + 50;
    }
}

public class Milk extends AddOn {
    public Milk(Beverage bev) {
        super(“Milk”, bev);
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + “ with Milk”;
    }

    @Override  public double cost() {
        return beverage.cost() + 100;
    }
}

As you can see above, we can pass any subclass of Beverage to any subclass of AddOn, and get the added cost as well as the updated description. And, since the AddOn class is essentially of type Beverage, we can pass an AddOn into another AddOn. This way, we can add any number of add-ons to a specific coffee blend.

Now to write some code to test this out.

public class CoffeeShop {
    public static void main(String[] args) {
        HouseBlend houseblend = new HouseBlend();
        System.out.println(houseblend.getDescription() + “: “ + houseblend.cost());

        Milk milkAddOn = new Milk(houseblend);
        System.out.println(milkAddOn.getDescription() + “: “ + milkAddOn.cost());

        Sugar sugarAddOn = new Sugar(milkAddOn);
        System.out.println(sugarAddOn.getDescription() + “: “ + sugarAddOn.cost());
    }
}

The final result is:

P.S. this is in Sri Lankan Rupees

It works! We were able to add more than one add-on to a coffee blend and successfully update its final cost and description, without the need to make infinite subclasses for each add-on combination for all coffee blends.

Finally, to the last category.

Type 3: Behavioral - The Command Design Pattern

A behavioral design pattern focuses on how classes and objects communicate with each other. The main focus of the command pattern is to inculcate a higher degree of loose coupling between involved parties (read: classes).

Uhhhh… What’s that?

Coupling is the way that two (or more) classes that interact with each other, well, interact. The ideal scenario when these classes interact is that they do not depend heavily on each other. That’s loose coupling. So, a better definition for loose coupling would be, classes that are interconnected, making the least use of each other.

The need for this pattern arose when requests needed to be sent without consciously knowing what you are asking for or who the receiver is.

In this pattern, the invoking class is decoupled from the class that actually performs an action. The invoker class only has the callable method execute, which runs the necessary command, when the client requests it.

Let’s take a basic real-world example, ordering a meal at a fancy restaurant. As the flow goes, you give your order (command) to the waiter (invoker), who then hands it over to the chef(receiver), so you can get food. Might sound simple… but a bit meh to code.

The idea is pretty simple, but the coding goes around the nose.

Command Design Pattern Class Diagram

The flow of operation on the technical side is, you make a concrete command, which implements the Command interface, asking the receiver to complete an action, and send the command to the invoker. The invoker is the person that knows when to give this command. The chef is the only one who knows what to do when given the specific command/order. So, when the execute method of the invoker is run, it, in turn, causes the command objects’ execute method to run on the receiver, thus completing necessary actions.

What we need to implement is;

1. An interface Command
2. A class Order that implements Command interface
3. A class Waiter (invoker)
4. A class Chef (receiver)

So, the coding goes like this:

Chef, the receiver

public class Chef {
    public void cookPasta() {
        System.out.println(“Chef is cooking Chicken Alfredo…”);
    }

    public void bakeCake() {
        System.out.println(“Chef is baking Chocolate Fudge Cake…”);
    }
}

Command, the interface

public interface Command {
    public abstract void execute();
}

Order, the concrete command

public class Order implements Command {
    private Chef chef;
    private String food;

    public Order(Chef chef, String food) {
        this.chef = chef;
        this.food = food;
    }

    @Override
    public void execute() {
        if (this.food.equals(“Pasta”)) {
            this.chef.cookPasta();
        } else {
            this.chef.bakeCake();
        }
    }
}

Waiter, the invoker

public class Waiter {
    private Order order;

    public Waiter(Order ord) {
        this.order = ord;
    }

    public void execute() {
        this.order.execute();
    }
}

You, the client

public class Client {
    public static void main(String[] args) {
        Chef chef = new Chef();

        Order order = new Order(chef, “Pasta”);
        Waiter waiter = new Waiter(order);
        waiter.execute();

        order = new Order(chef, “Cake”);
        waiter = new Waiter(order);
        waiter.execute();
    }
}

As you can see above, the Client makes an Order and sets the Receiver as the Chef. The Order is sent to the Waiter, who will know when to execute the Order (i.e. when to give the chef the order to cook). When the invoker is executed, the Orders’ execute method is run on the receiver (i.e. the chef is given the command to either cook pasta ? or bake cake?).

Final Client Output

Quick recap

In this post we went through:

1. What a design pattern really is,
2. The different types of design patterns and why they are different
3. One basic or common design pattern for each type

I hope this was helpful.

Find the code repo for the post, here.