Since being on holiday I've been making some progress on my game prototype. I've implemented the foundations for a multi-player experience. This has been quite interesting. Firstly, I tried to implement a simple client-server architecture using TCP sockets by implementing a GameServer (if you want to be the game server) or GameClients (for each player that doesn't).

The first implementation was slow due to the constant verification that TCP has to do to ensure that traffic arrives, in order and without packet loss. I tried to implement it instead without such guarantees using UDP and indeed this improved the performance drastically.

The basic design is a system where each client registers with the game server, akin to joining a lobby in a multi-player game and as each new player arrives in the lobby details about the player is captured, such as asking the client to tell the GameServer who he is (NickName). The game server stores reference to where the client is - if we're using TCP then this will be the socket that the client used to communicate with the server, if using UDP (which is faster, so preferred) then we store the client's source port on the game server (I use connected UDP). This way the game server can talk back to the client, something like this.

How it all works, is that if a client raises an event such as moving the player, this event is serialized and forwarded to the game server, who then in return distributes that same message to all the other game clients (with the exception of the original sender). In doing so the original sender's nickname is labelled as the target of the event so that when the message reaches the clients, they know who in the system that event is for, i.e it's for the player that moved, so each client can move that particular player in that particular way so that all players see the same player move on their screens. Equally, if the game server (who is also a player) moves, this event is serialized and sent to all players, again labelling the event as being from the game server player's nickname. Each system has an event queue that is added to by reading these events off the network when they are sent by the Game server - here is a simple design.

In general, the mechanism works well in terms of the coordination of notifying other players what one specific player did. I've yet to integrate it fully to actually see the player that moved, move the same way on all the other player's screens - but the messaging and the networking is all there - backed by UDP or TCP. Getting the architecture setup in this way is a milestone. Like most things that are well implemented, it takes time to move from each stage of the design because one needs to fully evaluate what the next stage needs/should be and, more importantly, that it will be useful and not a wasted effort of coding. In this way, designing and thinking is an important next step and when I reach a milestone like this,  I like to take a break and think about how to move from this milestone to the next one. So that's where I am right now.

One thing that has become clear is that in order to fully create a multi-player game, where all participants move and respond on each players screen, requires level initialization so that we can dynamically initialize a level with as many players as having joined, and then tell all of them to use the same level initialization and level creation parameters when starting the level on their screens in the same way, i.e complete with all the positions of all the other players. So there needs to be some dynamic collaboration to say, 'hey, these are all the players and they are here and here in the level, go and create the level that way when the game starts'. This needs to be done on all clients so all clients look the same way so that messages targeted for players actually reach players because they have been added/created to the same level that all other players are playing. This is the next milestone. 

But while I know what needs to be done, I've been travelling and working and well it's a great time to do other things while you're at a milestone and you don't need to finish anything yet as you've not started the next thing. So, I've been thinking about the general idea behind distributed networking and participant collaboration (because that is what a multiplayer system is really), and how it is generally an information collaboration system used for many types of problems. You could use it for collaborating on individual results that a client has come up with, in like a distributed computing scenario. I think this is where computer games technology is so interesting and useful for so many other things, particularly via network programming - as it allows you to design systems that can be used in other distributed scenarios like to create say a map-reduce environment or some other clustering environment where resources, results and information are shared across multiple participants just like in a multi-player game. The interesting thing is that it's not just about communicating across the network, its about communicating across the network to inform other people what you've done or what someone else has done, and in so many applications knowing what exactly someone has done in your network is useful because its the basis for collaboration or at least, of information sharing.

In many ways, I already knew this from my work creating the distributed broker but it never actually told everyone else what one person is doing, it never radiated the effects of one person to all others concerned, and it also never used UDP, so that is cool.

What are the applications or concerns for such a system?  

1. Too much information perhaps, not everyone wants to know about all other's information, but in games we definitely do, we want to know exactly what the other players are doing so that we can emulate that behaviour on all our screens. In fact, this would be useful in distributing real-time messages to multiply display boards, say at an airport or train terminal. 
2. With so much data flying around, security and integrity of that data are important, particularly if you need to be 100% sure that the information you've received is exactly as it was intended (it hasn't changed, ie its integrity is in check) and that it's absolutely from the person who sent it. So perhaps ensuring that the data transmitted is secure is important, generally. For a coordinated and distributed algorithm implemented a distributed game agents absolutely. For a network game, maybe a lack of security could compromise the integrity of the game (someone is changing the network data and messing things up)
3. Latency would be an issue for games, if it takes ages to act on a piece of information, then the real-time nature of a game is compromised. If the system is not real-time, then this wouldn't matter - it gets it when it gets it. Could implement the TCP mechanism to improve the reliability in these types of systems. Possibly compression, encryption and hashing be used to improve both the security and latency by reducing the size of transmitted data, but how would it affect the performance?
4. A system that reports all the activity of others could be useful for auditing purposes - ie replicating what has happened to multiple places that it guaranteed that what has happened can be verified. 
5. It could also be a useful way to distribute the same information to agents that use it differently like each one applies or uses the data differently, say uses a distinct algorithm and this way multiple 'tests' could be run in parallel, i.e each receiving agent can run use the received data at the same time and report back its results. 

I can't think of any more uses but distributed computing is basically what we're talking about and that is a huge field. I'd like to probably think a little more about the security of distributed computing, particularly in networked games or how implementing it could affect the gaming experience. That's perhaps for another day.

Recently, since Fading importance and the utility of lists, I've been thinking about the top-level approach/process that I use for doing development work, generally.

The main reason was that I was wondering how different other disciplines of development might approach doing work and how much commonality there might be in what I generally do. So I thought it would be interesting to outline my conceptual flow when approaching new work.

A typical strategy that I take to delivering software within the last couple of years, which has focused on being more agile, i.e, exposing and sharing issues more readily and making the strategy design process more collaborative, looks something like this:

 See Strategy for Designing Software Solutions for an illustration of the process

 Sharing the responsibility with your group

The stages of this process initially are from the developer's (my) perspective who has been tasked with delivering the software solution. This means that at each step the developer is cognitively involved in rationalising the information and tasks at each step to develop a mental blueprint of the upcoming work that he/she needs to deliver. This means that much of the process is internalised by the individual developer, and any artefacts that are externalised/produced are from the developer such as diagrams, documentation etc is initially produced to aid their own understanding and solidify their development methodology.

Personal artefacts are the outcomes of the process carried out by the developer and can include designs/diagrams, documentation and code

While the process is initially a personal approach initiated and implemented by the developer, many outcomes can be exposed to the group, particularly unknowns and concerns that the developer might have picked up while defining their process.

A problem with personal exposure to the process is that the amount of responsibility and burden that is implicitly on the developer grows as the process is followed and more information is uncovered. This is especially true of discovered unknowns that need to be accounted for or potential concerns or shortcomings that the developer realises not only within the solutions but within their own personal skillset for example.

