This site needs a big update. My "About Me" is very out of date, especially the photo. I think 2017 was the last time it was updated.

Wondering if it is time to shut down, UniverseSite. It pains me to say it because it was my first big project that I saw through to the end and I learnt a lot whilst building it. But after 11 years, I am now only running it for old times sake, but it is costing money for no reason. I doubt anyone is actually going onto it and finding it useful.

Over the past 5 years, I have released a lot of domain names that I was holding onto with the hope of one day turning them into money making side projects.

I actually came back to this blog because I was looking for the step-by-step guide I once made for extending a volume on VirtualBox. I couldn't remember if I actually published it. It seems not.

Well I best get back to work. I am off for a week after today. Getting married next week. Maybe I will see you again some time. At least the SSL certificate is valid again until August.

Over the past year, you may have noticed that I have consistently posted every single week on a Friday. Where I haven't is because of the Ghost scheduler being faulty and not posting, but I have always had a post ready.

This was a challenge that I set myself and I actually started last October. It really was a challenge!

Finding stuff to write about every single week was hard. Some weeks were easy as I may have encountered a problem or learnt something in my day-to-day work that I got to talk about. I also had a list of ideas of things that I wanted to try out that I think would be cool. But some weeks, I would get to Thursday with still no idea what to write.

I am also a terrible procrastinator, so I really would leave things to the last minute by which time, it was too late to write about things that were a little more involved.

But I felt that I had to complete a full year of this and now that the year has finished, I can now stop with the weekly posts.

I am still going to blog, but it will be when I have something to post not forcing something out every single week.

On the whole, it has been a great experience as it has forced me to learn things that I probably would not have if I didn't have this pressure to write. There is also stuff that I blogged about that has been in drafts for as long as this blog has existed (the crazy programming language challenge, for example). I also covered many topics that I myself have looked back on when I have needed that knowledge again.

Committing one post a week was taking up all of the time that I had for side projects. But now that I have that time freed up again, I can now pursue other projects.

I am not going to list here all the things that I hope to do, as quite often, I never stick to it. Back in 2014, I wrote about what I wanted to do in 2015. These included building an android game and writing a book. As we enter 2018, these are still on my list as not done - so I think this shows how I don't really stick to things. Even back then, I said, "I have found if I write all these in a list, I will get none of them done".

Other cool things from that happened this year include (but are not limited to):

• I became a Twig certified designer
• I made my first ever contribution to an open source project (the ability to specify a side to the trim function in Twig!)
• I went to multiple great conferences, most notably, the annual PHP Conference as well as JeffConf which was great
• Many day trips and events throughout the year including a great holiday in Cornwall
• I finally did a stadium tour of White Hart Lane stadium before it was demolished
• I became a Tottenham season ticket holder which was a surprise

It is always exciting to look at the year ahead with its endless potential to be amazing and I will do what I can to make that potential become reality.

I hope you all have a successful and fulfilling 2018!

The example I will go through is based on the one given in the book, PHP Master - Write Cutting Edge Code, which I would highly recommend anyone learning PHP.

What is the Observer Pattern?

It is basically a way of triggering code to run when certain events happen. If you are familiar with Javascript, then this concept will be familiar.

In Javascript, you might attach a function to a "click" event of a button which gets run every time that particular button is pressed.

This pattern allows you to do something similar in PHP. You can register a "listener" and then trigger it when you like. Let's take a look how this works.

The Event Class

This class will be responsible for storing and running all of the code. It will be made up of static properties and functions so that it can be accessed anywhere in the code base.

class Event
{
    static private $callbacks = [];
}

First we have an array that will store all of the event names and the functions to run when they are invoked.

static public function register(string $eventName, $callback)
{
    if (!is_callable($callback)) {
        throw new Exception('Must register a callable, '.gettype($callback).' given.');
    }
    self::$callbacks[strtolower($eventName)][] = $callback;
}

Next we have our register function. It takes 2 parameters: a name and a callback. The callback is typically expected to be a closure (which I covered here), but can also be an object.

The function throws an Exception if it is not a piece of code that can be run. Otherwise, it adds it to the array. Note that I have allowed for multiple functions to be run with the same event name.

Next we need a way to trigger it. So there is another function:

static public function trigger(string $eventName, $data = null)
{
    if (isset(self::$callbacks[strtolower($eventName)])) {
        foreach(self::$callbacks[strtolower($eventName)] as $callback) {
            $callback($data);
        }
    }
}

}

Again, very simple. It takes 2 parameters, the name and, optionally, data that you wish to pass into the callback function.

If the name exists in the listener, it loops through all the attached functions and runs them.

So simple.

Using the Event Class

In my very simplistic example, I am just going to register and even called "my_event" using the class that I just made:

Event::register('my_event', function($data) {
    print $data."\n";
});

You can see that I pass the function as the second parameter directly and all the function does is print the data parameter.

Now let's say somewhere else in the code I have a function that does something, I can now trigger the event each time it is run:

function doSomething()
{
    print "I did something\n";
    Event::trigger('my_event', date("Y-m-d"));
}

So this function prints some text then triggers the event "my_event", passing the date as the parameter. As we set up the event earlier, it will just print this.

So if we run this function:

doSomething();

We get the following output:

Summary

Obviously in this very simple demo, it seems silly to use events at all, but this is very useful pattern to use in your more complex systems and very easy to set up.

For example, you can trigger things like writing to a log or clearing some cache or sending an alert. It can make your code far more tidy having this all in one place!

I thought I would revisit this to remind myself of how it works and see what new things have happened.

It seems that it is even easier now than ever before to get started with real-time web applications. Where as before I built a websocket server that had to be on and handle the messages, there are now services that do all of this for you.

An example of this is Pusher. They provide the service for building real time web applications along with tools to monitor usage and a really simple API that does most of the work for you.

There is a free tier that is especially good if you just want to have a play. I won't go into details here how to sign up or a guide to their interface because they do a pretty good job of all that and it is pretty straight forward.

In fact, they even provide a very easy to follow basic code in whatever language you are using, to get you started (some of which this demo is based off).

The demo will build a very basic chat room with no rules or security at all. You just go on and send messages and they appear for everyone that is viewing the page.

HTML

I have put together a very basic HTML page with some help from Bootstrap as well as some inline styles.

The bulk of it looks like this:

<div class="container">
    <h1 class="text-center">My Chat Room</h1>
    <div class="row">
        <p class="col-xs-12">Messages:</p>
        <div id="messages" class="col-xs-12" style="height:400px; overflow-y: scroll; border: 5px solid #000;"></div>
        <div class="col-xs-12" style="margin-top: 20px;">
            <input type="text" id="my_message" class="col-xs-8" />
            <button id="send_message" class="col-xs-4">Send</button>
        </div>
    </div>
</div>

Which gives an output that looks like this:

The idea is that when I type something into the text box and click Send, it will update the messages box. This would happen on all who are logged onto the page.

First, let's handle receiving messages from Pusher.

Receiving Messages from Pusher

First I create a new app. It rather helpfully provides a clear example of how to use their library based on what technologies you use. So it is useful to select this albeit optional:

Now back to our code.

First, I need to load the Pusher library into the web page:

<script src="https://js.pusher.com/4.1/pusher.min.js"></script>

Next, I need to connect to the API, using my key. The demo code they provide has this boiler plate:

var pusher = new Pusher('api-key-goes-here', {
    cluster: 'eu',
    encrypted: true
 });

Finally, I open up a connection and start listening to a particular channel:

var channel = pusher.subscribe('messages');

I could have called this channel anything I wanted, but I named it "messages" in this case.

