I’m able to write a simple or even a complex text description and an AI / computer generates the images for me within a few seconds. There are a few of these AI-based image services out there. I’m currently trying out DALL-E.

Here are a few photos I’ve generated recently

Text prompts are in “quotes” followed by the image that DALL-E generated for me:

“Cybertronic robot orange and white, LEDs, high detail, sharp, studio, digital art”

“Photograph of a spaceship rising out of the ocean. The sun is setting and and there is a large planet visible in the sky. Someone wearing a robe stands on a cliff looking at the spaceship.”

“A white fur monster in a blue room”

“A Cybertronic robot full body on a mountain top overlooking a lake city, LEDs, high detail, sharp, studio, digital art, 8k”

“The solar system without words, digital art”

“A portrait of a hamster in a library, Sigma 85 mm f/1.4.”

“Photograph of a robot with red spikey hair on a mountain top overlooking a lake. There is a large planet system in the sky on the horizon.”

So today I tried ChatGPT and it blew me away!

The idea is you give it a single sentence such as “Write me a blog post about moons in the solar system” or “write a python program to download an XML news feed” and it replies with what looks like a human generated response.

Awesome! But scary at the same time…

How good is it? It actually can write really well. And it can code. In multiple programming languages. Python, C#, PHP. Probably more.

Check out the below video of me write a sentence or two and then the app replies back with a detailed, well written response. In some cases to include actual computer code; I tried running a couple of code examples it generated and the code did work on my computer.

Why use the Factory pattern?

Use the factory pattern when you need to provide a way for someone (a consumer or some client code) to use an object without needing to know how that object is created or it’s dependencies.

The consumer only needs to provide some information to get started using the class object and not the exact class their looking for.

Since the Factory pattern removes the need for a consumer to instantiate class objects, the resulting code becomes less coupled and easier to extend.

A simple example

class HandlesSmallFiles {
}

class HandlesLargeFiles {
}

class Factory {
    function generateObject($string) {
        switch($string){
            case "S":
                return new HandlesSmallFiles();
            case "L":
                return new HandlesLargeFiles();
        }
    }
}

$factory = new Factory();
$object = $factory->generateObject("L");
print get_class($object) . "\n";
$object = $factory->generateObject("S");
print get_class($object) . "\n";

And the output is

HandlesLargeFiles
HandlesSmallFiles

The above example is meant to illustrate the factory concept. We provide either an “S” or an “L” as the information about what object we want, and then the factory delivers the corresponding object.

However, the design isn’t great because the Factory class is not open to extension and would require modification. In other words, if you wanted to have a new case to handle medium size files, we would have to edit the Factory class. And this could be painful to regression test all the areas in the application where the Factory class was used.

An example providing a little more flexibility

<?php

interface FileEncrypter {
    function encrypt();
}

class SmallFileEncrypter implements FileEncrypter {
    private $filename;
    function __construct(string $filename) {
        $this->filename = $filename;
    }
    public function encrypt() {
        return "Now encrypting a small file in memory '".$this->filename."'\n";
    }
}

class LargeFileEncrypter implements FileEncrypter {
    private $filename;
    function __construct(string $filename) {
        $this->filename = $filename;
    }
    public function encrypt() {
        return "Now splitting up '".$this->filename."' into small chunks and encrypting each one\n";
    }
}

abstract class FileEncrypterFactory {
    abstract function getFileEncrypter(): FileEncrypter;
    function doFactoryWork() {
        $encrypter = $this->getFileEncrypter();
        return "FilesFactory: " . $encrypter->encrypt();
    }
}

class SmallFileEncrypterFactory extends FileEncrypterFactory {
    private $filename;
    function __construct(string $filename) {
        $this->filename = $filename;
    }
    function getFileEncrypter(): FileEncrypter {
        return new SmallFileEncrypter($this->filename);
    }
}