Holding onto these concerns, unknowns and problems can be psychologically taxing as they weigh down on the developer during subsequent stages of the process such as during Technical solution implementation for example. This is where group exposure to these issues can serve as a relief to these burdens, as it can distribute and share the responsibility of dealing with them, including sourcing potential solutions. This also allows for expectations to be readjusted as many issues are likely to impact the Technical solution implementation stage which is of principal concern for the individual developer as well as the group. This is likely to decrease the pressure that the developer faces when having to deliver the technical solution, as it involves more people (team) and distributes some of the burden such that technical solution implementation can proceed with more clarity with the impact that these issues will have on the technical implementation.

In this way, there needs to be a shared notion of the process where the personal process extends into the group and vice versa, however much of the process is initially heavily centred and focused around the engineer's personal ability to define it. It then needs to be fed back into the group to share and initiate feedback that serves both the developer and the group depending on the developer to deliver the software solution.

Group artefacts are resources that allow for exposure and feedback back to the developer's process and can meetings, design/documentation review, project/goal/strategy/planning tracking and code review.

Discussion

Generally, I find it useful to produce an artefact that represents my personal outcomes or thinking, such that they can be shared with the team, both for feedback but also for relieving the pressure from dealing with unknowns/uncertainties/issues etc. This includes taking a strategy that keeps track of my progress as outlined in Fading importance and the utility of lists which can help to quantify your efforts throughout the above process.

I would say a large portion of the process is similar and has parity with the typical software development process where requirement gathering proceeds analysis and which leads to design and then ultimately implementation. However, my process presents this slightly differently as more of a personal development process that is followed by an individual contributor (developer) of the overall software development lifecycle of a product or feature.

Also, in the process, there is an emphasis on the initiative that the developer must have when encountering issues, as the developer is often the first person to become aware of them, and failure to expediently expose issues can result in unnecessary pressure in dealing with them. So in this way, this process factors in these personal concerns. 

The process tracks individual concerns and processes such as research and the need for understanding and idea modelling. It implies that requirements are already gathered and just need to be correctly understood, or if they are poorly gathered, then that it's the developer's responsibility to determine what the requirements are and then understand them in order to develop a solution to deliver it.

I think much of the business analyst role especially for more agile, smaller teams are now largely deprecated and much of this responsibility is falling on the individual experienced developers.

There is also generally the feeling in my mind that more responsibility is required of developers to deliver end-to-end solutions, and I suspect this is because the complexity of software is difficult to adequately distribute across multiple actors such as an analyst, project manager and other developers.

So more of these tasks are taken on by the individual developer and this requires more skills and better communication skills (which arguably the other roles mentioned previously would be more traditionally good at). However, it's arguably easier to distribute the development tasks to other developers, provided the tasks have been defined - which again is usually the work of another developer if indeed the tasks get distributed at all. In some cases, the developer is responsible for the entire end-to-end software solution due to the difficulty in communicating the complexity of the implementation to others in an adequate time, and so the work takes as long as it takes the developer who understands it to implement. 

I think there is a concern in software projects, that due to the complexity of software projects, both theoretically but more problematically at a technical level, it is becoming difficult to speed up development by bringing in new developers as the time to transfer understanding of the complexity is now longer than the time required to deliver the entire solution. So in some cases, solution delivery is not being given strict deadlines but they are progressively being delivered piecemeal as they are being incrementally implemented by the developers who understand the solution/problem/complexity.

In the process outlined, understanding requirements, designing ideas and thinking about how to model and implement them, theoretically and technically is left to the individual developer to satisfy, requiring and drawing knowledge from past experience and training. This suggests that the quality of the developer is being more crucially being recognised as important for their ability to understand, contextualize, rationalize simplify and execute the delivery of solutions in light of the increasing complexities of software development generally.

An interesting discussion that is not touched upon here is how this process differs from the typical game development process, and how either it or this process can lean from each other. For example, is there a similarity to requiring research as part of a task or communicating unknowns to the team, and how is this carried out? I imagine there would be some similarity to non-game development but to what extent or how does it differ?

Since, ISO27001, Machine-Learning and Game dev, I recently wanted to store some sensitive data (private key) in a string in C# and keep it in memory during the duration of an operation.

Due to the design of some 3rd party APIs that required a string representation of the private key, I decided on encrypting the string and only unencrypting it when I want to use it. In all other instances, the encrypted string would be copied or passed around, while the unencrypted string would not be.

I did some reading about System.Security.Cryptography's ProtectedMemory function, which allows you to encrypt a block of bytes of which needs to be a multiple of 16 bytes. The interesting thing about doing this is being able to encode the length of your sensitive string within the actual encrypted 16n byte block so that when you unencrypt that block, you can retrieve from it the length of the original string, and recover the original string. This is kind of what you do when you encode the length of a packet that you send down the network.

The implementation of an object that can encrypt a string, store it internally and decrypt upon request, is a ProtectedString:

using System;
using System.Security.Cryptography;
using System.Text;

namespace X.Y.Z
{
    /// <summary>
    /// Store string encrypted at rest.
    /// </summary>
    /// <remarks>You can copy this object freely</remarks>
    /// <remarks>Portable alternative to SecureString, using DPAPI</remarks>
    /// <remarks>Note SecureString is not recommended for new development</remarks>
    /// <remarks>https://docs.microsoft.com/en-us/dotnet/api/system.security.securestring</remarks>
    public class ProtectedString : IProtectedString
    {
       /// <summary>
       /// Secret area that is encrypted/decrypted
       /// </summary>
       private byte[] _secretData;

       private readonly object _lock = new();

       private bool IsProtected { get; set; }

       /// <summary>
       /// DPAPI access control for securing data
       /// </summary>
       private readonly MemoryProtectionScope _scope;

       /// <summary>
       /// Creates a ProtectedString
       /// </summary>
       /// <param name="sensitiveString">Sensitive string</param>
       /// <param name="scope">Scope of the protection</param>
       public ProtectedString(string sensitiveString = null,
                              MemoryProtectionScope scope = MemoryProtectionScope.SameProcess)
        {
            _scope = scope;

            // Store secret if provided and valid
            if(InputValid(sensitiveString))
                Set(sensitiveString);
        }

       private static bool InputValid(string sensitiveString)
       {
           return sensitiveString != null;
       }