It should be obvious at this stage that I could have multiple different channels, listening to different things.

Now, I can tell it what to do when it receives data from the channel:

channel.bind('message-received', function(data) {
     alert(data.message);
});

Again, I could have different names for the events being sent, but I call it "message-recieved". You can see that I specify a function that gets the data as an argument. This data is in the form of JSON so can be accessed as such.

In this case, I am simply opening an alert showing what is in the message key.

I can test this using the Pusher debug console where I created the app.

It allows me to send a message on a channel and with a label that I specify with any data that I like to this particular app:

You can see my data is in the form of JSON and I have a key called "message" with the text, "Hello". You can also see underneath all that, that is has acknowledged the fact that there is one client online and listening to this app.

Sending the message causes the pop-up to show with my message there:

Thus proving that my front end is successfully connected.

Now we just have to make it do something a little more useful, that is, put the message inside the box. This can be done with a single line replacing the alert:

$('#messages').append('<p>'+ data.message +'</p>');

Server Side

So now we are successfully receiving messages and updating our screen accordingly. Now we want to be able to actually send messages from our browser.

To do this, we need some code on the server side to receive a message from the browser then send it on to Pusher. I have created a file called "message_processor.php".

First we need to install the Push SDK again. We can use composer for this which is great. So in my composer JSON file, I have the line:

"pusher/pusher-php-server": "v3.0.*"

Then I can just include it into my server file by requiring the vendor autoload file:

require __DIR__ . '/vendor/autoload.php';

Now I want to check if I have received a post request with the message and if I have run some code:

if ($_POST['message'] && !empty($_POST['message'])) {
    $message = $_POST['message'];
}

Next, within the if-statement, I wan to connect to the app again. As you can see, I pass the app id and the API key and secret key. These can be found under App Keys tab on the pusher website.

$options = [
    'cluster' => 'eu',
    'encrypted' => true
];
$pusher = new Pusher\Pusher(
    'KEY',
    'SECRET',
    'APPID',
    $options
);

Finally, I can now simply use my pusher object to broadcast the message to the app:

$data = [
    'message' => $message
];
$pusher->trigger('messages', 'message-received', $data);

As you can see, I am forming an array to send. I then call the trigger function with channel that I am sending it to and the label for that message. It seems silly sending back the message that I just sent, but remember, everyone who is currently on that page will see it appear like magic on their screen.

Connecting it all up with AJAX