class LargeFileEncrypterFactory extends FileEncrypterFactory {
    private $filename;
    function __construct(string $filename) {
        $this->filename = $filename;
    }
    function getFileEncrypter(): FileEncrypter {
        return new LargeFileEncrypter($this->filename);
    }
}

function client(FileEncrypterFactory $factory) {
    print "Now running doFactoryWork() on a ".get_class($factory)." object\n"
        . $factory->doFactoryWork();
}

client(new SmallFileEncrypterFactory("smallfile.txt"));
client(new LargeFileEncrypterFactory("largefile.mp4"));

And the output is

Now running doFactoryWork() on a SmallFileEncrypterFactory object
FilesFactory: Now encrypting a small file in memory 'smallfile.txt'
Now running doFactoryWork() on a LargeFileEncrypterFactory object
FilesFactory: Now splitting up 'largefile.mp4' into small chunks and encrypting each one

In the above example, we are encrypting two files, one small text file and one large mp4 file.

And we have two factory classes, SmallFileEncrypterFactory and LargeFileEncrypterFactory, each for handling small and large files respectively. Both are independent of each other, however both implement the FileEncrypterFactory interface.

We also have a SmallFileEncrypter and LargeFileEncrypterclass both implementing the FileEncrypter interface. These two classes represent the objects the factories create.

The flow happens like this

• Line 60, where the client() function calls SmallFileEncrypterFactory, the doFactoryWork() method is called on that object.
• doFactoryWork() calls getFileEncrypter() which then returns the SmallFileEncrypter object. So, now our factory has created the intended object to handle encrypting small files.
• Then that SmallFileEncrypter object’s encrypt() method is run and does the encryption work it needs to do.

The same flow happens for the LargeFileEncrypterFactory call on line 61, resulting in the encrypt() method run on the LargeFileEncrypter object. But in that case the the intent is that a large file is split into smaller chunks and maybe those chunks are swapped to disk unlike the small files that may be encrypted only in memory.

Why take this approach?

• The client() function only needs to know about the abstract FileEncrypterFactory class and does not need to know about any particular factory; it accepts any type of factory that extends (inherits) the FileEncrypterFactory class.
  • An abstract class was used in this example because that let’s us have just one default implementation of the doFactoryWork() method for all factories.
• If we wanted to have another factory, perhaps for encrypting .zip files, we could create that new factory and a corresponding ZipFilesFactory class and adjust the calls to client(). No need to adjust the other already created classes.
• The factory classes only need to know about the FileEncrypter interface and can return any kind of class object that implements File.

Test if two strings are an anagram of each other.

What is an anagram?

I didn’t know what anagram meant, so I asked the interviewer to define it for me.

An anagram is where two strings have the same frequency of letters in them. For example “abc” and bac” are anagrams of each other. But “abc” and “aabc” are not because the former has one “a” and the latter has two.

Anyhow, I was able to answer the question and I think this contributed to me landing the job offer.

And I can say for sure if you don’t know something that you think might be important to solving whatever problem you are faced with (even when on the spot), don’t feel afraid to speak up and ask questions. A hiring manager wants to see you interacting and how you think.

Here is a video of me coding and explaining the solution.

Here is the code from the above video with slight modification to test the positive and negative case:

/**
 * Anagram example: "emike", "eemik"
 * 
 * This function will return true if the two strings have the same frquency of letters
 */

function isAnagram($string1, $string2) {

    if(strlen($string1) != strlen($string2)) return false;

    $a1 = [];
    $a2 = [];

    // count letter frquency of string1
    foreach(str_split($string1) as $key => $value) {
        if(!isset($a1[$value])) $a1[$value] = 0;
        $a1[$value]++;
    }

    // count letter frquency of string1
    foreach(str_split($string2) as $key => $value) {
        if(!isset($a2[$value])) $a2[$value] = 0;
        $a2[$value]++;
    }

    // compare the letter frquency between the two strings
    foreach($a1 as $key => $value) {
        if(!isset($a2[$key])) return false;
        if($a1[$key] != $a2[$key]) return false;
    }

    return true;
}