       /// <inheritdoc />
        public void Set(string sensitiveString)
        {
            try
            {
                lock (_lock)
                {
                    if(!InputValid(sensitiveString))
                        throw new InvalidInputException();

                    // The secretData length should be a multiple of 16 bytes
                    
                    var secretDataLength = RoundUp(
                        sizeof(int) + // We will store the length of the
                                      // sensitiveString as the first sizeof(int) bytes in secretData
                        sensitiveString.Length, 16);

                    // Allocate array, all values set to \0 by .Net
                    _secretData = new byte[secretDataLength];

                    // Copy the length of the sensitiveString into the secretData
                    // first, starting at the first byte
                    BitConverter.GetBytes(sensitiveString.Length).CopyTo(_secretData, 0);

                    // Copy the sensitiveString itself after the bytes the above bytes
                    Encoding.ASCII.GetBytes(sensitiveString).CopyTo(_secretData, sizeof(int));

                    // Encrypt our encoded secretData using DPAPI
                    ProtectedMemory.Protect(_secretData, _scope);

                    IsProtected = true;
                }
            }
            catch (Exception e)
            {
                IsProtected = false;

                if (e is ProtectedStringException)
                    throw;

                throw new Exception("Unexpected error while storing data from protected memory");
            }
        }

        /// <inheritdoc />
        public string Get()
        {
            try
            {
                lock (_lock)
                {
                    if (!IsProtected)
                        throw new NotProtectedException();

                    // Decrypt secretData
                    ProtectedMemory.Unprotect(_secretData, _scope);

                    // Determine how long our sensitiveString was by reading the integer at byte 0
                    var secretLength = BitConverter.ToInt32(_secretData, 0);

                    // Read that many bytes to recover the original sensitiveString
                    var sensitiveString = Encoding.ASCII.GetString(_secretData, sizeof(int), secretLength);

                    // Re-protect secretData after retrieval
                    Set(sensitiveString);

                    // Return a reference to unprotected string.
                    return sensitiveString;
                }
            }
            catch (Exception e)
            {
                if (e is ProtectedStringException)
                    throw;

                throw new Exception("Unexpected error while retrieving data from protected memory");
            }
        }

        private static int RoundUp(int numToRound, int multiple)
        {
            if (multiple == 0)
                return numToRound;

            int remainder = numToRound % multiple;
            if (remainder == 0)
                return numToRound;

            return numToRound + multiple - remainder;
        }
    }
}

The question is if this is really useful at all from a security standpoint?

As soon as you unencrypt the contents, you get an unencrypted string back, and that string lives in memory and in theory, can be looked at by memory scanning. Also when that memory is freed (provided you don't have a reference to it), the garbage collector will free it but won't zero it out (securely clear it), so it'll be somewhere in memory, ...unencrypted.

Ultimately I never used this because of the reasons mentioned above, but it's still interesting...

Now, despite this, the above is still useful in some ways, provided you:

• a) only copy or store the protected string or pass it between functions.
• b) don't store the unencrypted string anywhere.

