<!doctype html>
<html lang="en">
  <head></head>
  <body>
    <meta charset="utf-8">
    <title>Pico 8 Game: Birb</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <h1>Birb</h1>
    <p>This is a "game" I created a while back when playing around with the <a href="https://www.lexaloffle.com/pico-8.php">PICO-8 Fantasy Console</a> back in 2018.</p>
  </body>
</html>


Pico 8 Game: Birb

<!doctype html>
<html lang="en">
  <head></head>
  <body>
    <meta charset="utf-8">
    <title>Writing Skills with Alexa</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <p>I've always loved the idea of home automation, and with the release of voice controlled devices, such as Alexa, Siri, and Google Home, we can now control devices, or query information on the internet.</p>
    <p>Here I'll show how to create an Alexa skill, and what steps you need to go through to create your own.</p>
    <h2>Setting up alexa</h2>
    <p>Amazon have made writing skills surprisingly easy. You're able to use several languages on their Lambda platform, which handles all the requests (though you can use an external server secured with SSL).</p>
    <p>We first need to setup the interaction model with alexa through their <a href="https://developer.amazon.com/edw/home.html#/skills/list">amazon developer console</a>.</p>
    <h3>Skill name</h3>
    <p>
      When writing a skill, you'll need to choose an invocation name which will get triggered when you ask alexa to perform a task.
      For example, if you're looking at writing a skill which interacts with the Kodi media player, you'd say <code>Alexa, ask Kodi to play south park</code>. You're also able to trigger and action by using <code>Alexa, tell Kodi to play south park</code>.
    </p>
    <h3>Interaction Model</h3>
    <p>The first thing we need to figure out what tasks we want to execute. We might want to start playing a movie, bring up a tv series list, or play the next episode in a tv series.</p>
    <p>We define this in JSON, where we define our <em>Intents</em>, which are keywords which we bind our <em>Utterances</em> and code to. We also have <em>Slots</em> which are variables that have a defined type.</p>
    <pre><code class="language-json">{
  "intents": [
    {
      "intent": "TVShowSearchIntent",
      "slots": [
        {
          "name": "TVShowName",
          "type": "TVSHOW"
        }
      ]
    },
    {
      "intent": "MovieSearchIntent",
      "slots": [
        {
          "name": "MovieTitle",
          "type": "MOVIETITLE"
        }
      ]
    }
  ]
}

</code></pre>
    <h3>Slots</h3>
    <p>Slots are variables which have an associated type. The type generally has predefined variables(see <a href="https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/built-in-intent-ref/slot-type-reference">Slot Type reference</a>), however if we're using a custom slot type (like we're using above), we can have undefined variables which get passed through to our code.</p>
    <p>Annoyingly, some slot types are (as yet) unavailable in the UK, which is why we needed to setup our own slot type for tv shows and movie types.</p>
    <h3>Phrasing (Utterances)</h3>
    <p>The next thing we need to define is how we're going to interact with Alexa. This just maps a phrase, and integrates variables (if any).</p>
    <pre><code>TVShowSearchIntent to put on {TVShowName}