if(isAnagram("kmgke", "emikk")) print "is anagram\n"; else print "not anagram\n";
if(isAnagram("emike", "eemik")) print "is anagram\n"; else print "not anagram\n";

Then the output looks like this:

not anagram
is anagram

And by the way, I’ve since learned the count_chars PHP function performs the anagram test a little faster than the above solution and with only a single line of code (line 2).

function isAnagram3($string1, $string2) {
    return(count_chars($string1, 1) == count_chars($string2, 1));
}

Said differently, it’s where one publisher updates one or many subscribers (or “observers”).

Here is a simple example

<?php

class Observer {
    function __construct($string) {
        $this->name = $string;
    }
    function update($string) {
        print $this->name . " received message: '" . $string . "'\n";
    }
}

class Publisher {
    private $subscribers = [];
    function add(Observer $observer) {
        array_push($this->subscribers, $observer);
    }
    function sendMessage($string) {
        foreach($this->subscribers as $key => $observer) {
            $observer->update($string);
        }
    }
}

$publisher = new Publisher();
$observer1 = new Observer("Observer 1");
$publisher->add($observer1);
$observer2 = new Observer("Observer 2");
$publisher->add($observer2);
$publisher->sendMessage("Hello!");

And the output looks like…

Observer 1 received message: 'Hello!'
Observer 2 received message: 'Hello!'

In the above example, we start by creating a Publisher object. Then create an Observer object, passing it a string “Observer 1” as it’s name. Then we pass the Observer object to the Publisher via the Publisher’s add() function. The add() function then pushes the Observer onto an array of $subscribers. Meaning that we’ve saved or “subscribed” the Observer.

We do it again with a second Observer object.

And now we have two Observers subscribed to the Publisher.

Then we call the sendMessage() function on the Publisher object (and pass it a message string “Hello!”), which loops through the array of $subscribers (Observers) and calls their update() function, passing it the message string.

And the result is each Observer prints it’s name and the message that was sent by the Publisher.

Nice!

I think this capability can be very useful especially when only parts of an application might need that change and not all of it.

Let’s see some examples…

Lets take the Coffee Shop example

The example I see often used on many websites is where a coffee shop offers coffee and a number of extras like milk, sugar, spices, etc. that could be added to a cup of coffee.

• To avoid class explosion (making a class for every possible coffee combination), the coffee shop implements the Decorator pattern to compose whatever permutation of coffee a customer might ask for.
• They treat each of those parts as a “Beverage” (implementing a Beverage interface). To me that makes no sense, because sugar and spices aren’t a beverage.
• Anyway, they start with coffee object. Then inject that into sugar object. Then inject that into a milk object. And so on. Until the stack of objects unwinds and ads up a final price and description. To me this example isn’t very practical. Yes you could compose objects at run time any way you want but here it seems overkill. Instead why not just have an array of objects passed to a coffee object, then iterate through and add up their prices and descriptions vs use the Decorator pattern.

A more practical Decorator example

I think what’s more practical is extending an object (at run time) with a wrapper class, like this:

<?php

interface Logger {
    function log();
}

class SimpleLogger implements Logger {
    function log() {
        print "The info to log...\n";
    }
}

class VerboseLogger implements Logger {
    private $logger;
    function __construct(Logger $logger = null) {
        $this->logger = $logger;
    }
    function log() {
        print "Adding some additional info before...\n";
        if(isset($this->logger)) $this->logger->log();
        print "And adding additional info after\n";
    }
}

$simplelogger = new SimpleLogger();
$verboselogger = new VerboseLogger($simplelogger);
$verboselogger->log();

And the output is

Adding some additonal info before...
The info to log...
And adding additional info after