Now that I have done the backend code, I want to send a message to it when I press the button. To do this, I make a simple click event function and within this function, I call some AJAX (I covered AJAX in last week's post!):

$('#send_message').click(function(e){
    e.preventDefault();
    $.ajax({
        url: "/pusherdemo/message_processor.php",
        data: {
            message: $('#my_message').val(),
        },
        type: "POST",
        dataType: "json",
        beforeSend: function() {
            $('#send_message').attr('disabled', 'disabled');
        },
        success: function(json) {},
        complete: function(json) {         
            $('#send_message').removeAttr('disabled');
            $('#my_message').val('');
        }
     });
    return false;
});

As you can see, it sends the contents of the input to the message processor and then clears it. It doesn't do anything in success because it doesn't need to.

Again, it seems a bit weird not using the success function to update the messages, but remember, only YOU would see that. This way, everyone on this chat room will see the message that you just sent.

Now I can't really demonstrate it in the blog post, but all of the above code does work. Here is a screenshot of 2 different browsers both connected to the same page. You can see the messages that I already sent have appeared on both even though I only sent from one:

Summary

Once again, I have only scratched the surface with what is possible with WebSockets and Pusher with an incredibly simplified demo.

But I hope it shows just how quick it is to get started!

I think right now every person developing for the web should have this in their toolset.

This blog will go over the common way that I use it with the help of jQuery.

AJAX and JQuery

AJAX stands for "Asynchronous JavaScript And XML" and provides a way of making web requests from a web page asynchonously. This is incredibly powerful as it means you can do all kinds of tasks without having to make your user wait or without refreshing the page.

So I am cheating a little when I use AJAX by using JQuery's wrapper of it. You can use it in pure javascript and I am sure there are plenty of tutorials on that, but it is a little bit more wordy than this way.

If you are already using JQuery in your project, then it makes sense to use it to handle your AJAX requests.

The full documentation on how to use it can be found here.

Demo

I have a very simple page with 2 elements:

<h1 id="response"></h1>
<button id="my_button">Make Request</button>

When I click the button, it will send an AJAX request and populate the <h1> tags with the response.

Let me just show you the Javascript then I will talk through each section:

$('#my_button').click(function(e){
    e.preventDefault();
    $.ajax({
        url: "/ajax/ajax.php",
        data: {
            name: "Antony",
        },
        type: "POST",
        dataType: "json",
        beforeSend: function() {
            $('#my_button').attr('disabled', 'disabled');
        },
        success: function(json) {
            $('#response').html(json.timestamp + ': ' + json.greeting);
            var t = new Date().getTime();                 
            while (new Date().getTime() < t + 5000);
        },
        complete: function(json) {         
           $('#my_button').removeAttr('disabled');
        }
    });
    return false;
});

OK.

The first line is a basic way of saying that when I press the button with the ID of "my_button", to run the function. Standard jQuery.

The AJAX request is made up of many parts:

url - the is the location to make the call. In this case it is just a PHP file in the same directory. But it could be anything from a 3rd party API to literally another website.

data - this is data that you want to send with the payload to the above URL. Again, this could be anything including data from a form. I have hardcoded my name. You will see later how it is received.

type - this specifies the HTTP method. Usually it is a POST or GET request. In this case, we are sending the data as a POST request, so the code at the URL should be expecting that.

dataType - this tells the AJAX what MIME type to expect the response. If you do not specify anything, it will try and guess. Here, I am explicitly saying to parse the incoming response as JSON.

beforeSend - this can be used to specify a function to complete some task before sending the request. Just like I have here, I usually use this to disabled the button to prevent further requests from being sent whilst the AJAX is waiting for a response. Remember, by default, this is non-blocking, so the user can still interact with the page whilst waiting. Other use cases could be to set some kind of message or loading graphic.

success - this is the function that is run when the AJAX completed successfully. You can see that the function takes a single parameter which is the response. In this case, it is all in JSON. In my function, I am setting the HTML of the h1 element with the contents of the JSON. I am also holding the execution for 5 seconds so that the disabled button could be seen otherwise it is too quick.

complete - whether the success function runs or not, the complete function always run. This can be used to do any tidying up or to relay a message to the user. In this case, I re-enable the button by removing the attribute.

And thats it! It is really straightforward to put together a simple request.

Now a quick look at ajax.php:

<?php
$name = $_POST['name'];
$response = [
    'greeting' => "Hello, $name!",
    'timestamp' => time()
];
header('Content-Type: application/json');
echo json_encode($response);
return true;

Obviously how you deal with the request and return and the response depends on how your project is set up and any frameworks that you are using. For this demo, it is really simple.

First, you can see that I interact with the $_POST array to get the data that was sent. The key matches the key in data and I am accessing it in $_POST because it is a request of type "post" (as we set earlier).

I simply put together an array and json_encode it and set the header and echo back the result.

If you look at the network tab in the dev tools, you will see the request being made and the JSON response:

Summary

So as you can see, using AJAX is very very easy and I have only just scratched the service. It is so useful for triggering non-blocking events to give a smoother website experience.

Once again, the full guide on what you can do with jQuery's AJAX can be found here. It covers all of the options that I went over in this post and many many more.

I think this one is a relatively low-key release in terms of language changing features. A few small things here and there but nothing too big. But here is a selection of changes.

A full list with further details can be found here.

Overview of Versions

So now is a good time to take stock of what versions of PHP are currently supported.

If you are on anything less than PHP 5.6, you are in trouble and you have been for a while. Security support for 5.5 ended some time in the middle of 2016.

PHP 5.6 is no longer getting active support, but is going to to continue to get security support until 31st December 2018. This means that bugs are only going to be fixed if they pose a security threat. It also means that you have also got just over a year to make the leap to PHP 7.

If you are on 5.6, it really isn't that much of a big jump to get to PHP 7 in terms of backwards incompatible changes.

PHP 7.0 ends its active support in 2 days on the 3rd of December 2017 and will continue to get security fixes until the same time next year. So if you are still on this version, I would suggest skipping 7.1 and upgrading straight to 7.2 and now is the time to start thinking about doing this.

PHP 7.1 has active support for another year and security support until today in 2019.

PHP 7.2 obviously has 2 years of active support ahead of it now and a year of security support following that.

Features

Override Argument Type Annotations

Let's say that I have the following class:

class MyClass
{
    public function myFunction(int $var)
    {
        return $var;
    }
}

It has a single function called myFunction that takes a single argument that has been specified as being an integer. All it does is return the argument as it is.

Now if I make another class that extends the one above:

class MyChildClass extends MyClass
{
    public function myFunction($var)
    {
        return $var;
    }
}

I have overridden the function, myFunction and although it does the same thing, it no longer has the type hint.

If I now use this class:

$obj = new MyChildClass;
var_dump($obj->myFunction(3));

This would give me the expected result but it will come with a warning:

PHP Warning:  Declaration of MyChildClass::myFunction($var) should be compatible with MyClass::myFunction(int $var) 

This warning will no longer occur from PHP 7.2 onwards. I am not sure how useful this feature will be. In my mind, it could lead to laziness when inheriting from libraries as it is no longer forcing you to use a type.

But apparently it "complies with contravariance of method argument types under the Liskov Substitution Principle". Who am I to argue with Liskov?

Override Abstract Function With Another Abstract Function

Let's say I have an abstract class:

abstract class MyClass
{
    abstract function myFunc(int $param);
}

And another that inherits it:

abstract class MyOtherClass extends MyClass
{
    abstract function myFunc(int $param):int;
}

In my inherited class, I override myFunc with another abstract function and even give it a return type.

Now if I implement this abstract class and use it:

class FinalClass extends MyOtherClass
{
    public function myFunc(int $param):int
    {
        return ($param * $param);
    }
}
$obj = new FinalClass;
var_dump($obj->myFunc(3));

I would get an error:

PHP Fatal error:  Can't inherit abstract function MyClass::myFunc() (previously declared abstract in MyOtherClass)

You could not inherit an abstract class in this way. From PHP 7.2, you can. So the above code would run successfully and give me the result:

int(9)

Trailing Comma in Group Use Statements

From PHP 7.0, you have had the ability to group use statements like so:

use SomePackage\{
      MyClass,
    AnotherClass
};

But if you had a trailing comma like this:

use SomePackage\{
      MyClass,
    AnotherClass,
};

You would get a parse error:

Parse error: syntax error, unexpected '}', expecting identifier (T_STRING) or function (T_FUNCTION) or const (T_CONST)

From PHP 7.2, you are now allowed to have the trailing comma. This makes it possible to do cleaner diffs when doing source management. It is why it is often down in long arrays (I personally hate it though).

The original RFC had a few different places to have the trailing comma allowed but this was the only one that was accepted.

Object Type Annotation

PHP 7.2 brings another type that you can use to type hint with called 'object'.

Take the following:

class MyClass
{
     public static function myFunc(object $param)
     {
         return $param;
     }
}

If I try to use the function and pass it a generic object:

var_dump(MyClass::myFunc(json_decode('{}')));

I get a fatal error:

Fatal error: Uncaught TypeError: Argument 1 passed to MyClass::myFunc() must be an instance of object, instance of stdClass given

Because it is expecting some object that is an instance of a class called "object". But as of 7.2, "object" is a reserved word, and the code runs correctly.

This is a very useful addition as it gets rid of the need for the is_object check that one would normally have to do in this case.

MCrypt Now In The Crypts

This is actually something removed rather than added and I have included it as it is the biggest change that effects me personally.

In PHP 7.1, the Mcrypt extension was deprecated. Now it is completely removed. This is because libmycrypt has not been maintained for 10 years! So it is now considered insecure and even if you are not planning upgrade, you should stop using it.

Alternatives that you can use are OpenSSL or, new to 7.2, libsodium. The functions are very similar so porting across should be straightforward.

If you absolutely can not migrate away from it but really want to upgrade to 7.2, it is still available as a PECL extension so could be installed separately (but you should seriously just scrap it completely).

Summary

So there are just a few of the features added (and removed) in this latest iteration of PHP. You can read about these and the rest of the release notes here on the PHP website.

It is the idea that instead of purchasing a server (or paying a provider for one), you give the provider the functions that you want to run and they will be responsible of putting it on the server and maintaining that side of things.

It is essentially "serverless" to you, the user, as you don't need to worry about any of that kind of stuff. You also only pay when the function is called making a lot cheaper than a dedicated server in certain cases.

My problem so far has been the lack of support for PHP functions. If you know Node or Python, then you have loads of choices to set it up including AWS Lambda.

That was until I went to the above conference and became made aware of Bluemix functions: an IBM implementation of OpenWhisk which is an "open source cloud platform".

For basic executions of up to 5,000,000 executions a month, its free. This experimenting fall well within that price bracket.

Rob Allen did a great blog post to get started using it and that is what I used to get me started to write this one.

Installing the CLI

First thing that you have to do is sign up to IBM Cloud. This the new name for Bluemix, although you will still see the name used for the functions.

Here is the link,

The process is pretty self explanatory. You don't even need payment details. I would advise you put in a name for company even though it is optional as this is used in the URL for your functions later. If you leave it blank it uses the e-mail in the URL which is something you may not want public if you plan on sharing it.

You could create and modify your functions on the web interface but there is a CLI plugin which is probably more preferable as you can then develop on your own setup.

There are instructions for Windows, Mac and Ubuntu. I used Ubuntu so can only speak for that.

First you download the package:

curl -fsSL https://clis.ng.bluemix.net/install/linux | sh

The website then goes through the 4 steps of setting it up which I won't copy and paste here. They even personalise it to pre-fill your e-mail address for settings etc.

The Code

The code for a single function is pretty straightforward. You have a file with a function called "main" which can call other functions or do everything itself.

My example is a simple quadratic equation calculator. It takes 3 parameters a, b and c and does the calculations based on the formula:

So here is the code. I will go through the points of interest for this post below:

function main(array $args) : array
{
    $ouput = [];
    $error = '';
    foreach (['a', 'b', 'c'] as $part) {
        if (isset($args[$part])) {
            if (!is_numeric($args[$part])) {
                $error = $part.' is not a valid integer.'.$args[$part];
                break;
            }
        } else {
            $error = 'Missing value for '.$part.'.';
            break;
        }
    }
    if (!empty($error)) {
        $output['runtime_error'] = $error;
    } else {
        extract($args);
        $value1 = (($b * (-1))+(sqrt((($b**2)-(4*$a*$c)))))/(2*$a);
        $value2 = (($b * (-1))-(sqrt((($b**2)-(4*$a*$c)))))/(2*$a);
        if (is_nan($value1) || is_nan($value2)) {
            $output['runtime_error'] = 'Not a valid quadratic equation.';
        } else {
            $output['x1'] = $value1;
            $output['x2'] = $value2;
        }
    }
    return $output;
}

So the first point of interest is the function signature:

function main(array $args) : array

As you an see, it is called "main" takes a single array called "$args" and has a return type of "array".

$args contains all of the parameters that you call with the function (if any) where the key is the name and value, the value. More later how we pass these but for now accept that they go into the array.

The code itself starts off by validating the input parameters, making sure they are numbers and that none of them are missing. All of the response is going into an array, $output, that is returned at the end.

One thing to note that is that if there is an error, I called the response key "response_error". This is because when it was "error", I got unusual results when running this script on the web.

The returned array is transformed by Bluemix into JSON by default if you do not specify anything.

The rest of the code is doing the calculations. That is not important for this blog so I will leave you to look through that.

Installing and Calling

Once you have done your code, it is time to send it to IBM to host.

To do this, you use a simple command:

bx wsk action update nameOfFunction /path/to/file.php

This will create (or update if it already exists) a function of the said name with the code that you send.

You can see the list of installed actions with:

bx wsk action list

To run a function, in the command line do:

bx wsk action invoke --result nameOfFunction

If you want to add parameters use the param flag:

bx wsk action invoke --result nameOfFunction --param nameOfParam valueOfParam

So with my quadratic equation example, here is me calling with with various parameters to show the error handling.

Note, this is before I changed $output['error'] to $output['runtime_error'], so the response says error. Also note that the response is automatically sent as JSON by default.

If I pass it valid parameters, I get the 2 values of x.

Making it available on Web

Of course one thing you will want to do with these functions is the make them available on the web. This is very easy to do.

When you install the function on IBM, you can add another flag:

bx wsk action update nameOfFunction /path/to/file.php --web true

Now to see the URL, you can do:

bx wsk get nameOfFunction --url

This will give you the full URL of you function. You can then hit this in any web browser and IBM will give you a formatted JSON response. To add parameters, you can do it in the normal way expected on the web: ?param=value&param2=value2. So after doing this with my function, let's see it on the web:

Summary

As you can see, it is incredibly easy to get started with serverless code in PHP. As usual, I have barely scratched the surface with what is possible and I look forward to experimenting in the coming weeks.

No longer do you need to pay for an entire server environment to run a few simple lines of code!

Once again, check out Rob Allen's blog post which helped get me started. He has also done a few more posts delving deeper into what you can do and has a link to a Git repository with more sample code.

This week I will show how I solved the 2 more problems: lighting and power.

Lighting

Night vision cameras can't actually see in the dark. Like all other cameras, they still need light. But the light they can see is infra red light which is what separates them from the rest.

So most night vision cameras, have an infra red light that is invisible to human eye, but lights up an area perfectly for a camera to see.

For this project, I decided to use the IllumiPi kit, which provided all of the power cables and components hook up most IR lights. I also bought this light which is compatible with the camera and IllumiPi.

It needs 12V to power it and I originally bought a battery pack for 8 AA batteries. More on this in the next section.

So I followed the instructions and when I finished plugging it all in, it looked like this, roughly:

The black cables are ground and red live. The light and battery live cables actually join together on the breadboard.

You can see that the live cable plugs in the Pi at GPIO 24. This will become important when we do the code.

The way that I understand it works, is that the voltage regulator (that black thing) completes the circuit and is sort of a switch depending on if GPIO 24 is on or off.

Next I had to add code.

Last week I went through the code that uses the motion sensor to trigger the camera.

To this, I added the lights.

As I said above, the circuit is completed by the cable plugged into GPIO 24. So first I set this pin up for output:

LIGHT_PIN = 24
GPIO.setup(LIGHT_PIN, GPIO.OUT)

Next, inside my while loop all I had to do, was turn the light pin on and then off:

while True:
    if GPIO.input(PIR_PIN):
        filename = time.strftime("%d_%m_%Y_%H_%M_%S")
        GPIO.output(LIGHT_PIN, GPIO.HIGH)
        time.sleep(1)
        camera.capture('/home/pi/pic_'+filename+'.jpg')
        GPIO.output(LIGHT_PIN, GPIO.LOW)
        print "Picture Taken"
        time.sleep(3)

The key line here is:

GPIO.output(LIGHT_PIN, GPIO.HIGH)

Which turns in on. And then after the picture is taken:

GPIO.output(LIGHT_PIN, GPIO.LOW)

To turn it off.

I added a delay of 1 second in between turning it on and taking the picture as I found it took the picture too quickly after it was barely on.

Also it should be noted that the light array I am using has a built in sensor so that it won't switch on if it is too light around it.

And that is it! That is all it took to add the lights!

Powering Up

As I previously mentioned, my biggest blocker was figuring out how to power everything without mains electricity.

The lights require its own 12 volts of power. I originally bought a pack that held 8 AA batteries to achieve this. But I was pretty disappointed with this solution as it was very big.

One of the reasons for doing this project with the Raspberry Pi Zero was because of its tiny size. The 8 AAs negated this.

Upon revisiting this project this year, however, I discovered that you could get a single, fairly small battery that provides the required power! They are called 23A batteries.

I bought this from E-Bay which also had the holder for it to plug in. I am delighted with how small it is!

The Pi itself, I am powering with a Lithium Ion battery. I bought this one from Pimoroni. I also bought the Zero LiPo which provides the interface to plug it into the Raspberry Pi and is designed to be small enough to use with the Pi Zero. I had to also buy a charger for the battery so chose this one.

It would be nice if one day I figure out a way to have only one battery powering both AND the charger built in. But for now, this will do.

Summary

So that's it really! The last thing to do is solder it altogether and find suitable housing for it. I may do another blog post in future to show the finished product and the results I got from it.

I funded a Kickstarter a while back to get this protoboard which will allow me to solder it all together and keep it small. As for the housing, it seems I will have to make some home made. We will see.

I am quite excited to finally get this finished in the next couple weeks! I hope the last couple of blog post have been enough to get you started on similar projects.

I hit a few challenges along the way and then some months went by without doing anything and now that we are back around to November, I decided to dust it off and give it another go.

Parts

Raspberry Pi Zero
The center piece of this entire thing. It is basically a much smaller version of the standard Raspberry Pi with a size of 65mmx30mmx5mm. The trade off for this is that it is slightly less powerful in terms of processing power and you have to solder on your own pins, but the version that I bought introduced the camera slot which was crucial for this. They have since released a version that has built in Wi-Fi, but the version that I have doesn't.

Pi Noir Camera Module
This is a Raspberry Pi compatible night vision camera. By night vision, I mean that it detects infra-red light (which is what we will use to light up the night instead of visible light). It works with any Raspberry Pi that has the camera port and the libraries for it are already installed on the OS.

Raspberry Pi Zero Camera Adapter
As the Pi Zero is smaller, so is the camera port. For that reason, to use the above camera on a Pi Zero, you will need to buy this ribbon. The ribbon on the camera is easily interchangeable so that makes it very easy.

PIR Motion Sensor Module
Finally, I used this motion sensor to trigger the camera. It requires no additional software and can provide input to the Raspberry Pi depending on whether it detects movement or not.

Mini RTC Module
This is not necessary for the camera itself but I wanted to make sure that the Pi had the correct time when I switched it on so that the photos have the correct timestamp. The Pi has no built in ability to keep the time when it is switched off. Instead, it uses the Internet to sync the clock when it boots up. As my camera will not have Internet access, this was not possible. This module is basically a clock with a battery built in that keeps the time. I then have to configure the Pi to use this time instead of its own.

How they connect

I tried to make a diagram to illustrate this but it took too long, so here is a an image of the pins on the Pi Zero and I will describe it to you (found here):

This is actually an older version of the Pi that doesn't have the camera port.

The motion sensor has 3 inputs that I connected with jumper cables. The power input which was plugged into number 2 that provides 5 volts of power. The ground cable that completes the circuit, I plugged into number 6 (but could have plugged into any of the other ground pins). The data pin that actually provides input could be plugged into any of the GPIO pins but I plugged it into pin 19 which is GPIO 10 (this become relavant in the code).

The clock could have been conntected with jumper cables, but I plugged it directly onto the pins such that power plugged into port number 1 which provides 3 volts. It takes 5 pins (so 1, 3, 5, 7 and 9). Plugging into the board directly is a lot cleaner than 5 more cables.

Here is a photo of everything plugged in together:

The code

Lets start with programming the motion sensor and camera. What I want is for the camera to take a photo when the detector detects movement.

You may already know that scripts in the standard Pi OS are generally written in Python and there is no exception here.

Here is the script and an explanation of each part:

import RPi.GPIO as GPIO
import time
from picamera import PiCamera

So here, I am just importing some built in libraries that I will use later. The most notable one is the PiCamera.

GPIO.setmode(GPIO.BCM)

You may have noticed from the above diagram that there are different ways of numbering the pins. This just sets it so that we use the GPIO numbers.

PIR_PIN = 10
GPIO.setup(PIR_PIN, GPIO.IN)

Here, I am creating a variable that stores the GPIO pin number of the data input of the motion detector. If you remember earlier, I plugged it into GPIO 10. I then set up that pin to expect an input (rather than an output).

try:

except KeyboardInterrupt:
    print "Quit"
    GPIO.cleanup()

The entire code will go within the try block. This is because it will run until I stop it with the keyboard. When I do that, the KeyboardInterrupt is detected and the program ends cleanly. GPIO.cleanup() is important as if I didn't do this, when I run the script again it will error as it attempts to reassign an already in use pin.

Within the try block have the following code.

print "Motion Triggered Camera"
camera = PiCamera()
camera.exposure_mode = 'night'
time.sleep(2)
print "Ready"

The printing and sleeping is just for aesthetics (which won't be necessary when this program runs in the background). The important part here is that I am creating a new camera object and setting it to be in night mode.

while True:
    if GPIO.input(PIR_PIN):
        filename = time.strftime("%d_%m_%Y_%H_%M_%S")            
        camera.capture('/home/pi/pic_'+filename+'.jpg')
        print "Picture Taken"
        time.sleep(3)

So I have a while loop as I want the program to keep working until I stop it. I have an if statement: GPIO.input(PIR_PIN). So on every loop (which runs split seconds at a time) it will check if it received an input from the motion detector. If it did, it will run the code beneath it. If not, the loop will come round again and it will run the if statement again.

I supposed in theory there is a possibility that you could be detected in between the if statement failing and the next loop starting and not be captured, but this is hard, which is why there are delays when the picture is taken.

So I create a new file name using the current date and time.

I simply run the capture function passing it the full path to save the picture as a parameter. It really is that simple!

I added a 3 second delay otherwise I would be flooded with pictures if something passed by the camera. So for 3 seconds, it will not attempt to check the motion detector again.

And that's it really! With just a few lines of code, I was able to get a motion triggered camera up and running.

Now for the clock. This required a system setup rather than code. I used this tutorial to set it up.

I won't copy and paste the instructions here. Go and check them out as they are pretty easy to follow. Once I had that, I was able to keep the correct time for the Pi even between power ups.

Summary

So that is Phase 1 of my project complete. In reality I actually add to clock last but I changed the order for these blog posts. But you can see just how simple it was to add a simple detector.

Next time, I will talk about how I added infra red illumination as well as how I powered it all away from the mains!

1. Brainfuck
2. LOLCODE
3. Whitespace
4. Piet
5. MalbolgeZombie <- You are here

This week was supposed to be Malbolge. I know that all these programming languages have had a degree of difficulty, that is almost a requirement of esoteric programming languages, but Malbolge was just a different level of difficulty. After many hours of studying it, I had to admit defeat and change the language for this final part.

You can have a go with this language yourself if you fancy a a challenge. Here are some links to get you started:

• Wikipedia page with further links
• Archive copy of the official website

I actually picked these 5 languages when I planned to do this series all those years ago and had the original draft saved all of this time.

Now I am changing this last one (regretfully to be honest), I decided to go with something to go with the spooky theme as it was Halloween on Tuesday - hence I have chosen Zombie.

Overview

Zombie is an acronym that stands for Zombie-Oriented Machine-Being Interface Engine and is designed for evil necromancers to do evil things.

One important aspect is that it runs a multithreaded environment. This means multiple entities can run at the same time and in parallel.

Entities are structural units of code. They have different types such as zombies, ghosts, vampires and demons (and many more).

Each type has a slightly different behaviour and have slightly different commands to use them. We will only focus on the most basic type which is zombie.

Zombies are very straightforward: they run each task sequentially and don't start the next one until the previous one has finished.

Another example is Ghosts. These run tasks whenever they feel like it. They will eventually run all the tasks but there is an undetermined amount of time between them.

Full details of the different types and the commands that can be run can be found here. It is fairly straight forward to follow and so I don't want to just regurgitate what is written.

Installing and Running

I am using this interpreter that is written in Python. I am not sure how closely it follows the language specification, but was very easy to use.

Simply copy the code into a new .py. Then in the terminal, run:

python nameOfYourInterpreter.py zombieCodeFile.zom

I am not sure the .zom extension is actually needed, I just added that myself.

That is it. The code compiles and runs. Obviously, you will need to install Python on whatever machine you are working on. I will leave you to work that part out yourself.

Building "Hello, World!"

First we declare our zombie and give it name:

HelloWorld is a zombie

This is creating a zombie entity that will be run. Valid programs must declare at least one of these.

After declaring it, I then have to give it some "tasks". These are just like functions in normal programing languages.

The tasks are written inside a summon/animate pair:

summon
    //tasks go here
animate

Summon and animate mark the beginning and end of an entities task list.

It also sets the current entity as being active if it is a zombie.

We will have one task for printing Hello, World! to the screen:

task SayHello
    say "Hello, World!"
animate

As you can see, you have to use the task keyword follow by the name of the task to start it off. The end of the task is marked again with animate.

The actual code: say "Hello, World!" is pretty self explanatory and makes this very straightforward.

Summary

I have barely scratched the surface with what you can do with this language (mostly because I ran out of time as I wasted quite a lot trying Malbolge). As I said before, more details of what can be done and what is allowed can be found here. It is fairly high level compared to some of the others I have played with and so you can probably create some decent programs.

That brings the end to this little mini-series. I am sorry for the sort of rushed ending but this series has been in drafts for a bout 4 years and so to have finally completed and published it is a great feeling. I hope that you enjoyed it as much as I did trying out these languages.

They have inspired me a little bit to perhaps have a go at creating my own...

1. Brainfuck
2. LOLCODE
3. Whitespace <- You are here
4. Piet
5. MalbolgeZombie

This week, I am trying out Whitespace.

Overview

Whitespace is a language designed as it says on the tin. The only characters that it contains are whitespaces: Space, Tab and Line Feed.

This means an entire program just looks like a blank document if you do not highlight it. It is also incredibly harder to program in as you quite literally can't see what you are doing.

It works using a stack and heap model. The commands involving putting things on top of the stack and interacting with those elements.

For example, SPACE-SPACE-NUMBER will put a number on the top of a stack. A number is represented as a binary string where SPACE is 0 and a TAB is 1.

Similar to Brainfuck, characters are represented in their ASCII number equivalent.

This [website](http://progopedia.com/language/whitespace/
) has a full list of commands available. I am not going to list them all out here.

Installing and Running

It was actually very tricky to find the official resources for this program as a lot of links are now dead. Luckily, the Wayback Machine saved copies of the relevant web pages and I was able to obtain what I needed.

Here is a link to the website stored on the web archive.

The compiler that I chose is on [Github here](https://github.com/hostilefork/whitespacers/tree/master/c
). I chose this one because it was the most straightforward to set up. I was unable to get any of the official ones to work.

Once you download the C file, you will need to run:

  gcc whitespace.c -o wspace

Then you can simply run:

 ./wspace /path/to/file.ws

Notice that I use the .ws extension to my whitespace file.

I recommend using Sublime to write this code as it is able to show tabs and spaces a little clearer. Just highlight the whole text and you will see the spaces are represented by . and the tabs represented by -:

You can type normal text to annotate the code to make it easier to read, the compiler will simply ignore anything that is not whitespace.

Building "Hello, World!"

Last week, LOLCODE was reasonably straightforward, so I was able to build something a little more complex than "Hello, World!". I tried to do this again, but I could not get input from the terminal to work correctly, so we are back to "Hello, World!".

It is a little easier than in Brainfuck as all you have to do is add the number to the top of the stack and then run the command for printing the top item.

So the first letter H, is ASCII number 72. To put it in the stack, it needs to be converted to binary first. 72 is: 01001000. The command is two spaces followed by a number where space is 0 and 1 is tab. Then it ends with a line feed. This would look like this:

  {            }
;      

I have put in the curly braces as nothing would show otherwise! I think it is safe to say that would easier if I represent everything with words:

[SPACE][SPACE][SPACE][TAB][SPACE][SPACE][TAB][SPACE][SPACE][SPACE][LF]

To print the top of the stack, the code is:

[TAB][LF]
[SPACE][SPACE]

It is incredibly tempting to add a new line each time you want to begin a new operation but it is important not to.

Storing the next letter, e, would begin straight after the previous [SPACE].

So, if we continue this pattern of storing a letter to the top of the stack and then printing it, our code looks a little like this:

[SPACE][SPACE][SPACE][TAB][SPACE][SPACE][TAB][SPACE][SPACE][SPACE][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][TAB][SPACE][SPACE][TAB][SPACE][TAB][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][TAB][SPACE][TAB][TAB][SPACE][SPACE][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][TAB][SPACE][TAB][TAB][SPACE][SPACE][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][TAB][SPACE][TAB][TAB][TAB][TAB][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][SPACE][TAB][TAB][SPACE][SPACE][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][SPACE][SPACE][SPACE][SPACE][SPACE][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][SPACE][TAB][SPACE][TAB][TAB][TAB][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][TAB][SPACE][TAB][TAB][TAB][TAB][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][TAB][TAB][SPACE][SPACE][TAB][SPACE][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][TAB][SPACE][TAB][TAB][SPACE][SPACE][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][TAB][SPACE][SPACE][TAB][SPACE][SPACE][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][SPACE][SPACE][SPACE][SPACE][TAB][LF]
[TAB][LF]
[SPACE][SPACE][SPACE][SPACE][SPACE][TAB][SPACE][TAB][SPACE][LF][TAB][LF]
[SPACE][SPACE][LF]

Try it out yourself by pasting it into a text editor and finding and replacing all of the characters (Note, however, I added newlines next to [LF] to visualise here correctly, so you would have to replace [LF]\n). When I run it, I successfully get the message:

Summary

A very tricky language to code in mostly because you can't see what you are doing. Other than the visual difficulties, it is not actually that hard to understand and there is plenty of built in operations that would allow for fairly complex programs to be built.

The other difficulty was also finding the resources to actually run the programs and learn the language. Once again, the resources that I used were:

• Official documentation
• Compilers in multiple languages on Github
• Progopedia also has a good article on the language

Next week, the challenge continues with Piet.

1. Brainfuck
2. LOLCODE <- You are here
3. Whitespace
4. Piet
5. MalbolgeZombie

Last week I tried Brainfuck which was as bad as I thought. This week, LOLCODE.

Overview

Unlike Brainfuck, LOLCODE is a little bit more like traditional programming languages in the way that it is written.

The full spec can be found here. I am not going to cover everything written there here as does have a lot of substance.

The basic premise is that all of the keywords of the language are written like "Internet slang". So for example:

A new variable can be created like:

I HAS A VAR

A comment can be written like:

BTW this is a comment

An if-else statement could be written likes so:

BOTH SAEM A [AN] B
O RLY?
    YA RLY
       VISIBLE "Hello"
    NO WAI
        VISIBLE "Goodbye"
OIC

It is actually quite funny seeing of the language constructs recreated in this language. As I said, I can't cover anything so even if you are not going to try the language, you may find it amusing to read the spec.

Installing and Running

Installing LOLCODE is actually very straightforward and the instructions for doing so are on the official website:

git clone https://github.com/justinmeza/lci.git
cd lci
cmake .
make && make install

I had only 2 minor issues. I had to install cmake but that was simply apt-get install cmake. The other problem is that you have to be a sudoer to run make install otherwise you will get an error.

Once you have done this, that is it. You simply run lci and the name of the file (which doesn't have to have any particular extension) and it instantly compiles and runs.

Building "Hello, World!"

Like last week, I was going to build the basic "Hello, World!" program however the website gave away the answer:

HAI 1.2
    CAN HAS STDIO?
    VISIBLE "HAI WORLD!!!1!"
KTHXBYE

As you can see, it is also very simple. It runs like so:

So I decided to try a more complex program: A program to convert between Celsius and Fahrenheit.

It would work by taking an input from the user to decide the mode and then a number that they want to convert. It would then return an answer.

I start the code the same way as the "Hello, World" example above and then I have some variable declarations:

  I HAS A conversion_type
  I HAS A conversion_label
  I HAS A opposite_conversion_label
  I HAS A temperature

These will all come into play later.

Next, I want the user to enter C to convert to Celsius or F to convert to Farenheit. I do not want the program to continue unless one of these two options have been entered.

So, I create a while loop. In LOLCODE, a while loop looks like this:

IM IN YR label
    BTW code goes here
IM OUTTA YR label

So you specify a name for the loop and use the same name to close it. It is possible to set this to a condition, however I simply break out of it when I am done, so this is the equivalent of:

while (true) { //code goes here }

Inside my while loop, I print two lines and wait for an input:

VISIBLE "Press C to convert from Farenheit to Celsius"
VISIBLE "Press F to convert from Celsius to Farenheit"
GIMMEH conversion_type

Note the GIMMEH command here. This waits for the user to enter an input and then assigns that value into the variable that you give, in this case, conversion_type.

And so now I want to check this input and break out of the loop if it is a valid one. Otherwise, it will just continue asking and receiving.

And now we have the slightly confusing syntax of the conditional statements.

It goes like this:

  BOTH SAEM conversion_type AN "C"
  O RLY?
  YA RLY
      conversion_label R "Farenheit"
      opposite_conversion_label R "Celsius"
      GTFO
  MEBBE BOTH SAEM conversion_type AN "F"
      conversion_label R "Celsius"
      opposite_conversion_label R "Farenheit"            
      GTFO
  OIC 

Lots of language constructs going on here.

The if statement starts of with a true or false expression. BOTH SAEM takes two things separated with an AN and returns true if they are equal. In this case I am checking if conversion_type is equal to C.

If-statements, start of with O RLY? and end with OIC.

The code within the YA RLY block is what is run if the previous expression is true. So in this case if conversion_type is C.

After this block, I another condition, this time starts with MEBBE and I am now checking if conversion_type is equal to F.

To sum-up the PHP equivilent to this statement would be:

if ($conversion_type === "C") {

} elseif ($conversion_type === "F") {

}

With code within each block.

The code within each block is simply assigning the variables are initialised earlier with values using the R keyword.

Finally, conditional block ends with GTFO which is what breaks out of the loop that we are in.

Next, I want to get the value that the user wants to convert. This time, I am not going to perform any validation (although I wanted to check if it as a number but was unable to) so there is no need for a loop:

  VISIBLE SMOOSH "Your choice: " conversion_type MKAY
  VISIBLE SMOOSH "Please enter a temperature in " opposite_conversion_label ": " MKAY
  GIMMEH temperature

Again, I am using VISIBLE and GIMMEH to perform output and input commands. You will also see SMOOSH and MKAY. This is basically string concatenation. I am providing a list of space separated strings that are getting "smooshed" together.

Now that I have a value, I want to run a function. So I have another if statement:

I HAS A answer
BOTH SAEM conversion_type AN "C"
O RLY?
   YA RLY
       answer R I IZ farenheitToCelsius YR temperature MKAY
  MEBBE BOTH SAEM conversion_type AN "F"
       answer R I IZ celsiusToFarenheit YR temperature MKAY
OIC

Above, I first create another variable for to store the answer and I also have another conditional statement identical to the one earlier.

Then you can see this line:

answer R I IZ farenheitToCelsius YR temperature MKAY

The first part is easy, answer R is storing whatever is about to happen into the answer variable. Next, we see how a function is called:

I IZ functionName YR param1 param2 MKAY

You can have as many parameters as you like, we only have the one in our case. This works exactly as you would expect functions to work in terms of how they scope variables and how you return them.

One thing to note is that you have to have the function created BEFORE you used it, unlike languages like PHP where the function only has to be within the scope and the order doesn't matter.

So I have the function written near the beginning of the function:

HOW IZ I farenheitToCelsius YR temperature
    BTW C=(F-32)x5/9
    temperature IS NOW A NUMBAR
    I HAS A answer ITZ QUOSHUNT OF PRODUKT OF 5 AN DIFF OF temperature AN 32 AN 9
    FOUND YR answer
IF U SAY SO

Functions start with declaring the name and the parameters as you see here and end with IF U SAY SO.

Inside the function itself, you can see I have a little comment of the formula that I need using the syntax for comments, BTW.

I then do temperature IS NOW A NUMBAR. I had to do this to make sure that the parameter is treated as a floating point decimal. Otherwise, if the user gives a whole number, it would be cast as an integer and the calculation would round it.

Next I create a variable and assign it a value in one go: I HAS A answer ITZ, whatever comes after ITZ would be assigned to answer.

Then I use the mathematical functions made available to me to perform the calculations (these are all outlined in the documentation). There is no brackets and the functions tend to be structured like:

 F x AN y

So,

QUOSHUNT OF PRODUKT OF 5 AN DIFF OF temperature AN 32 AN 9

written in English pseudocode is:

division (multiply(5, subtract(temperature, 32)), 9)

It is a little confusing at first to structure it in this slightly different way.

Finally, the function returns the answer with the line:

FOUND YR answer

The celsiusToFarenheit counterpart is structured in the exact same way just with a different formula.

Now I have returned from my function, I output the answer:

VISIBLE SMOOSH "The temperature in " opposite_conversion_label " is " answer ". " MKAY

And thats it!

So if I run the program, this is how it looks:

Summary

There we have it. LOLCODE was actually a lot easier than Brainfuck last week because it was actually a lot closer to the sort of programming that I am used to (albeit with an unusual syntax) and therefore building a more complex program that actually does something useful, was easy.

Again, documentation for this can be found here. Next week, I fear it will not be as easy as we go onto Whitespace!

Wikipedia, the fountain of all human knowledge, has a very long list of programming languages.

They also have a list of programming languages that are "esoteric" (nope, I have not hear of that word either until now). These are languages that are less conventional than the mainstream programming languages.

For your enjoyment and my own, I decided to go down this list and pick out five try:

1. Brainfuck <- You are here
2. LOLCODE
3. Whitespace
4. Piet
5. MalbolgeZombie

Each week I will post my experience of 1 of these languages.

Today I kick it all off with Brainfuck.

Overview

I started with this post to help familiarise myself with the basics of Brainfuck. The language itself is really rather simple.

There an internal array, kind of like a tape, with 30,000 cells. There is a pointer that points to cell number 1 when the program starts. Each cell can contain a number and hold up to 1 byte of data.

There are just 8 commands that you can do:

< and > move the internal pointer left or right of the current cell.

+ increments the current cell's value by 1. - decrements by 1.

. prints the content of the current cell as an ASCII character.

, reads a single input into the current cell (I did not try this and so am not sure of its behaviour).

Then you have [ and ]. These enable looping. If the value of the current cell is 0 when it reaches [, it will skip to the corresponding ]. Otherwise, it will go to the next instruction within the block. If the current cell has 0 when it reaches ], it will exit the the loop to the next instruction, otherwise, it will return to the corresponding [. This is essentially a while loop but it can be confusing when thinking of the current position of the tape and the values in them (which is a running theme).

So overall, every character that is not ><+-.,[], is ignored. This includes all white space and any comments that you may write outside of the program.

Installing and Running

I decided to use this compiler to run my code because it appeared to be the most straightforward to set and use. Go to the link and save the page as a .asm file.

You will then need to install nasm:

sudo apt install nasm

Next run:

sudo nasm -f bin -o bf /path/to/bf.asm && sudo chmod +x bf

This will compile the file you just downloaded and enable you to execute it. You simply have to run ./bf from the directory you put it.

Now to run our first program.

The article that I linked gave a great simple example of a program:

++++++ [ > ++++++++++ < - ] > +++++ .

What this does is print the letter "A".

How?

The internal pointer begins in position 1. The increments the value in that cell by 1 6 times, therefore we get the value, 6, in the first cell.

Then we have a loop inside the square brackets. The loop starts by going to position 2, and then incrementing by 10. It then goes back to position 1 and decrements once.

So after the first iteration, our tape looks like this (the * shows the position of the pointer):

| 1 | 2  | 3 | 
| 5 | 10 | 0 |
| * |    |   |

It then goes back to the beginning of the loop and starts the whole thing again: go to position 2, increment by 10, go back to position 1, decrement by 1.

The loop continues until it sees 0 in the current cell that it is in at the end of the block (at the closing ]). In this case, it is when position 1 has 0 in it. The tape would look like this:

| 1 | 2  | 3 | 
| 0 | 60 | 0 |
| * |    |   |

The final part put the pointer into position 2, and increments by 4. So now we have:

| 1 | 2  | 3 | 
| 0 | 64 | 0 |
|   | *  |   |

64 happens to be the ASCII character code for the letter A. The very final thing, the . , prints what ever the pointer is on. In this case it is in position 2 and therefore the letter A is shown.

This could have been done equally with just 64 +s and a .. But this other solution demonstrates the level of think that you need to create readable programs. Also note that the spaces are ignored and are not needed.

To compile and run the code is simple. First the compiler command is:

/path/to/bf < /path/to/hello.b > /path/to/hello && chmod +x /path/to/hello

The part after && ensure that the program has the correct privileges to be executed.

So running all this:

Easy.

Building "Hello, World!"

I want to have to console print "Hello, World!" with the correct punctuation. So using the earlier example as a model, I first need to convert each character into ASCII number and then print them to the screen after generating.

The number that I need are

72 101 108 108 111 44 32 87 111 114 108 100 33

So, lets start with 72:

++++++++ [ > +++++++++ < - ] > .

This has the exact same logic as when we printed A. The difference is that since 72 is exactly 8 x 9, we do not have to do the extra adding once the loop is finished. If I run this, I see H printed onto the screen.

My tape now looks like this:

| 1 | 2  | 3 | 
| 0 | 72 | 0 |
|   |  * |   |

So now I do the next number, 101:

< ++++++++++ [ >> ++++++++++ << - ] >> + .

As you can see, I use position 1 as my counter and position 3 to store 101. So now my tape looks like this:

| 1 | 2  | 3   | 4 | 
| 0 | 72 | 101 | 0 |
|   |    | *   |   |

Next line, 2 ls:

<< +++++++++ [ >>> ++++++++++++ <<< - ] >>> ..

Same as before but with more arrows going between spaces as I move further down the tape. Also, you can see that I do 2 .s as I print the same letter twice in a row.

I kept going with this same logic until I had something like this:

<< +++++++++ [ >>> ++++++++++++ <<< - ] >>> ..
<<< ++++++++++ [ >>>> ++++++++++ <<<< - ] >>>> +++++++++++ .
<<<< +++++++++++ [ >>>>> ++++ <<<<< - ] >>>>> .
<<<<< ++++ [ >>>>>> ++++++++ <<<<<< - ] >>>>>> .
<<<<<< ++++++++ [ >>>>>>> +++++++++++ <<<<<<< - ] >>>>>>> - .
<<< . >>>>

The last line is the "o" in "World". As I have this stored previously, I simply move the pointer back to that position, print, then move it back again.

This is where it went wrong for me. As you can see, it is very easy to lose track of the where you are on the tape. Especially if you are going backwards and forwards.

Then I realised I was being silly. I did not need to store every single letter after I had printed them, only the ones that I want to reuse. So I only need to use 3 or 4 cells at most.

So I started again:

++++++++ [ > +++++++++ < - ] > . [-]

We are back to printing the letter H again. But you can see that I added [-] after I have printed. This effectively clears the current cell to 0 (remember the loop keeps going until the current cell at the ] is 0). So at this point, the tape looks like this:

| 1 | 2 | 3 | 4 | 
| 0 | 0 | 0 | 0 |
|   | * |   |   |

So, if we get to the "ll" again:

++++++++ [ > +++++++++ < - ] > . [-] 

< ++++++++++ [ > ++++++++++ < - ] > + .[-] < +++++++++ [ > ++++++++++++ < - ] > ..

So you can see for "e" we do exactly the same as the "H": get the number, print, then clear. For the "ll", we once again print twice. But as we want to reuse that letter later, we do not clear. So the next line:

< ++++++++++ [ >> ++++++++++ << - ] >> +++++++++++ .

Puts "o" into position 3:

| 1 | 2   | 3   | 4 | 
| 0 | 108 | 111 | 0 |
|   |     | *   |   |

Again, we want to keep "o" for later, so I don't clear it and use position 4 for the other letters:

<<< ++++ [ >>> ++++++++ <<< - ] >>> . [-]
<<< ++++++++ [ >>> +++++++++++ <<< - ] >>> - . [-]

At this point, we are printing:

Hello, W

And the tape looks like this:

| 1 | 2   | 3   | 4 | 
| 0 | 108 | 111 | 0 |
|   |     |     | * |

For the next letter, "o", we only need to go back to position 3 and print what is there. Also, we no longer need to store this letter so we can clear it and work in this cell:

< . [-]

So now we have

Hello, Wo

and the tape:

| 1 | 2   | 3 | 4 | 
| 0 | 108 | 0 | 0 |
|   |     | * |   |

So we carry on working in the 3rd cell, using cell 1 as the counter, the next letter is "r":

<< ++++++++++ [ >> +++++++++++ << - ] >> ++++ . [-] 

Now we are ready for "l" again. So as we are position 3, and "l" is stored in position 2, we simply have to go back 1 and print:

< . [-]

I no longer need this letter, so I can clear it and keep working here for the last 2 letters:

< ++++++++++ [ > ++++++++++ < - ] > .[-]
< +++ [ > +++++++++++ < - ] > .[-]

So if I now run this:

Woo!

Summary

So the overall program is like this:

++++++++ [ > +++++++++ < - ] > . [-] 
< ++++++++++ [ > ++++++++++ < - ] > + .[-]
< +++++++++ [ > ++++++++++++ < - ] > ..
< ++++++++++ [ >> ++++++++++ << - ] >> +++++++++++ .
<<< ++++ [ >>> ++++++++ <<< - ] >>> . [-]
<<< ++++++++ [ >>> +++++++++++ <<< - ] >>> - . [-]
< . [-]
<< ++++++++++ [ >> +++++++++++ << - ] >> ++++ . [-] 
< . [-]
< ++++++++++ [ > ++++++++++ < - ] > .[-]
< +++ [ > +++++++++++ < - ] > .[-]

Remember, the spaces and newlines are for us only. This could be minified to a single line.

There is also a much better written version of "Hello, World!" on the Wikipedia page that makes mine look terrible!

I found it to be an interesting challenge to think in terms of a tape and realising that we don't have to store everything once it is outputted to the screen.

I have the book, Node.js for PHP Developers, by Daniel Howard, which is designed to help PHP developers, like myself, get to grips with Node.js by translating the concepts from one language to the next.

In the post, I will go over the very basic "Hello, World" web server example.

Installation

As a Windows user, I often have difficulty setting up development environments and usually resort to using an Ubuntu VM. But in this case, it is actually very easy.

If you go to the nodjs.org website, you can find an installer that will set everything up.

You can then, in command prompt, run the command npm or node without any further issues!

Node.js Server

Unlike PHP, node.js doesn't run on a web server. If you want to use it for a web system, then you must build a web server using it!

The following is boiler-plate code for a very basic node.js server:

var http = require('http');

http.createServer(function(req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World!\n');
}).listen(1337, '127.0.0.1');
console.log('Server running at http://127.0.0.1:1337');

So what is it doing?

The first line demonstrates one of the biggest strengths of node.js: the availability and ease of loading of pre-existing modules. In this case, we are loading the module, http, which will provide the functionality that we need.

Next, we use the createServer function from the http module. This accepts a function as it's parameters that is the web server itself. This function accepts two parameters: request and response.

Inside this function, we do two things: we give the response object a header which gives it a 200 OK status and that the content we are returning is plain text. We then give the content, which is a hard coded string. So, anyone who hits this server will be given a plain text string: "Hello World!" and a 200 OK HTTP status.

The function, createServer then returns the server object with our functionality installed. On the last line, you can see that I call the listen function which tells the server to listen to requests coming to "http://127.0.0.1:1337".

Finally, I have a console log just to show that we got there.

So, if I run this using note ws.js (where ws.js is the name of the file with the above code):

You can see that it prints the log, but also the process doesn't end as the server is now running.

I can then hit the address "http://127.0.0.1:1337" in my favourite web browser and I see:

A working response.

Summary

Obviously this is a very simplistic example of a node.js web server and a very simple use for node.js as a language. But it is a great start to get experimenting with! Good luck!