TVShowSearchIntent to put on the tv show {TVShowName}
TVShowSearchIntent to play the tv show {TVShowName}
TVShowSearchIntent to on {TVShowName}
MovieSearchIntent to put on the movie {MovieTitle}
MovieSearchIntent play {MovieTitle}
MovieSearchIntent to play {MovieTitle}
MovieSearchIntent to play the movie {MovieTitle}
</code></pre>
    <p>As you can see above, the slot name is the variable name, which is assiciated with an intent. This allows us to interact with the skill naturally, and not have to ensure there is one specific way of asking for information.</p>
    <h2>The code</h2>
    <p>Now we've set up how we're going to interact with Alexa, we now need to write some code to actually perform some tasks. For this, we're going to use Lambda.</p>
    <h3>Lambda</h3>
    <p><a href="https://eu-west-1.console.aws.amazon.com/lambda/home?region=eu-west-1#/functions">Lambda is part of Amazons "Amazon Web Services"</a>. This is pretty cool as it only runs as long as the process is running, so you don't need to keep a server constantly running, and waiting for Alexa to communicate with it. Lambda also is free for the first million requests, and $0.20 for each million requests after that. So unless you end up publishing an insanely popular skill, it's not going to be very expensive.</p>
    <h4>Setting up</h4>
    <p>After signing into AWS, follow Lambda > Blank Function > Select Alexa Skills Kit.</p>
    <p>Here you will need to name your function, but also set up some configuration. Scroll down to Role under <em>Lambda function handler and role</em> > create a custom role > under IAM choose lambda_basic_execution > Click allow.</p>
    <p>You'll notice under advanced settings you can increase the memory and timeout. Currently, we don't need to worry about this, though if you are using a slow service, you might need to configure this later on.</p>
    <p>Click next, and then create function.</p>
    <h3>Alexa SDK</h3>
    <p>Amazon have made an SDK which provides a class which generates responses. You can get a copy <a href="https://raw.githubusercontent.com/amzn/alexa-skills-kit-js/master/samples/helloWorld/src/AlexaSkill.js">here</a>, or you can use npm to install the official sdk using <code>npm i --save alexa-sdk</code>, which we'll later upload to Lambda.</p>
    <h3>Writing the code</h3>
    <p>Make a Alexa skill directory which is going to hold your index.js file, and any node modules, or your AlexaSkill js module. The downside of using npm is you won't be able to live update your code on Lambda, though you will be able to utilise npm libraries in your project.</p>
    <pre><code class="language-javascript">var AlexaSkill = require("./AlexaSkill");
var http = require("http");

var Kodi = function () {
  AlexaSkill.call(this, undefined);
};

// Extend AlexaSkill
Kodi.prototype = Object.create(AlexaSkill.prototype);
Kodi.prototype.constructor = Kodi;

Kodi.prototype.intentHandlers = {
  TVShowSearchIntent: function (intent, session, response) {
    TvShowSearchIntent(intent.slots.TVShowName.value).then((data) => {
      response.tellWithCard(
        `I've put on ${data.show.title}`,
        `Put on ${data.show.title}`,
        `Put on ${data.show.title}`
      );
    });
  },
  MovieSearchIntent: function (intent, session, response) {
    MovieSearchIntent(intent.slots.MovieTitle.value).then((data) => {
      response.tellWithCard(
        `I've started playing ${data.movie.title}`,
        `Started playing ${data.movie.title}`,
        `Started playing ${data.movie.title}`
      );
    });
  },
  "AMAZON.HelpIntent": function (intent, session, response) {
    response.ask("You can say hello to me!", "You can say hello to me!");
  },
};

function TvShowSearchIntent(tvShowTitle) {
  var endpoint = "http://mykodiapp.net:3000/show/" + tvShowTitle;

  return new Promise((resolve, reject) => {
    getUrl(endpoint).then((data) => {
      resolve(data);
    });
  });
}

function MovieSearchIntent(movieTitle) {
  var endpoint = "http://mykodiapp.net:3000/movie/" + movieTitle;

  return new Promise((resolve, reject) => {
    getUrl(endpoint).then((data) => {
      resolve(data);
    });
  });
}

function getUrl(endpoint) {
  var body = "";
  return new Promise((resolve, reject) => {
    http.get(endpoint, (response) => {
      response.on("data", (chunk) => {
        body += chunk;
      });
      response.on("end", () => {
        resolve(JSON.parse(body));
      });
    });
  });
}

// Create the handler that responds to the Alexa Request.
exports.handler = function (event, context) {
  // Create an instance of the HelloWorld skill.
  var kodi = new Kodi();
  kodi.execute(event, context);
};