In the above example a SimpleLogger object is created and then injected into a VerboseLogger object. The latter wraps the former and adds some additional logging info (before and after) without adjusting the SimpleLogger class in any way.

I think this example is more practical than the coffee shop example because it could be that the SimpleLogger is already used many places within an application. And you may only want to extend a subset of those objects with VerboseLogger. Because you only need additional info logged at certain points.

Deprecating old code

Another example I’ve heard of (very similar to the above example) is to wrap old code that needs to be deprecated in some places and not in others. Let’s say we create a version two of our SimpleLogger class called “SimpleLoggerV2”. We might only want parts of the system to be adjusted rather than the whole thing to reduce risk of things breaking. By wrapping the old code with a decorator the old behavior can be adjusted or even ignored.

The Decorator Pattern is cool!

Whatever the case the Decorator pattern is nice and gives us flexibility to add behavior to existing objects at run time. And helps when we need to adjust behavior across part of a system vs all of it.

The Strategy pattern is a software design pattern that lets a class change its behavior at run time; helping to keep classes decoupled and re-usable.

Run time? Behavior?

I really like this description from Stackoverflow which seems like a real world use

(those duck and animal examples just don’t cut it for me!):

In this case, we could have a character class and also some weapon classes like gun or sword. The weapon classes may subscribed to an interface that says each weapon needs to implement an Attack() method. That way, the character class only needs to know about the interface and could accept any type of weapon at a given time.

Let’s take another example…

A calculator that wants to log it’s activity

Suppose you have a calculator class and all it does is crunch numbers. Add, subtract, etc.

You then want to extend that class to log usage to a file or a database.

Should you add that new behavior to your calculator class? You could but that would start to bloat your calculator class.

What about letting sub-classes (that inherit the Calculator class) implement logging behavior? Again, you could do this but the problem is what happens when two different sub classes want to log their activity. Now you end up with the same code possibly in two locations. Not good!

Instead let’s use the Strategy pattern! We will create an interface just for the logging and tell our Calculator class it should know about that interface. This allows our Calculator class to leverage any logging class that wants to implement that interface. And our Calculator class doesn’t need to know details about logging, just that it can log.

Here is some code (PHP) to illustrate:

<?php

interface Loger {
    function log();
}

class FileLoger implements Loger {
    function log() {
        print "now logging info to a file...\n";
    }
}

class DatabaseLoger implements Loger {
    function log() {
        print "now logging info to a database...\n";
    }
}

class Calculator {
    private $log;

    function __construct(Loger $log) {
        $this->log = $log;
    }

    function log() {
        $this->log->log();
    }
}

class ScientificCalculator extends Calculator {
    function someAdvancedFeature() {
        // tbd...
    }
}

$fileloger = new FileLoger();
$calculator = new Calculator($fileloger);
$calculator->log();

$fileloger2 = new DatabaseLoger();
$calculator2 = new Calculator($fileloger2);
$calculator2->log();

And here is the output

now logging info to a file...
now logging info to a database...

In the above code we have a Calculator class that has a private member variable $log.

We also have a Loger interface with concrete implementations FileLoger and DatabaseLoger to log to files and to a database, respectively.

When we create a new Calculator object, we also first created a FileLoger object and passed that into the constructor of the Calculator object. And our Calculator constructor is expecting a variable of interface type Loger; it doesn’t care about any concrete implementations of Loger. The Calculator class could accept a FileLoger or DatabaseLoger object and it doesn’t mater. It only knows about the Loger interface.

So the constructor stores the local $log variable to it’s private $log variable.

Then later we call the Calculator’s log() function, which in turn calls the private $log variable’s log() function, which again is defined in the Loger interface and that’s all the Calculator class knows about. It doesn’t care about how anyone implemented the log() function.

And we can create another Calculator after that with a different concrete implementation of the Loger interface and log to a Database. Or someone could create another concrete implementation to log to an API.