The other advantage is that the window of exposure of the unencrypted string is small (but it'll still get garbage collected), as you only unencrypt the ProtectedString when you want to use it, otherwise the secret is encrypted at rest.

Still, it doesn't help with the original problem of having unencrypted string copies lingering in system memory somewhere....

Since Implementing a Vignette, I've been pretty involved in getting various machine learning algorithms to, well learn...

I've been playing around with SIFT feature extractors, Histogram of gradients (HOG) and convolutional neural networks (CNNs) and at times it's been quite interesting.

When I started learning about machine learning techniques, I wouldn't say machine learning was of immediate interest to me. I think ever since I did a course on Data management and Analysis, I kinda thought designing software was more my thing. Sure the graphs were cool though, and I like graphs but I think too much data fiddling well just becomes too much data fiddling. That said, I did not learn machine learning and the closest I got to classification was K-nearest neighbour clustering techniques.

With machine learning, the mathematics however is quite interesting, especially the partial derivative calculations that help you determine the impact that model weights are having on the loss function of your model (backpropagation). I did have to write them out by hand initially because otherwise I just would not understand it.

After you understand this, you start to understand that parts of machine learning are very much a brute force, nudge-it-until-its-correct sort of discipline - which is effective but this is an over-simplification of course, and there are more smarts involved.

What is really quite impressive is that pytorch has a built-in Tensor type that will track how each tensor's value impacts an expression that involves that tensor - and calculating the impact of the tensor on say loss function is just a matter of calling backward() and the entire object hierarchy involved in the expression is evaluated for its impact on the expression. Quite cool. This helps not having to worry about trying to calculate the chain rule manually on a piece of paper! Also, found it pretty cool how easy it was to move Tensors to the GPU to speed up training times.

With this, I've pretty much swapped Ruby for Python which has become almost an extension of me lately (same goes for C++ but more on that later). Interestingly while designing my feature pipeline, I found that python has no concept of private members and the convention is just to use double underscore in front of the method name. Abstract classes exist which was useful, as I designed a pipeline (which is basically this) that is based on interfaces that allow uniform interaction but allowing varying underlying implementation details. 

My pipeline currently consists of 2 classifiers (SVM - Support Vector Machines and MLP - Multi-Layer Perceptron) and 2 feature extractors (SIFT and HOG) and one convolutional neural network (CNN) based on MobileNetV2.

The CNN I originally designed from scratch needed too much training than I had time to do and so the learning rate was poor. So I've been fine-tuning this one using pre-trained weights and I've just adapted it to learn the classes that I'm interested in.

I will say that I particularly enjoyed the learning around machine learning theory, for example understanding why a non-linear function (Sigmoid or ReLu for example) is used after linearly combining the input values, which is to produce a variance in the shape of the function which contributes to determining a function that best describes the input.

To this extent, this book was particularly useful in understanding 'why' and not just doing it and moving on which is so often the case with technical theory - not that this book was technical it was more practical and provided diagrams like this one - which my brain seems to appreciate. I wouldn't say I'm proficient however but I'm interested which was more than I could say before. 

Pity I don't have an NVidia graphics card so I've been having to use the GPU in google colab and I hit the limit a few times while training but eventually got 83% validation accuracy which is pretty good. 

Apart from that I've also been writing a lot of C++/OpenGL and finished a demo racing game, which I very much enjoyed programming. Its very simple but shows various important 3D graphical elements.

I've implemented an exponential fog effect and my scene is basically themed on Jurrasic park-styled atmosphere.

I've incorporated some meshes for the player car, the forest and the track. The path through the scene is calculated using catmul rom splines and the rear-view mirror is programed using a FrameBuffer object.

Most of the shader code is for the lighting effects and the fog. For the lighting, the Phong-Blinn model is used. Its been very interesting managing the vertex buffers and drawing 3D primitives etc. 

What I'd like to do next is incorporate the library of code that I developed for the demo into a more abstract utility that I can use in the next thing I do. 

In terms of Information Security, I wrote a critical review about securing software development processes as recommended by Clause 14 in ISO 27001 around the utility of implementing E-SecSDM, an engineering-focused software development model to improve the security of engineering systems that incorporate software in their design.

I think the learning I did on digital forensics, criminal law and network security previously was a bit more exciting than learning about ISO 27001/2 but like most things, its useful to know a little more than you did before so in this way, its useful.

I've been out and about running also - that knee niggle has seemed to have sorted itself out (well, I did implement a no-run policy for about 2 months) however my fitness has dropped off but that's ok - I've been slowly working my way back up. My last couple of runs were slow but they were pretty nice especially now as the sun is starting to come out. 

Speaking of which, maybe I should go for a run. now....

I recently had a task to create a vignette of a picture. This is a technique in Computer Vision or digital signal processing whereby as you move closer and closer towards the centre of the image, the pixel intensity increases:  

When first approaching this problem, I could not understand how, from a dense matrix of colour information, you could determine how far the pixel that you were processing was from the centre of the image. I confirmed, that no position information is available within the pixel itself (it just contains raw colour information). Finally, it dawned on me that you could use the coordinates of the image matrix to create a vector to represent the centre point, ie. the offset x and y from an origin.

But where is the origin?

I first thought I'd have to use the centre of the image as the origin, meaning all my pixels co-ordinates would need to be relative to that, which would have been a pain as I'd have to work out how, say each pixel in the matrix[x][y] would probably need to be represented differently when relative to not matrix[0][0] but the centre of the image!

Then I realised that it could keep the origin as [0][0] in the matrix ie image[0,0] for both the centre point and each respective pixel and then it could thus be represented by a vector displacement from that same origin. This was a breakthrough for me. Not only that, you could then generate a new vector for each pixel this way - all using [0,0] in the image matrix to represent a distance of that pixel from the same origin. 

So, now you have two 2D vectors from the same origin, one that points at the centre of the image ie [max_cols/2, max_rows/2] and you have a vector that is [x,y] for each pixel you are currently processing. You can now subtract the vector representing the centre point from the pixel vector you are currently at, ie this would result in the vector between the two, which if you can calculate the magnitude thereof, will be the distance between the pixel you are on and the centre of the screen - ie its the hypotenuse between the two sides (of the two vectors). 

The length of the resulting vector can be easily by passing in the vector to np.linalg.norm() - ie get the norm of the vector ie the (length or magnitude) and this the distance. I guess you could also do this yourself by squaring the components of the vectors, adding them up together and taking the square root. But this is much easier.

Now you can use that distance to drive the intensity value at that pixel!

With the distance(d), you can derive the relative intensity using a function of d and max length of the image to give the intensity i.e brightness(d,img_max) to assign for that distance from the centre. That function produces e raised to the power of the ratio of distance to width. This equation was given and I've represented as the brightness function in the python code below:

$$ f(x,y) = e^{(\frac{-x}{y})}
= \begin{cases}
& \text{x is distance from center} \\
& \text{y is the width of image }
\end{cases} $$

As the image was already in 24-bit RGB colour, I converted it to HSV so that I could manipulate the V component, which corresponds to the intensity. This is not immediately and easily determinable from the RGB data.

I could then manipulate the V component by doing a simple 1d vector x 1d vector multiplication to create a mask that multiplies only the V component with the brightness, leaving the Hue and Saturation intact (I multiplied those by 1(identity)) 

This can be more concisely be represented in this Python script I wrote: 

# Change intensity of pixel colour, depending on the distance the pixel is from the centre of the image

from skimage import data
import numpy as np
import matplotlib.pyplot as plot
from skimage import color, img_as_float, img_as_ubyte
import math

# We can use the built in image of Chelsea the cat
cat = data.chelsea()

# Convert to HSV to be able to manipulate the image intensity(v)
cat_vig = color.rgb2hsv(cat.copy())

print(f'Data type of cat is: {cat_vig.dtype}')
print(f'Shape of cat is: {cat_vig.shape}')

# Get the dimension of the matrix (n-dimensional array of colour information)
[r, c, depth] = cat_vig.shape
v_center = [c / 2, r / 2, 0]

# Derive the pixel intensity from the distance from center
def brightness(radius, image_width):
    return math.exp(-radius / image_width)


# Go through each pixel and calculate its distance from center
# feed this into the brightness function
# modify the intensity component (v) of [h,s,v] for that pixel
def version1(rows, cols, rgb_img, v_center):
    for y in range(rows):
        for x in range(cols):
            me = np.array([x, y, 0])
            dist = np.linalg.norm(v_center - me)
            # alternative:
            cat_vig[y][x] *= [1, 1, brightness(dist, cols)]
            # cat_vign[y][x][2] *= brightness(dist, cols)

# do it
version1(r,c, cat_vig, v_center)

# Convert back to RGB so we can show in imshow()
cat_vig = color.hsv2rgb(cat_vig)
fig, ax = plot.subplots(1, 2)
ax[0].imshow(cat)  # Original version
ax[1].imshow(cat_vig)  # vignette version
plot.show()

This was pretty interesting, and I do love it when theoretical math ie linear algebra applies to practical outcomes!

Q.E.D:

aggressive lick pic.twitter.com/40fZHFY2w1

— Animal Life (@animalIife) January 25, 2021

I've just come back from a 21km run and it was fantastic and I'm just going to reflect on what worked and how it went to perhaps explore why.

I headed out just after half-past one in a long sleeve top. It was pretty cold outside. The original goal was to run 5km up the hill and onwards a little bit before turning around.

I've been thinking on a couple of my last runs that I should probably slow down a bit more and try to maintain a consistent, albeit slower pace throughout my run. This analysis was done on the back of the last couple of 10Km runs I'd done where I'd noticed that I've got a tendency to speed up in in beginning and also at the end of the run. 

The net effect of this is that I think I tend to strain in the end when perhaps I could just coast over the finish line.

So with that in mind, I've decided to head out a bit slower and try to keep it calm, cool and collected and I think this is what ultimately made this particular run so easy.

I didn't push forward, I just pulled back when I was moving a bit fast or when I was establishing a stitch and then I'd just 'canter'. This means that I was able to notice a lot of things about my running behaviour.

For example, I slowed down and my feet where not being banged up and usually after an 11Km run they are pretty torn up with impact shock and sometimes blisters. I still think that this is partly to do with the rate I'm running at and perhaps coupled with my weight - I'm gaining weight.

Either way that combination is not great, so slowing down has fixed the 'thunder' in my feet that I've been having lately.  

Slowing down has allowed me to concentrate on listening to the pain, and adjusting. Usually, I ignore pain when I run 'fast' around say 4"30 or so. Its almost like you're focusing so much on pace, that you don't care about what your feet are feeling like or going through.

So with this slower style, I could find a pace that did not mash up my feet. This I think, is also a large reason why running past the usual threshold of 10-11Km was so easy and why I was not even aware of any discomfort.  What I was aware of was a distinct lack of discomfort in my feet, and perhaps I should just see how far they would take me. 

So the shoes are not the problem (i never thought they were, as I've been using them for years, at least this particular model). The other thing that might have played a part in it, was that I was listening to my favourite songs of the year. That helped. 

From a psychological point of view, I was not hard on myself because I'd already said to myself at the start of the run that I was going to go slower.

In the uphill stages or the more treacherous terrain where I could have struggled, I just said to myself 'calm down, you're running slower now so if you need to run any slower that's fine' and this approach worked.

Being ok with slowing down and perhaps speeding up is ok. Going one speed or the speed you predicted you should go at, takes it's toll, particularly psychologically to maintain and also physically and I think corroborating the feeling in your arms, legs, arms with appropriate adjustments, including the pace, makes the run smoother - this is a breakthrough really.

Running should not be turmoil or an obstacle. 

I was wary about wearing long sleeves though. I've got a good track record of enjoying running in short sleeves and this is because ultimately I warm up sufficiently, so I've resisted the need to change. And I think this is what is important, being ok to adapt, even below expectations, is what made this run better than all others this year - and certainly x2 as long as usual. 

The route took me back to my old workplace, around it and all the way back again. It was nice to be in familiar surroundings and I felt fine.

Look, I'd be lying if I said that I did feel uncomfortable at times, especially as the clocked ticked on over the hour mark, but I just slowed down and kept it in gear, steady and calm and ultimately this avoided disaster.

Looking back at the stats, in the end, 4"59 pace is mighty impressive because I did not think I'd be reaching anywhere near that. if anything I thought perhaps at my pace I would be trundling on at around 6 minutes per km. That shows that it wasn't that slow, and I was just running at where I was most comfortable at and that is variable throughout the route. 

I never look at my watch routinely when running.

I've always found that this helps to reduce the stress and strain on accommodating expectations - I think it also messed with your stride.

I don't think we should have expectations about who long we take, we should perhaps have expectations about how long we'll run for and then manage all the factors in the run to make it happen - if that means stopping, slowing down, taking a picture or taking a pee whatever - do it and then carry on running.

As it happens I needed a leak at about 16km in, so I pulled over into a footpath that was abandoned (I had a good nose about to ensure I'd not be interrupted).

This is the first time I've needed to take a whizz mid-run, but I stopped. I rationalize with myself, that it would be uncomfortable not to, and why stop this zen-like run by having to worry about that.

When it comes to my preparation in terms of what I ate - nothing special: I just had my usual porridge and a cup of decaf coffee.

I did, however, sleep until 12 pm. This was an important factor too perhaps. I was well-rested. 

In the end, the long sleeve top was almost unnoticeable and maybe it actually helped me stay comfortable and zen.

This is exactly how its supposed to be.

I think that change is a wonderful thing - and it is inspirational - you have the opportunity to put into action that which you have had a chance to evaluate... Sure, you can evaluate constantly but none is more effective than that done right before of some major required action. That being said, it is not always the case though, and change can be seen as an opportunity or failure.

The SAS for example, suggest that inducing unexpected circumstances in military training best confirms the effectiveness of the application of learning. I would probably agree with that and suggest that it would probably boost confidence in soldiers also.

Opportunity and failure: I believe which one depends not only on your mindset but also how persistent you are. The latter being a function I think of the practice, particularly of endurance generally, but perhaps specifically in overcoming obstacles consistently and dealing with new situations as they occur. I mean that's life pretty much, isn't it?

I think programmers deal with new and unexpected situations all the time - we rationalise, evaluate, apply and move on without any hoo-ha. In this way, I think we consume a lot of uncertainty. The next problem, however, is always more interesting.

Interestingly I think a lot of time is spent not on solving the problems but choosing the solutions that solve the problem for the longest time...as change is inevitable in software engineering. I have come to realise that trying to find the best solution is impossible, there are not enough knowns in any software project and it comes down to pretty much civil law: a balance of probabilities that the solution is effective given what we know.

It's not easy to remember past events, specifically the influences, feelings and effects that events had without revisiting them, which I think is crucial for well-being and confidence. Exercising and thinking about things helps to plan what to do next.

Voltaire once said: "No problem can withstand the assault of sustained thinking", but I'm paraphrasing because he was french - and would probably have said something like : "Aucun problème ne peut résister à l'assaut de pensées résolues."

For example, earlier this year I had to complete a three-part programming exercise online and it was daunting at first (this was as lockdown started, so tons of uncertainty), and I guess with any unexpected event, a degree of trepidation was felt for sure. After overcoming the difficulty of the exercise itself, not just the technical complexity of the scenarios, but also the psychological growth that occurred as a result, was the sense of self-determination...

I also participated in a live group-work session via skype to solve a much larger problem, using hand-drawn diagrams, evaluating requirements and establishing a strategy. I'm a whole lot more comfortable with this now and I guess that is what experience is: everything I've done in the past and have encountered has taught me something that I can use in the next round.

I've become a lot more confident for example because I realised while doing it, how much I really enjoy solving problems and modelling situations and the whole experience was actually a lot of fun. I ended up developing a parser for markdown in one scenario. The other scenarios required me implementing a tracking system by using virtual functions to invoke overriding behaviour in base classes and the other was to do with sorting.

Small things like the above, you often brush away as just being part of the work to be done, but in doing so you lose so much of the valuable tacit knowledge that is ultimately lost with time.

After this, I started a big project at work, research and the development, and learnt so much about distributed databases and sharding it's quite amazing. I'm well suited I think to work on large projects that are high in uncertainty. I also learnt a new language, (not french - Ruby) which I've quite enjoyed. See my discussion around Deadlocks and databases.

I also began a new course on Information Security which is pretty neat, I'm working in a more theoretical aspect in this course than I did in Network Security which, like Digital Forensics was highly technical. It is basically implementing ISO27001 by implementing an ISMS (Information Security Managment System), so I'm doing a lot of assessing of criteria, risks, controls, security requirements, policies etc... It's pretty interesting.

Besides that, recently I've been working on my 2D game engine which is currently undergoing a major refactor. I find if I can reason about a system within an A5 page in my notebook, then the system is sufficiently complex

I've got pretty much most of the basics in place, a resource manager that swaps in scene resources in and out of memory - that works ok, scene management is there a system of layer hierarchies to manage drawing using the painter's algorithm - zorder that is.

What I need now is to write a level editor to interface with the format of my resouces.xml file and scene{n}.xml file formats so I can create levels and co-ordinate placement of assets etc. I'll probably do this in C# using WPF. 

My current focus right now is on my event manager which is my baby right now. I built it from scratch using some primitive ideas but which has translated into a pretty robust system, handing the distribution of work throughout the subsystems. What I'm looking to do now is incorporate some tests to keep the system green through its lifetime and have just recently introduced some using the same framework I used when testing my circular buffer in my audio programming class. 

Apart from this, I've watched all the Alien movies, which are frankly quite awesome. I've also watched all the John Wick films too. I clocked up about 35+ Kms last week but my feet are all torn up and I've been hobbling around at times. I also performed a mini-surgery on my foot to strip away all the old skin after a pretty major blood blister - this was a major success.

The company I write software for bought me a pull-up machine for my apartment and offered to pay my gym membership which I think is pretty great, so during covid I've been pretty active: I can do about 10 pull-ups with relative ease now.

I wrote an article on  Design Patterns: Representation, Transmission and Dependencies which I found interesting (but I'm biased)  and released my architecture design in Mazer Game Architecture Report for my game architecture class.

I think the next 6 months are going to be even more intense and I'm gearing up for it!

You can't do everything but you can do something.

I've found working from home to be a lot more useful than perhaps I'd ever imagined it to be. 

The routine and flexibility have allowed me to more easily complete my deliverables in many cases (though I do tend to go to be later). For example, I am able to go for runs more routinely, and my days are uninterrupted which helps me concentrate and make productive advances in my work.

Due to these advances, I've very much considering this to be my default modus operandi moving forward and reducing my travel and potentially my rent in the future...

At the moment I'm learning about various design patterns and as part of my ongoing research and even made a foray into Lambda Calculus while reading a paper by Haskell author Paul Hudak written in 1989. I find reading papers to be quite enjoyable, and immersive - particularly as I'm already at home after work with no tiresome commute.

I've realised that I very much like doing investigative work, research or otherwise. Particularly true of debugging in general or any aspect where I need to paint a clear understanding from an otherwise unknown or blurry set of circumstances. I really enjoyed the Digital Forensics course I did for example.

I guess at the heart of it, this is a form of conceptual modelling - piecing together understanding about the unknown. And I think it can be quite a personal thing, and therefor quite rewarding - because you've got to figure out, in your own way how something works ie make it understandable. This can be a very creative process. I find drawing pictures in my notebook the best way to model things and ideas, I'm also quite partial to using my Surface too.

My running has made leaps and bounds, I've increased my fitness to a large extend while under lock-down, which perhaps compensates for the amount that I'm eating too!

I recently I wrote about some aspects of the testing framework in Ruby RSpec let and let! differences which came up during a discussion and have found the platform generally useful. 

I've also been re-writing a prototype game to use Functional programming paradigms and techniques to first show that it can be done, and to document what they are - for purely research basis.

As part of this and other ongoing learning, I've updated my LanguageExt tutorial (which had made it into an arctic vault), so will now be enjoyed for generations to come! It also happens to be its 1st Birthday this month. 

I've added a new use case for demonstrating the Try<T> monad, which is such a useful thing but is something somehow, particularly people I've spoken to about it, haven't appreciated as much.

I've also been prodding around in J2EE code around using RX-Rest, Glassfish, JSF, JPA and EJBs but not in a huge way these days. I'm looking for excuses now.

Since Set Theory, Ruby and Upgrades, I've been focusing on learning new technologies recently{xbref tag="0" title="Changed jobs" desctext="I now work at VMware" } [Changed jobs] ¹⁵{/xbref}. The primary focus of the new platform under development is on centralizing the view of your current separate clouds{xbref tag="0" title="Multi clouds" desctext="AWS, Azure, GCP(Google), Alibaba etc" } [Multi clouds] ¹⁵{/xbref} and managing them from single operational, governance, security and cost management perspective.

The platform is based on Ruby on Rails and it is a completely new and another level of learning which centres around a platform that provides the tools to develop online or cloud-based systems. There is a striking resemblance to ASP.net MVC and Spring MVC however the added twist of needing to use ruby makes it an interesting proposition, not to mention's provision for metaprogramming.

I've been in the thick of learning about RSpec, FactoryGirl and the base Rails platform documentation. I've also been watching a lot of Plural Sight videos which has been quite a time-consuming process however an interesting diversion at times. I'm not even nearly made a dent in the materials.

I recently decided to write a simple game called Ruby Mazer entirely in Ruby over the May bank holiday weekend. This was really fun and got me conversational with ruby. I used a gem called Gosu to help with the drawing and input. The premise of the game is that you need to reach a point in the autogenerated maze without touching the maze walls in getting there. Once you get to the exit point, you are teleported to a new maze which is slightly more difficult. I used Prims Algorithm to generate and solve the models that make up the level generation routines. You can read up on the implementation in Ruby Mazer.

I've had to dial back on my recent reads{xbref tag="0" title="Recent reads" desctext="DirectX and Maths" } [Recent reads] ¹⁵{/xbref} as priorities have changed and I'm re-focusing on other things{xbref tag="0" title="Re-focus" desctext="Ruby and Ruby and rails being one, and some of the onbording training being the other" } [Re-focus] ¹⁵{/xbref}, however as my learning curve goes down, I'll probably continue with them. This has also been the case with my running over the last two weeks.

Having said that I went for a run yesterday as described in Hot weather running. I just about survived. I also earned two new(3 actually) blisters for my efforts. I played my specifically created Spotify playlist. A particular good running tune is Micheal Jackson - The way you make me feel and Dance Monkey.

In other news, I've recently started focusing on Euclid. It's fairly slow going, however 'slow and steady wins the race'... It's quite nice to see how common rules like how the angles under at the base of an isosceles triangle are equal - is actually solved in an actual proof so as to show/explain/prove where/how this rationale came from{xbref tag="0" title="Proposition 5, Book 1" desctext="This is the actual proposition by Euclid" } [Proposition 5, Book 1] ¹⁵{/xbref}. 

The other thing I like about the proofs is that they build upon each other. Initially, if you look at the rationale of a proposition, particularly the starting diagram{xbref tag="0" title="Proposition 3, Book 1" desctext="Given two unequal straight lines, to cut off from the greater a straight line equal to the less" } [Proposition 3, Book 1] ¹⁵{/xbref} it's not entirely clear however that it proceeds from the previous Proposition{xbref tag="0" title="Proposition 2, Book 1" desctext="To place at a given point[as an extermity] a straight line equal to a given straight line" } [Proposition 2, Book 1] ¹⁵{/xbref}.  This is sometimes a pain however I do think the mental realization of connecting where the previous proposition left off and where this one derives from it perhaps is a necessary mental step. The first 7 triangle propositions have been an interesting diversion over the last couple of weeks.

I've also been heavily customizing my editor recently for my new workflow - see it here complete with split screens and git integration! 

Now, I must not forget to sleep and must run more. Sleep and run, sleep and run and program in the middle (7 hours) 

Since Time shifting, CS algorithms and Game Architecture, I've been exploring trivial set theory to gain insights into the theory of what defines a function from a purely mathematical standpoint, which as it happens, is the product of two sets. For example, let C represents a function in terms of a set $ C \subset A \times B $ such that it produces a set where $ \{(a,b): a \in A, b \in B\}$ and which references all the possible inputs and outputs of the function where $ C = A \mapsto B $.

Usually the nomenclature of a function is usually represented as $ F = X \mapsto Y$ and alternatively $ f(x) = y : x \in X \ y \in Y $. Obviously, if you spend some time going through the theory of functions as expressed on a graph such as a linear equation, the relationship between the dependant variable $y$ and independent variable $x$ has a clear relationship. In programming, this is generally interpreted as the running of a function's code as opposed to the evaluation of an equation or expression to realise the dependant variable's value.

The theory of sets is pretty interesting in its own right however its particularly interesting in the context of functional programming, particularly pure functions which are programming constructs which are trying to model the mathematical ideals of functions. A pure function represents a bijective mapping (both injective and surjective) of the product of the two sets (domain $X$ and codomain $Y$). This means nothing else exists that influences $y$ other than $x$ (it's a direct mapping). This is a key consideration of pure functions in functional programming and immutability.

The reason its key is because this makes $f(x)=y$ absolutely reliable because if you know $x$, then you know $y$. These ideas have implications for real-time processing environments like games because they usually rely on highly concurrent and often parallel execution of tasks, where reasoning about functions within a threading context requires predictability. This is among some of the research I'm doing at the moment.

Parallel executing tasks usually lock critical sections of shared state and these tasks (functions really) themselves are prone to producing non-deterministic results due to the very fact that they don't exhibit a bijective nature between their domain and codomains. Executing environments that rely on I/O and other external factors make it impossible to guarantee the result of any function that relies on it - not great for a function's predictability.

Making tasks pure, arguably makes them reliable and then you don't need locking either. My argument then, is that this will make games perform better - and more reliably. Though my research looks to determine at what cost this comes at, particularly when it comes to the code itself such as readability and maintainability etc.

Interestingly if you do some reading about Memorization, this relies on this behaviour of a bijective function too ie. you never need to evaluate that function again in the future - provided of course you store its input and output.

Apart from Mathematics, I've upgraded my Investment Management project to .net core 3.1 which takes it right up to the latest supported version. It was a bit of a pain doing it, as I had to go from .net core 2.0 -> 2.1 -> 2.2 -> 3.0 separately and then finally to 3.1. It wasn't that complicated but it wasn't seamless either. 

I've also done some more Canal-side runs lately, which I've enjoyed.

Although I don't use functional programming for my day-to-day work in C# anymore, I've written a prototype game in C# which I'd like to 'functionalize'. I've come to appreciate the ideas and would like to explore its applicability to game development now.  I'm slowly reading through Functional Programming in C# and I'm weaving it in with the other readings I have going on. I've got through the first 2 chapters so I've yet to make real headway. I produced a tutorial about functional programming in C# (which got good feedback) and this, I guess is an extension of that.

There is scope to incorporate Scala into my future work and there are functional aspects to Ruby (see later) - so the trajectory is in the same direction, generally. So I'll not be dropping it quite yet.

I've also been playing around with latex, trying to get it working on my blog(which I've managed to do) and I think moving forward I'd like to use it to write up some of my work moving forward.

I've managed to get out my project proposal which is entitled "Evaluating and Applying Functional Programming Paradigms in Developing Computer Games using C# and MonoGame", though I had to chase up my supervisor to review the draft and by the time he'd done it, my proposal had diverged significantly and thankfully his comments were largely already covered in my revised version. I incorporated some of his comments however which was helpful. I'll need to start working on the delivery of it.

I'm slowly making it through A mind for numbers having made it through the first 3 chapters. I'm also learning more about Linear Equations and relationships between numbers, specifically the dependant and independent variables that constitute formulae (given my earlier foray into functions) such as trivial straight line equations in the form of $y = mx +c $. I find it quite interesting going through it. I'm finding it quite useful for reinterpreting some of the fundamental algebraic ideas and others such as understanding the nature of proportional relationships (the meaning of gradients for example).

I've pretty much stalled on applying my linear algebra learning to 3D transformations (which is the stuff I need to do next and finish...DirectX math, coursework and some films) as I think I've been reading so much about it that I'm a little tired of it (I've read the first 6 chapters of 3D Game Programming Using DirectX 10 and OpenGL back-to-back as well as Frank D Luna's book - lots and lots of theory). 

As a distraction, I bought a book a while ago which is old (managed DirectX 9 in C#) which I thought might be useful to obtain an alternative perspective on viewing transformations and the like, so I started to read that. I've got through the first 3 chapters and now I'm at a point where viewing transformations are being discussed. So I've got 3 books ready to get into about this! This one's obviously old and managed direct X is no longer a product, but it's exciting none-the-less. I've got to avert my eyes when I see some of the device enumeration and selection code as some of it now does not apply to later versions of Direct X with the version I'm most familiar with (DX10) being the one that did away with the compatibility checking code that features in this book. It is however nice to be back in C#.

I created a nice little C++ vehicle that shows the current frames per second and I'll use this as the basis for my next work, which should be shortly. It will probably also include some HLSL and shader programming as that's required for the vertex transformations to occur.

I've also been learning Ruby and Ruby-On-Rails recently, not in a massive way yet. I've read the basic tutorial on the main website, followed 2 video tutorials on the subjects respectively, the first 4 chapters of "Eloquent Ruby" as well as the section on ruby in one of my programming books and created my first dummy rails application. I find text-based tutorials much more effective than a video, but I guess it depends on your time and motivations. My plan so far is to integrate it into my Investment Management project, using Resque and Redis as the basis of a background job management system, which I've already partially set up.

I've got Halo Wars, Metro Last Light, Dragons dogma and Dantes Inferno currently sprawled out on my couch and I've not played any of them yet. This means I've been pretty productive. I have played Mass Effect 3 though, that is until I got to a stage where I kept on getting killed and it started to annoy me - I stopped playing... You got to make games adaptively progressive!

There is still much to do, and only 2 more weeks to do it in!

Since Convolution, Running and Finite State Machines, I've spent the last couple of days focused on reading lotsa different stuff.

I'm currently alternating between a few books: "Introduction to 3D Game Programming with DirectX10", which is by Frank D Luna. It's quite technical however, it's accurate and provides good perspective, particularly around the basic math such as vectors and Matrices.

I'm also reading Rautenbach's "3D Game programming Using DirectX10 and OpenGL", which is one of my favourites reads on the subject. I think it is primarily because it does the best coverage of 3D transformation I've ever read and its got great illustrations too. 

With "Foundations and fundamentals concepts of mathematics",  I'm taking a history lesson at the moment into the axiomatic, deductive method used throughout history in describing math. I've been reading about the development of the deductive method used by Euclid and Archimedes and some of the histories behind how varying degrees of assumptions including Axioms and Postulates and how they are used, how they were formed and it is pretty insightful. It's theoretical but/and pleasingly so.

On a more practical note, I'm now also reading "A programmers introduction to mathematics"  where we're trying to implement a secret code sharing mechanism using polynomial theory, which is a little more practical. This book takes a little longer to read than the others but I'm quite interested in it.

Last in my round-robin of reads is "A mind for numbers", which is more inspirational than technical and sits squarely within the genre of some my previous 'popular research' reads such as "Mindset" and "Bounce" as well as "The Checklist". It reads more like a novel/story than a technical book.

Apart from physical the books, which are stacked up next to me on my coffee table, I've been wondering the passages of the internet too. I recently came across a BBC learning page about computer science fundamentals.

It introduces algorithms such as those used for searching including linear and binary search methods and sorting too using methods such as bubble sort, selection sort, merge sort etc.

Its a series largely aimed at children but it has real application (just like any math would) and I found it particularly interesting and fun, which perhaps further suggests that perhaps I've not yet grown up.

It also maybe suggests that some computer science fundamentals are a little more known to children that they have ever been before as it was surprisingly well documented and entertaining as it included videos, examples and was suitable 'gamified'. The only thing missing I found was actual code implementations...

I spent some time implementing some of them for fun as I wanted to test myself.

My first test was implementing Bubble Sort - a linear time, O(n) sorting algorithm, pretty inefficient and slow but it's got a very defined and coordinated setup which makes it easily modelled.

I used a do() iteration construct, as you'll be swapping at least once and I count the number of swaps done through each iteration or 'pass' running through the list of numbers. The process ends when there are no more swapping to be done, which forms part of my exit condition in my loop and then the list is sorted:

public static void BubbleSort(ref int[] input)
{
    int swapped;
    do
    {
        swapped = 0;
        for (int i = 0; i < input.Length-1; i++)
        {
            if (input[i] > input[i + 1])
            {
                var temp = input[i];
                input[i] = input[i + 1];
                input[i + 1] = temp;
                swapped++;
            }
        }
    } while(swapped > 0);
}

It was actually pretty fun doing this, and can surely be improved upon - Next, I tried the insertion sort:

Insertion sort

Insertion sort is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort.

This is a little more difficult because you need to 'look' back to see if any prior elements, so it needs a nested loop. One loop for the initial pass-through of each of the elements and then for each element, scan the previous elements leading up to the element. Pretty inefficient, somthing in the region of say O(n^2) I'd imagine, but totally something that can be modelled in code:

public static void InsertionSort(ref int[] input)
{
    for (int i = 0; i < input.Length; i++)
    {
        for (int j = 0; j < i; j++)
        {
            if (input[i] < input[j])
            {
                var save = input[j];
                input[j] = input[i];
                input[i] = save;
            }
        }
    }
}

These all sorted the list in-place. I stopped there but I'm going to add a few in the future, probably the more complicated and more efficient ones as it's a pretty interesting and enlightening process, and helps me practise. 

So in other news, I've finally completed my Network Security course, and I'm pretty much done with the Digital Signal Processing. Actually, the last piece of work I did on it was the course work(which ultimately replaced the exam) was where I needed to implement a Circular Buffer and then use it in creating audio effects in C++ using fmod, among other things.

One example of this was creating a delayed(or time-shifted) signal effect like a flanger... 

This is what I ended up doing in C++:

 {google_docs}https://drive.google.com/file/d/1xaTjX39n-vQzKOtaFPcULaANjEGGjgWO|width:800|height:500|border:1|border_style:solid|border_color:#000000{/google_docs}

One of the other things I had to do, was set up an occlusion effect whereby walking in front of an object would effectively cut off sound originating from the object.

I used FMods geometry system to construct a polygon that represented a wall and positioned that in front of my object. I then registered it with the fmod system. Pretty fun as we had to import a new mesh and render it in the OpenGL - which was the first time I'd used OpenGL.

Looking back at my DSP course, I actually enjoyed it, particularly the theory but also too the C++ and the work I did on the ringbuffer. We covered aspects including:

• Logarithms, Real and complex numbers
• Sampling and Quantization analogue continuous signals into digital
• Wave theory and properties of waves
• Signal correlation and the Fourier transform: Dot product, Autocorrelation, Cross-correlation, Cross-co-variance, the Correlation coefficient
• Frequency Analysis
• Filtering and convolution

I enjoyed learning about the Fourier transform the most, and I suspect in the future I'll be using it again...

Apart from my Network Security and DSP course, which has taken a lot of my spare time, I also managed to also complete the Game Architecture course.

As a result, I've written a game engine in C# and MonoGame and produced a representable prototype to represent it. The main concepts covered include:

1. Resource Management Strategy
2. Character Control and Decoupled Input
3. Collision Detection
4. Moving and animated game elements and frame-rate independence
5. The configurable game world and data-driven approach
6. Decoupled removal of game objects from collision detection
7. Scoring System use of event listeners
8. High score or alternative state load/save mechanism
9. Start-screen with FSM
10. Power-ups using event listeners and re-use of base classes for game objects
11. NPC opponents demonstrating FSM
12. Overall game-play and presentation

I have a bit of a demonstration of a PAC-man like game which features collision detection, primitive AI and animation. It's very basic and is really just a prototype (not a whole game) to demonstrate the underlying architectural designs and concepts in the game code:

I started with a simple concept of a GameObject which takes on a lot of the functionality and responsibility of typical game situations such as calculating bounding boxes, doing collision detection and common updating routines, drawing and initializing of components etc.  

Apart from the actual coding which has taken a lot of my time, I've also spent a considerable amount of time distilling the design decisions of my game engine into a report, which really helped me take stock of all the code I'd been writing, specifically the architectural aspects.

{google_docs}https://drive.google.com/file/d/1aY27W9TsXzr8XuPHnr0qvOF2WJ40Z2wUhpVmHyM3gjA|width:800|height:500|border:1|border_style:solid|border_color:#000000{/google_docs}

There have been a A few runs during the stay-in phase which are notable.

Yesterday, I put in Mass Effect 3 into the XBox and played a little bit, enough to cure the Krogen of the Genofage but I died like 20 times before I was able to finish the mission. But the persistence paid off!

I also upgraded my Investment Tracker application to Angular 6 from 5.2 which wasn't that bad however I'm a bit stuck now as I can't upgrade beyond that as I've got a strong dependency on a component that won't upgrade further - which I'll need to look to remove in the future but not a big issue right now.

I'm thinking of doing another project that uses my new knowledge around signal processing to implement a sort of Strava-like application in Angular 8/9 but the jury is out on the schedule of that. I've got a few weeks break before things start going again!