</code></pre>
    <p>You can see above that the intentHandlers define an object literal of the intents we defined in our Interaction Model. This is what is executed when our utterance has been detected. The slot data is passed across in the <code>intent.slots</code> array, which we can then pass across to some other method. In this example, we're passing it across to different methods to get resolved, and returning a promise, so we only send a response once we've recieved the data we're expecting. Depending on how fast the external sources you're looking at, you might need to bump up the execution time on your Lambda function (under configuration).</p>
    <p>Finally, you just need to upload your files in a bundled zip file. As long as your file is not huge, you're going to be able to edit the page window, otherwise you'll just need to upload another zipped up bundle again.</p>
    <h2>Finishing up</h2>
    <p>You now need to link your Lambda function to your Alexa Skill. You should notice in the top right corner of the lambda skill will have an <strong>ARN</strong> (Amazon Resource Number). You need to paste this reference into the configuration section in the Config Section of your Alexa Skill.</p>
    <p>If you're using the same account Alexa is already linked to, you'll now be able to issue commands.</p>
  </body>
</html>


Writing Skills with Alexa

<!doctype html>
<html lang="en">
  <head></head>
  <body>
    <meta charset="utf-8">
    <title>Trading Secrets Secretly</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <p>
      For thousands of years people have been trying to hiding information. The
      Nazis had the Enigma, Julius Caesar used a Caesar Cipher, the Freemasons
      had the Pigpen Cipher, and Mary Queen of Scots used a substitution cipher
      alphabet while imprisioned by her cousin.
    </p>
    <p>
      The Caesar Cipher was particularly weak, as letters were just shifted three
      places to obscure the message. While initially useful, once discovered the
      messages could be easily intersepted.
    </p>
    <p>
      The Freemasons used the Pigpen Cipher. This substituted letters for symbols,
      which allowed easy hiding of messages. Though once the codebook was
      discovered, the messages transmitted could again be easily intersepted.
    </p>
    <p>
      Mary Queen of Scots was imprisioned by her cousin (Queen Elisabeth I) for
      plotting to take the throne. She, and her Catholic supporters were in
      communication where she consented to the assasination of the Protestant
      Queen. Little did she know, she responded directly to Elisabeth's spymaster,
      who had already broken the code.
    </p>
    <p>
      While these examples use substituions or codebooks, symmetric ciphers use
      keys which are traded, which allow the sender and recipient to communicate.
    </p>
    <p>
      There does however seem to be a very glaring issue here. How do you share a
      key with a person you've never met? If you send the key, how could you
      trust that intermediate party isn't trying to steal your secrets?
    </p>
    <h2>Exchanging a Key</h2>
    <p>
      Up until the 1970's, the only way to share a key was to physically share
      the key. But in 1976 the a paper which discussed generating a mutually
      agreed key from public and private keys was published. This is known as the
      <strong>Diffie Hellman Key Exchange</strong> after its creators
      Whitfield Diffie and Martin Hellman.
    </p>
    <h2>Diffie Hellman Key Exchange</h2>
    <p>
      In this example, we're using a simplified explanation of the key exchange
      using colours. This works as an example, as it allows us to show how you
      could create a secret colour between two parties who have never met, while
      not providing enough information for a third party to calculate the secret.
    </p>
    <iframe height="1440" style="width: 100%;" scrolling="no" title="Diffie Hellman Key Exchange" src="https://codepen.io/amonger/embed/amOPMa?default-tab=result&#x26;theme-id=light" frameborder="no" loading="lazy" allowtransparency="true" allowfullscreen>
      See the Pen &#x3C;a href="https://codepen.io/amonger/pen/amOPMa">
      Diffie Hellman Key Exchange&#x3C;/a> by Alan monger (&#x3C;a href="https://codepen.io/amonger">@amonger&#x3C;/a>)
      on &#x3C;a href="https://codepen.io">CodePen&#x3C;/a>.
    </iframe>
    <p>
      In reality, large primes are used as keys as they're more difficult to
      calculate (as we want to make it as difficult as possible to break), and
      the numbers are multiplied instead of added.
    </p>
  </body>
</html>


Trading Secrets Secretly