What’s also nice is we’ve got a ScientificCalculator class that inherits from the Calculator class and now it too can leverage objects that implement Loger and begin logging usage. It’s not shown in the code, but if you pass a Loger object into the ScientificCalculator constructor you’d get the same behavior as the Calculator object.

Decrypting a file based on file size

I like this example from a Stackoverflow contributor who actually used the Factory pattern along with the Strategy pattern to determine how to do data encryption (the algorithm that can change at run time) based on the size of the file in question.

I’ve copied and re-written the example here (and the language is Java):

File file = getFile();
Cipher c = CipherFactory.getCipher( file.size() );
c.performAction();

interface Cipher  {
    public void performAction();
}

class InMemory implements Cipher { 
    public void performAction() {
        // load in byte[] ....
    }
}

class SwaptToDisk implements Cipher { 
    public void performAction() {
        // swapt partial results to file.
    }
}

In the above example

• For small files less than 1 gigabyte, the InMemory class should be used to performAction(); meaning the entire file is read and kept in memory and the decryption is done there.
• Larger files should use the SwapToDisk class to performAction(); meaning parts of the file are read to memory and partial encrypted results are stored in tmp files.
• Line 2 is the Factory which will get the correct class object based on the file size. The Factory implementation is not shown and this line is just to give you an idea the Factory does exist.
• And line 3 is where the rubber meets the road and the Strategy pattern is used to run the performAction method (from the appropriate object).

So, this example differs slightly from the Calculator. With the Calculator we injected the Logger type into the Calculator object manually at run time. With the decryption example things are more dynamic and it’s the file size that determines which implementation (which object) of performAction() to use.

And now we can see the power of the strategy pattern. Super useful. It helps to keep our classes decoupled and re-usable.

Very cool!

The file was a database export from mysql (from a mysqldump command I had run).

And if you’ve ever run a mysqldump command you know those files can be pretty large / long.

It would be possible to move the file to your desktop, open it up in a text editor and do a find and replace, then move it back to the server. But large files take time to transfer and open up. And then you have to worry that did your text editor do something like add weird line endings to the file and will the file still work when it gets re-imported back to mysql?

So, why worry or do that when you have sed?

sed is a command line tool found in linux and let’s us modify text files (or more specifically “streams” of input).

In the below code example I am running a find command from the current directory (the “./”) and then telling find to run the sed command.

The sed command then looks at each file (the “{}”) that find picks up and in this case, replaces the string “olddomain.com” with “newdomain.com” (the “s” right before the “/”) all throughout that file. And it does that replacing “in-place” (the -i parameter) rather than printing the edited text to the console.

find ./ -type f -exec sed -i -e 's/olddomain.com/newdomain.com/g' {} \;

In my case, I was moving a WordPress website from one domain to another.

And actually, I ran the above code against the mysqldump file as well as the entire WordPress directory of files so that any reference to the domain would be found and replaced. Nice!

(WordPress likes to hardcode the domain being used into not only the database but also files, yuck)

However, I’m sure sed could be used for lots of other file or stream editing beyond WordPress migrations.

Happy sed-ing

Does our universe reside inside a black hole?

Some people think so, including me. I think at least it’s possible!

I thought it was so interesting I had to make a video…

Here is a video of me illustrating the main idea as I see it: since we know our universe is expanding, then if the space inside a black hole is also expanding (including space within the singularity) then they might be one in the same.

Think of it like this:

Concurrency is how you manage multiple things that need to run at the same time. Parallelism is running multiple things at the same time.

So, manage vs run.

With Concurrency, you may have two things that you need to get done but only one resource available to do them. Sort of like when one person is multitasking.

For example, you are cooking pasta for dinner!

You fill a pot full of water and put it on the stove to heat up. While the water is heating up you don’t wait for it to boil and move to another task. You select the noodles you want to cook and begin preparing the sauce. Then the water is boiling. Stop with the sauce and the noodles. And then back to the sauce and other things while the noodles cook.