<!doctype html>
<html lang="en">
  <head></head>
  <body>
    <meta charset="utf-8">
    <title>Continuous Integration With Gitlab CI</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <img src="/assets/gitlabci/gitlabci.png" alt="gitlab ci">
    <h1>Existing Solutions</h1>
    <p>There are some fantastic tools available for continuous integration, particuarly for open source projects. Jenkins is probably the most popular; written in java its compatible with most operating systems and works with many languages. It also has multiple plugins so you're able to configure the system to suit you.</p>
    <p>Jenkins is however quite an old project. By default each project has operate within the state of the server, which might not accurately represent the server your application is going to end up being deployed on.</p>
    <p>Travis CI is a fantastic example of the next version of continuous integration tools. As each project is run in an individual virtual machine, you're able to define what version of the language you're running, the queue software and database to accurately mimic your server.</p>
    <p>This is fantastic to run your unit, functional and integration tests, and is completely free for open source projects. By integrating this software with the git software you're using, you can ensure that a branch you've created is working correctly before merging into master.</p>
    <p>Unfortunately Travis CI is quite an expensive solution if you have small projects you want to keep private, or you have a large number of projects which each have few commits.</p>
    <h3>Enter Gitlab CI... and Docker</h3>
    <p>Gitlab CI is a fantastic piece of software, which leverages docker images, to give you complete control over your environment. This means you can choose the type of server, software and memory you need to allocate to a project.</p>
    <p>As runners are attached to Gitlab CI, you can increase the number of runners on each project, and scale them as a project grows.</p>
    <h2>Setting up</h2>
    <p>For this example, we're going to configure Gitlab CI with Gitlab Enterprise.</p>
    <h3>Gitlab Enterprise</h3>
    <p>Gitlab enterprise is available as a free service with unlimited private repositories. This is a great solution for agencies who need to manage multiple projects across several developers.</p>
    <p>It can also be self hosted, so if security is a concern, that is always an option.</p>
    <ul>
      <li>Sign up for an account over at <a href="http://www.gitlab.com" target="_blank">Gitlab</a></li>
      <li>Create a repository and push some stuff onto it</li>
    </ul>
    <h4>Gitlab CI</h4>
    <p>As you now already are registered with a gitlab account, you can access Gitlab CI by accessing <a href="http://ci.gitlab.com" target="_blank">ci.gitlab.com</a>.</p>
    <p>Add your newly created project to the tool by clicking "Add project to CI".</p>
    <p>Click on runners in the left navigation menu, where you can copy your registration token (you'll need this in the next step).</p>
    <h3>Create a Runner</h3>
    <p>
      Gitlab CI needs a runner from you to be able to carry out some operation. Gitlab (the company) provides a service written in go which uses Docker to "contain" that image.
      What we're aiming to contain within this example is:
    </p>
    <ul>
      <li>An Apache server</li>
      <li>PHP 5.6</li>
      <li>MySQL</li>
      <li>MailCatcher</li>
    </ul>
    <h4>Server Setup</h4>
    <p><a href="https://www.digitalocean.com/?refcode=72661a1914c1" target="_blank" onclick="ga(&#x27;send&#x27;, &#x27;event&#x27;, &#x27;referal&#x27;, &#x27;click&#x27;, &#x27;Digital Ocean&#x27;, &#x27;25&#x27;);">Digital Ocean</a> provide low cost servers you can configure for multiple services. For small companies, a server with a single core (meaning you can only carry out one runner at a time) should work well for most purposes. So in this instance, we're going to be setting up a $10 a month server. This is a recommended specification from Gitlab themselves, though the bare minimum is a 512mb server.</p>
    <p>The server needs to be the x64 version, as docker isn't compatible with the 386 architecture. Here, I've chosen Ubuntu 14.04.</p>
    <p>You can add your public key here or if you prefer, create without and you'll be emailed your password.</p>
    <p>After you press create droplet, it'll take about 30 seconds to setup your VPS (Virtual Private Server).</p>
    <h4>Runner Setup</h4>
    <p>SSH into your new server. Update aptitude and install the runner by executing:</p>
    <pre><code class="language-bash">apt-get update \
curl -sSL https://get.docker.com/ | sh \
curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-ci-multi-runner/script.deb.sh | sudo bash \
apt-get install gitlab-ci-multi-runner -y
</code></pre>
    <p>
      Now you'll need to register the runner you configured earlier.
      Run:
    </p>
    <pre><code class="language-bash">gitlab-ci-multi-runner register
</code></pre>
    <p>Register the runner:</p>
    <pre><code class="language-bash">Please enter the gitlab-ci coordinator URL (e.g. http://gitlab-ci.org:3000/ )
https://ci.gitlab.org/
Please enter the gitlab-ci token for this runner
[The token you generated earlier]
Please enter the gitlab-ci description for this runner
my-runner
INFO[0034] fcf5c619 Registering runner... succeeded
Please enter the executor: shell, docker, docker-ssh, ssh?
docker
Please enter the Docker image (eg. ruby:2.1):
ubuntu
</code></pre>
    <p>Apply the key you took from the GitLab CI website from the previous step.</p>
    <h4>Runner Image</h4>
    <p>Now we've setup the runner, we can work on the image. As previously stated, the image is a docker container which we're going to configure to lose its state after the build has completed.</p>
    <p>As we've already installed docker in the last step, we can work on our docker file. This is a file which defines which packages we want to install for our container.</p>
    <p>As we're mainly concerned about running tests then losing state, we're going to configure docker to install all these dependancies within a single configuration file. However if you begin to look further into using docker you'd likely separate these out.</p>
    <h4>Dockerfile</h4>
    <pre><code class="language-bash">FROM ubuntu:14.04

RUN apt-get update -y
RUN apt-get install apache2 make build-essential -y
RUN apt-get install mysql-server libapache2-mod-auth-mysql php5-mysql curl wget git -y
RUN apt-get install php5 libapache2-mod-php5 php5-mcrypt php5-mysql php5-curl php5-gd php5-intl php-pear php5-imagick php5-imap php5-mcrypt php5-memcache php5-ming php5-ps php5-pspell php5-recode php5-sqlite php5-tidy php5-xmlrpc php5-xsl -y

RUN apt-get install ruby1.9.1-dev libsqlite3-dev -y
RUN gem install mailcatcher

RUN export DEBIAN_FRONTEND=noninteractive
RUN curl -sS https://getcomposer.org/installer | php

EXPOSE 22 80
CMD ["/usr/sbin/apache2ctl -D FOREGROUND"]
</code></pre>
    <p>Here we're installing apache, mysql, ruby, and mailcatcher. These tools are adequate for our needs, but we can update this whenever we need to. Save this as "Dockerfile".</p>
    <h4>Build</h4>
    <p>Now we need to build the file. You can do this by changing to the directory containing the Dockerfile and running:</p>
    <pre><code class="language-bash">docker build -t "php56" .
</code></pre>
    <p>The "php56" is the name of the image you're creating. This can be whatever you want. You can create multiple builds with several docker files if you have different environments you'd like to test.</p>
    <h4>Final configuration</h4>
    <p>Finally we need to tell the CI tool what images it's allowed to run. Although Docker Inc. have updated docker to prevent container breakout, we don't really want to allow any images to run on the server. By default this is disabled, and the image provided will be the image defined when defining the runner.</p>
    <h4>/etc/gitlab-runner/config.toml</h4>
    <pre><code class="language-toml">[[runners]]
name = "docker-lamp"
url = "https://ci.gitlab.com/"
token = "28fj239jf2983jf283j9283jf98j382j3"
limit = 1
executor = "docker"
environment = ["MYSQL_ALLOW_EMPTY_PASSWORD=1"]
[runners.docker]
image = "ubuntu"
allowed_images = ["php56"]
</code></pre>
    <p>Here we've defined the image we built earlier can be used with Gitlab CI under allowed_images. This can be replaced with a "*" if you'd prefer to run any image.</p>
    <h2>Enable The Runner</h2>
    <p>Now we've done all that admin work, we can enable the runner on the Gitlab CI website.</p>
    <h2>Setup a .gitlab-ci.yml file</h2>
    <p>We've finished setting up our runner, so now we can begin running tests! Our image already contains the majority of services we need, so we just need to create a file which defines how to run our tests. This file is placed in our projects repository and is committed into version control (in the root of the project).</p>
    <h3>.gitlab-ci.yml</h3>
    <pre><code class="language-toml">image: php56

before_script: - service mysql start - echo "create database laravel" | mysql -u root - mysql -u root laravel &#x3C; "sql/laravel.sql" - echo "SET PASSWORD FOR 'root'@'localhost' = PASSWORD('root');" | mysql -u root - php /composer.phar install --no-progress
job1:
script: - php artisan migrate - vendor/bin/phpunit tests
</code></pre>
    <h2>Finishing Up</h2>
    <p>
      As we've already configured the service to run with our runner, so the next time you commit to the project, the projects tasks will be run and you will be able to view the status of each build on the GitLab CI website.
      
      <img src="/assets/gitlabci/success.png">
    </p>
    <p>Merge requests will now also have the additional merge status field which will tell you whether you should merge your branch into master.</p>
    <p>Build badges are also generated, which are a nice extra to quickly view the status of a project.</p>
    <p>As you can see, the Gitlab CI tool is very powerful, as you could define multiple environments, with different versions of software which could run on the same server, and are quickly provisioned thanks to the Docker container.</p>
    <h2>Some Freebies</h2>
    <p>If you want to have a play around with Digital Ocean, following my <a href="https://www.digitalocean.com/?refcode=72661a1914c1" target="_blank" onclick="ga(&#x27;send&#x27;, &#x27;event&#x27;, &#x27;referal&#x27;, &#x27;click&#x27;, &#x27;Digital Ocean&#x27;, &#x27;25&#x27;);">affiliate link</a> will give you $10 free.</p>
  </body>
</html>


Continuous Integration With Gitlab CI

<!doctype html>
<html lang="en">
  <head></head>
  <body>
    <meta charset="utf-8">
    <title>Application Chunks with the Command Bus</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <p>
      I've recently been playing around with Laravel and have been using the command
      bus for several projects. I've found the ability to abstract chunks of functionality from your controllers makes a lot more sense, and allows easier integration testing later on, as well as making it easier to reuse code. On top of this, it's far easier to see what your application is doing by looking at the structure of the application.
    </p>
    <h2>How it works</h2>
    <p>The command bus is an implementation of the command pattern. You pass it a Data Transport Object (DTO) which then gets resolved by the bus in a 1-1 mapping. So every DTO (the command) gets resolved by a single handler.</p>
    <p>As this is a 1-1 mapping some libraries forgo the separation of DTO and handler, and allow you to have a command handle itself.</p>
    <h2>An example</h2>
    <p>In this example I'll use a library I created, <a href="https://github.com/amonger/command">Command</a>.</p>
    <p>
      Imagine you have a chunk of functionality in your controller which handles billing. You might want to reuse this in several areas and put it into a service, but this would still mean binding it quite closely to your application.
      By separating this out into a command, you could create a library which could be used on several projects.
    </p>
    <pre><code class="language-php">&#x3C;?php
class BuyItemsInCartCommand implements SelfHandling, ApplicationInterface
{
    private $card;
    private $cart;
    private $application;

    public function __construct(Card $card, Cart $cart)
    {
        $this->card = $card;
        $this->cart = $cart;
    }

    public function handle()
    {
        $payments = $this->application->getServiceManager('Payments');
        $payments->charge($this->card, $this->cart);

        $this->application->dispatchEvent('payment.success', new SucessfulPaymentEvent);
    }

    public setApplication(Application $application)
    {
        $this->application = $application;
    }
}
</code></pre>
    <p>In this example, we've charge the customers card, and dispatched a new event. We can handle any exception thrown by the charge function in our controller so we can output to the customer any issue that they may have with their card. The class name is also very descriptive, so it is easy to track down when we're looking to make any modifications later on.</p>
    <h2>CQRS</h2>
    <p>CQRS (Command Query Responsibility Segregation) is taking this pattern one step further. For large enterprise applications this may be a desirable way to separate a monolith, and by using a command bus they can achive this.</p>
    <p>CQRS is identical to the command bus, except it replaces the service layer completely with query objects, which are commands dedicated to a single query.</p>
  </body>
</html>


Application Chunks with the Command Bus

<!doctype html>
<html lang="en">
  <head></head>
  <body>
    <meta charset="utf-8">
    <title>Visual Poker in Canvas</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <p>I found a project I made a few years back when I first started playing with canvas. I think its still quite a fun toy.</p>
    <iframe width="100%" height="700" src="https://jsfiddle.net/haveacigaro/zj9fpgxt/embedded/result,js,html,css" allowfullscreen frameborder="0"></iframe>
  </body>
</html>


Visual Poker in Canvas

<!doctype html>
<html lang="en">
  <head></head>
  <body>
    <meta charset="utf-8">
    <title>PHP Deployment with Phing</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <p>Deploying applications to remote servers can be problematic. Traditionally, files would be transferred via FTP to a remote host, using a tool like FileZilla.</p>
    <p>This isn't however a complete solution. Depending on your project, once the files have been transferred to the server, other operations may need to be carried out (such as changing owners, or file permissions).</p>
    <p>Another scenario is that you are using a dependency manager such as Composer. Uploading via FTP would mean that it is necessary to either download the dependancies locally then upload them via FTP or upload the files, then SSH into the remote server and download the dependancies remotely.</p>
    <p>You may then need to clear your cache.</p>
    <p>So in this scenario several operations need to be completed before the site is live, and these tasks need to be repeated every time a modification has been made to the local copy. So it makes sense to automate these tasks.</p>
    <h2>Phing</h2>
    <p>Phing [Phing Is Not GNU Make] is a tool which allows us to script the deployment process using XML.</p>
    <p>Phing comes with a host of tools to allow us to build an entire application, but for the purpose of this example, we'll focus on deployment.</p>
    <h2>The scenario</h2>
    <p>Lets assume you have a project that you've currently got a Composer project on GitHub which you intend to be updated on a remote server via SSH. This project has a caching directory which needs to be cleared every time the server is updated.</p>
    <p>So the order of operations will be something like this:</p>
    <ol>
      <li>The developer will run the deployment Phing script</li>
      <li>The Phing script will deploy a custom Phing server script to the remote server via ssh</li>
      <li>A git pull request will be made to the git repository</li>
      <li>Composer will be instructed to update and dump the autoloaded files</li>
      <li>The cache will be cleared</li>
    </ol>
    <h2>The Files</h2>
    <p>Initially we need to create two XML files, build.xml and buildremote.xml. The job of build.xml will be to transfer buildremote.xml and to execute it once it is on the server.</p>
    <pre><code class="language-xml">&#x3C;?xml version="1.0" encoding="UTF-8"?>
&#x3C;project name="Deploy" default="production" basedir="." description="A deployment Script">
    &#x3C;property name="remote_host" value="host.com"/>
    &#x3C;property name="remote_user" value="username"/>
    &#x3C;property name="remote_pass" value="password"/>
    &#x3C;target name="production">
        &#x3C;echo msg="Uploading remote phing script"/>
        &#x3C;scp host="${remote_host}" username="${remote_user}" password="${remote_pass}"
             todir="/home/learnmango/phing-example"
             file="remotebuild.xml" />
        &#x3C;ssh host="${remote_host}" username="${remote_user}" password="${remote_pass}"
             command="cd phing-example; phing remotebuild.xml; mv remotebuild.xml build.xml" />
    &#x3C;/target>
&#x3C;/project>
</code></pre>
    <pre><code class="language-xml">&#x3C;?xml version="1.0" encoding="UTF-8"?>
&#x3C;project name="Deploy" default="production" basedir="." description="A deployment Script">
    &#x3C;property name="remote_host" value="host.com"/>
    &#x3C;property name="remote_user" value="user"/>
    &#x3C;property name="remote_pass" value="pass"/>
    &#x3C;target name="production">
        &#x3C;exec command="cd site" />
        &#x3C;echo msg="Pulling down latest git version"/>
        &#x3C;exec command="git pull" />
        &#x3C;echo msg="Updating dependancies"/>
        &#x3C;exec command="composer.phar update" />
        &#x3C;echo msg="Dumping autoload"/>
        &#x3C;exec command="composer.phar dump-autoload -o" />
        &#x3C;echo msg="Clearing the cache"/>
        &#x3C;exec command="rm -rf ./cache/*" />
    &#x3C;/target>
&#x3C;/project>
</code></pre>
    <h2>Execution</h2>
    <p>As these two files are now configured, the user now only needs to move to execute the command “phing” in their terminal, phing will then take over and handle the deployment.</p>
  </body>
</html>


PHP Deployment with Phing

<!doctype html>
<html lang="en">
  <head></head>
  <body>
    <meta charset="utf-8">
    <title>Web Development With Vagrant</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <p>Many web developers begin with a XAMP stack like XAMPP or MAMP to provide an easy way to get a web server off the ground. Starting programming can be daunting; especially when you find out you need to learn how to configure Apache or Nginx before you can even begin to write your first hello world script.</p>
    <p>XAMPP and MAMP fill this niche nicely. However as developers become better versed in the tools they are using, the limitations of these tools soon present themselves.</p>
    <p>A large factor of web development is working on legacy applications, as well as working within a team using the same code base.</p>
    <p>This is something which is difficult to do consistently when you may be working on a projects months apart, or between several developers working on different platforms.</p>
    <h2>Enter Vagrant</h2>
    <p>Vagrant solves this issue by removing the local install completely. Instead, Vagrant works by provisioning virtual machines to replicate the same virtual environment each time a new server is built.</p>
    <p>This is useful to developers as it means a consistent working environment regardless of your platform. The configuration is defined in a Vagrant file, annotated with YML. This can easily be updated, and a machine can be quickly re-provisioned with the new settings.</p>
    <h2>Vagrant + VirtualBox + Puppet</h2>
    <p>Vagrant works by provisioning virtual machines using either Chef or Puppet. Both pieces of software are made to provision machines, and allow fully reproducible environments.</p>
    <p>Vagrant supports both VirtualBox and VMware to create virtual machines. These both have their advantages and disadvantages, but fundamentally work in a identical way.</p>
    <p>Although ideally we’d like to have an understanding of how Puppet provisions machines and the syntax used to achieve this, a quick way configure a Puppet LAMP stack would be to use an online tool like PuPHPet, which lets you interactively define your server configuration.</p>
    <h2>Vagrant + Version Control</h2>
    <p>Vagrant really shows its worth when working with version control. The Vagrant file is just a plain text file which defines a server configuration, which means it can be committed to your project repository with very little overhead.</p>
    <p>This is advantageous as it means several developers on differing platforms could work in an identical environment. A developer could even update the Vagrant configuration, and the other developers could merge into their environment, and re-provision their machines ensuring consistency between the team.</p>
    <p>The environment for archived sites are also documented within the Vagrant file, so if a development is needed on a site several year later, you’re quickly able to jump back into development without concern for dependancies that may have been missed.</p>
    <h2>It just works</h2>
    <p>Working on shared server configurations can cause issues. A corruption in an Apache or Nginx file could cause the whole department to come to a halt until the server is fixed, causing downtime and extending deadlines. Vagrant however allows the developer to destroy and re-provision a virtual machine independent of other developers in minutes.</p>
  </body>
</html>


Alan Monger

Posts