You’ve taken multiple things (cooking noodles, preparing the sauce) and broken them up into smaller bits allowing you to do things concurrently instead of in sequence (finish the noodles and then finish the sauce), because in sequence would take way too long, right?

On the other hand, with Parallelism, you may have two things to do and have two resources to do them. One resource per thing. Or two people in the kitchen: one person cooking the noodles and one person preparing the sauce. That’s parallelism.

Are they the same? No!

Manage multiple things at the same time (concurrency) vs have multiple things run at the same time (parallelism).

Here is a 30 min video by Rob Pike explaining the difference. He uses the Go programming language to illustrate his ideas. But the ideas are not language dependent.

What is Concurrency? Give me a code example!

You may or may not get the Concurrency examples that Rob provides in his above video.

To better understand concurrency with a code example we can look at the idea of async await.

Different languages like JavaScript and C# (there are others) allow you to call a function and run other code while that function runs in case it happens to run long. Then of course once that long running function returns the other code pauses allowing your calling code to do whatever it needs to. Then your other code resumes and your program continues on.

Here is a JavaScript example of Concurrency:

import fetch from 'node-fetch';

async function cook() {
  await fetch("https://mikeshannon.com/heatTheWater");
  console.log("The water is now boiling");
}

cook();
console.log("Prepare the sauce");

In the above example, even though the console.log statement looks like it will complete after the cook() function, the console.log() will complete before the cook() function. That’s because we assume the cook() function is long running due to it calling fetch() and waiting for the website to return a response.

The “async” before the function keyword and the “await” before our fetch() command tells our program to begin running other things (in this case the console.log(“Prepare the sauce”)) while the fetch() is waiting on a response.

Running the code we get…

Prepare the sauce
The water is now boiling

We can take the example a little farther and cook some turkey pasta!

In this example we setup what we think will be long running tasks into async await functions: Heating the water, cooking the noodles and cooking the turkey. The other tasks of preparing the sauce and strainer are quick and won’t take as long.

import fetch from 'node-fetch';

async function heatTheWater() {
    console.log("Starting to heat the water");
    await fetch("https://mikeshannon.com/heatTheWater");
    console.log("The water is boiling");
}

async function cookTheNoodles() {
    console.log("Adding noodles");
    await fetch("https://mikeshannon.com/cookTheNoodles");
    console.log("Noodles are done cooking");
}

async function cookTheTurkey() {
    console.log("Starting to cook the turkey");
    await fetch("https://mikeshannon.com/cookTheTurkey");
    console.log("Turkey is done cooking");
}

heatTheWater().then(() => cookTheNoodles());
console.log("Prepare the sauce");
console.log("Prepare the strainer");
cookTheTurkey();

And let’s run it and get the response…

Starting to heat the water
Prepare the sauce
Prepare the strainer       
Starting to cook the turkey
The water is boiling
Adding noodles
Turkey is done cooking
Noodles are done cooking

Instead of doing one activity after another in sequence: heating the water, waiting for it to boil and then cooking the noodles, and then preparing the sauce and then turkey… our program decided to break things up and multitask (and act with concurrency) to make the most of it’s time (using async await in the code):

You can see from the response the program started with heating the water but that typically takes some time to start boiling. In the meantime it prepared the sauce and the strainer. Still waiting for the water to boil, it started cooking the turkey. Then the water started boiling, so right away it added the noodles. Then the turkey finished cooking. And finally the noodles finished cooking too.

Whew what a meal!

(Heads up each run may result in a slightly different response based on how long each fetch() request takes… but I think you get the idea)

Another example of a long running request is when a call is made to a database or any third party service and in that case you may not want that waiting to block your other code from running. And by leveraging the concept of concurrency it helps to make the most of what you have.

Concurrency let’s your code multitask. Whether or not it has one or multiple CPUs to run on.