- Details
- Category: Blog
- By Stuart Mathews
- Hits: 2748
Since Games, STL, Digital Forensics and a Fedora, I've been pushing forward, however, I'm pretty tired this weekend. I skipped my run into the office on Friday because I suspected that I was coming down with something and thought better of it.
I went to the gym yesterday and I felt a bit weak. The run in was a bit tough because the sun was blazing down, though I think that unlike most, I'm ok with running in the heat, still, it was hot under the sun.
I worked on my back and I had to pace myself because there were times that It was pretty tough going. I think because I'm not as regular as I used to be, I've not developed the resistance to hard training so when I do it, its a tough going. But I just need to adapt to my new routine.
I had to slow down during my bench rows, as I strained a little near the end of my sets and my lat pulldown wasn't as heavy as it normally is, though I kept my form which is important and this morning I can feel the areas of my back. The run back that day was also a little tough and I suffered somewhat but I'm used to that - so I continued through it. You got to be a little bit mental. maybe a lot.
Today I woke up and decided to do it all again, this time the run in wasn't that hot or tough but I can certainly feel my weight inhibit me. I'm trying to be in shape so that my running isn't so tough and I think its working, though perhaps just being tired made me feel sluggish.
I decided to do shoulders today, which is notable because I've strayed far from shoulders recently and I'm very happy with the results. I was able to articulate my shoulder through a full range of motion. It wasn't heavy but that's ok, I need to ensure my shoulder is strong and fully recovered. I guess I'll really determine the outcome of today from tomorrow. Again, much like yesterday I focused on full ranged motion and left my ego at the door. I ran back and felt pretty OK - a lot easier than yesterday.
After yesterday's session, I was a bit pooped and fell asleep after my shower - propped up on my bed headboard. That was a good little break because It allowed me to regain some energy and motivation.
I spend the rest of the day studying Law. Common and Civil Law and how the courts and the law are structured. It was pretty interesting. I also did some planning for my next assignment which is about Continuous Professional Development which I deferred until this semester, which gave me real problems last time so I'm coming into this with new eyes.
Had my weekly lecture on C programming on Tuesday which gets me home at around 22:00 and in bed around 23:00 which is a bit painful but necessary. I helped a colleague to understand the concepts inherent to C which are quite challenging at times. I didn't realise how loud we were talking and was asked by this one guy in the room, very loudly, to 'Stop that, its really annoying!". I was actually quite surprised, shocked really. The dude is also finding the work tough so I guess he was just really annoyed at not being able to get 'it'. We were going over functions and we've yet to reach arrays and pointers, which should blow his mind.
Anyway, made me realise how not used to being in a classroom environment I am.
Though I think I really helped my colleague. Boo-hoo to him. I said sorry and left it at that. Moving on.
Apart from this, I've been recently working with a colleague on a data science platform, well just the beginnings of it. It is pretty cool because its an application of my dataflowpipline project I recently started. The key requirement of the pipeline for a data transformation exercise are to put some data through the pipeline, run some anonymizers on it, and then run some feature extraction function on it.
I sat with him and we coded it up together based on his experience at Cern. I had to go away and re-code it because it only became clear to me that tone last aspect of the discussion (around building a delegate that builds a pipeline for just one item should be created). Sometimes my brain needs to sleep on it to work it out. Anyway, I worked it out(see below) and it was quite interesting and fun doing it(maybe I should get out more).
The key was to create a pipeline builder that would create a pipeline could take in any single item of data and anonymize it and then extract features from it, both these processes are all represented by custom Processes() that represent those stages of the pipeline. Each process is represented as a stage and each stage is represented as a function ie Func<T,T>. The goal, as mentioned previously, was ultimately to represent a delegate that would take a single item of data and construct a dedicated pipeline configured with the anonymisers stages and the feature extraction stages built in and then put it through the pipeline. Then the full transformation would use this generic typed delegate on all the items.
I came up with this prototype, which transforms a list of People objects in this case, but in theory, any objects can be used and the appropriate anonymizers and features can just be defined and passed in when creating the pipeline and it will bake those into the pipeline.
This is is the way you'd create a pipeline for a list of people. Just add Anonymizers and feature extractors:
// This is a generic builder where we can use any type of data
// and transform it into a array of, in this case, integers
// The features take a person and turn it into an inteter
// if there are 3 features, then 3 integers will result int[3]
// for one person passed into the pipeline
var builder = new Builder<Person, int>();
// This will take all the anonimizers, features and the data
// and transform all the items into items of feature results
var result2 = builder.Transform(items: listOfPersons2, anons: anons, features: features);
The Anonymizers are just a list of functions that transform the data somehow and the features extract features somehow and the result is a matrix of this transformation of all the items into this array of extracted features which then can be minded or run through an algorithm for analysis-a-la-data-science.
The anonymizers and features are defined here:
// Here are two anonymizers
// We'll represent them as stages in the pipeline
Func<Person, Person> Anon1 = (person) =>
{
person.Name = "Boop";
return person;
};
Func<Person, Person> Anon2= (person) =>
{
person.Age = person.Age + 5;
return person;
};
// These are the feature extractors
Func<Person, int> featureEx1= (person) => person.Age;
Func<Person, int> featureEx2 = (person) => person.Name.Length;
// turn the anonimizers and features into arrays of funcs
var features = new[] { featureEx1, featureEx2};
var anons = new[] { Anon1, Anon2 };
Actually providing multiple stages (anonymizers) in the dataflow pipeline library wasn't possible in v0.02 so I had to manually code a loop and this prompted me to release a new version of the library to do this.
It's 4 days old and has 22 unlucky souls using it.
Anyway, I'll put the full source code at the end of the post.
I popped into my little Italian dinner, located on the ground floor of the local shopping centre after the gym and had an Italian bean salad with Mediterranean veg, chicken, mushrooms, sun-dried tomatoes and avocado. Then I spent most of my day following that reading the Association Of Chief Police officer's Good practise guide to digital evidence, which can be found here: https://www.digital-detective.net/digital-forensics-documents/ACPO_Good_Practice_Guide_for_Digital_Evidence_v5.pdf which has been on my todo list, since last weekend. Quite a long read but I'm better informed now because of it.
So on the whole, another productive two days.
As is life.
My data aquisition and trigger POC source code as promised:
sing System;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Pipeline;
using static Pipeline.Pipeline;
namespace daq
{
// This is an example of the data we'll pass through the pipeline
// in order to transform it
class Person
{
public Person(string name, int age)
{
Name = name;
Age = age;
}
public string Name { get; set; }
public int Age { get; set; }
}
class Program
{
static void Main(string[] args)
{
// Some copies of the input data
Person input1 = new Person(name :"Stuart", age : 31);
Person input2 = new Person(name: "Stuart", age: 31);
// Here are two anonymizers
// We'll represent them as stages in the pipeline
Func<Person, Person> Anon1 = (person) =>
{
person.Name = "Boop";
return person;
};
Func<Person, Person> Anon2= (person) =>
{
person.Age = person.Age + 5;
return person;
};
// These are the feature extractors
Func<Person, int> featureEx1= (person) => person.Age;
Func<Person, int> featureEx2 = (person) => person.Name.Length;
// turn the anonimizers and features into arrays of funcs
var features = new[] { featureEx1, featureEx2};
var anons = new[] { Anon1, Anon2 };
// This will run all the features on a single Person
// This is specifically desinged to deal with Person objects
// So its not generic but we'll fix that later with a builder
Func<Person, Func<Person, int>[], int[]> featureVectorizationFunc = (person, featuresLst)
=> featuresLst.Select(fn=> fn(person)).ToArray();
// Prepare copies of the input as a series of Persons instead
// of just processing one person we want to process many
var listOfPersons = new Person[] {new Person("Jack", 29), new Person("stuart", 31), new Person("John", 45)};
var listOfPersons2 = new Person[] { new Person("Jack", 29), new Person("stuart", 31), new Person("John", 45) };
var listOfPersons3 = new Person[] { new Person("Jack", 29), new Person("stuart", 31), new Person("John", 45) };
// Examples of the data flow pipeline transformation process
// Pipe line of applying anonymiser in multi elements input before transforming result
// with custom function featureVectorization
// While this works, you need to provide each Anonimizer
var result1 = listOfPersons.Select(p => StartPipeline(() => p)
.Process(Anon1)
.Process(Anon2)
.ProcessAndTransform((person) => featureVectorizationFunc(person, features)).Result);
// This is a generic builder where we can use any type of data
// and transform it into a array of, in this case, integers
// The features take a person and turn it into an inteter
// if there are 3 features, then 3 integers will result int[3]
// for one person passed into the pipeline
var builder = new Builder<Person, int>();
// This will take all the anonimizers, features and the data
// and transform all the items into items of feature results
var result2 = builder.Transform(items: listOfPersons2, anons: anons, features: features);
// Example using the delegate which can process just one Item
var result21 = builder.SendThroughPipeline(input1, anons, features);
// Pipe line of applying anonymiser on one element of input before transforming result with custom function featureVectorization
int[] result3 = StartPipeline(() => input2)
.Process(Anon1)
.Process(Anon2)
.ProcessAndTransform((person) => featureVectorizationFunc(person, features)).Result;
}
}
/// <summary>
/// Turn input into a feature set, applying anonyizers on entry.
/// Fully Generic
/// </summary>
/// <typeparam name="T">Type of the items</typeparam>
/// <typeparam name="R">Type of the result matrix</typeparam>
public class Builder<T,R> where T : class
{
internal static Func<T, Func<T, R>[], R[]> featureVectorizationFunc = (person, featuresLst)
=> featuresLst.Select(fn => fn(person)).ToArray();
/// <summary>
/// function delegate that'd then be called with each object
/// </summary>
public Func<T, Func<T, T>[], Func<T, R>[], R[]> SendThroughPipeline = (T eachItem, Func<T, T>[] anons, Func<T, R>[] features)
=> StartPipeline(() => eachItem)
// Run the Anonimizers
.Process(i =>
{
// Really if Process could actually do this given an Func<IEnumerable<T>> of anonimizers that'd be much better than this
T prevResult = null;
for (int j = 0; j <anons.Length; j++)
{
prevResult = prevResult == null ? anons[j](i) : anons[j](prevResult);
}
return prevResult;
})
// Split item into feature results and put into matrix
.ProcessAndTransform((person) => featureVectorizationFunc(person, features)).Result;
public R[][] Transform(T[] items, Func<T, T>[] anons, Func<T, R>[] features)
=> items.Select(eachItem => SendThroughPipeline(eachItem, anons, features)).ToArray();
}
}
- Details
- Category: Blog
- By Stuart Mathews
- Hits: 3614
Since C, 64, Triple Black, Resource Management and a Game Prototype, I’ve been working on my game prototype these past few couple of days which now has morphed in its architecture as I’ve been learning about new concepts.
This weekend I’ve learnt about Scene Management. Scene management is all about targeting the subset of resources in your game that belong to the current scene. So, this means when a new scene is started, the resources associated with it will need to be loaded into memory. Those not part of the scene need to be unloaded etc. So, there is a bit of interplay between the resource manager and the resource manager.
I didn’t have a scene manager in my prototype and its introduction into my code base meant that I needed to change how my rendering processes work. My game prototype is a bit of a mug, it’s a scratchpad of different sources of information. This is great because I’m picking and choosing things in some places that make sense to me and using those ideas. The downside is that not everything is the same from say a particular book I read. For example, I’m using the game loop from one book (Game Algorithms), the scene management from another (Thorn) and the two sources differ in how they deal with audio for example. I’m now considering implementing the Actor or game object infrastructure using a 3rd book (from which I've already used the event management ideas from). It’s fun.
Speaking of fun, I had a good time setting up my Event Manager(which I introduced in Retro sounds, Event Manager and some running) to link up the main game to the Scene Manager to the Graphics Manager. I'm finding the event management the most rewarding part of coding up the prototype. One of the great things about it is that it decouples many subsystems from each other. For example, I have components like the actors subscribe to DoLogicEvent, PositionChangedEvent and the Resource Manager subscribe to SceneChangedEvent. This is pretty cool. You just need to to subscribe to your event of choice and when it happens. Being able to use this more frequently is proving how useful the design pattern is.
I’m also glad that I’m being a lot more conversational in my C++ and the practice using STL quite rewarding. The new features I’ve mentioned previously like lambdas and implicit variable types is nice.
I also spent most of Sunday writing up an assignment for my Digital Forensics course. This so far has entailed understanding the incident life-cycle, insights into contemporaneous notes and basic introductions into Computer, Mobile, Image and Network forensics, among others, and what they can tell us. Quite interesting.
I must say that while I enjoyed it, the word limits are quite restrictive. I am glad that I didn’t kill myself trying to get it done though - I had started it some weeks before. Recently I’m finding that my more exotic choices i.e. modules that I’m not already familiar with i.e. non-Computer Science related, like Forensics or Psychology aren’t that easy to predict one’s efforts. I remember this one time working 2 weekends for a meager result which was both time-consuming and disappointing. That specific module was Psychology, so I’m reserving judgement.
I’ve been going to my weekly lectures (that’s really what they are – he just talks) on the C programming language and I spent the entire session coding up the course final project. It’s a noughts and crosses game. I’m not finished with it and I’m surprised at how I didn’t finish it in the class. I’m obviously not as good as I thought I was! That said, I’ve solved it now but its not perfect which is irritating. So, I’m gaining more from this course that perhaps I thought I would.
My issues first arose from the fact that I decided to not use the concepts that I’ve yet to be introduced in the course but then I go and base the solution on a multi-dimensional array-based board – something we’ve not been taught yet. So, I’m doomed from the outset – half of it is restrictive by the above and the other is using un-restrictive ideas (what a mess?) and I’m hell-bent on using multi-dimensional arrays. I don’t mind it being tough.
I’m stuck being unable at the moment to figure out a generic algorithm to solve diagonals irrespective of the dimension of the multi-dimensional array – something that should be easy to solve but my brain hasn’t been paying much attention to sanity lately. The code is here.
I also found myself in the gym yesterday (Bank holiday) as I couldn’t go on Sunday(assignment) or Saturday (lazy and meeting friend in London). So, I went out on the trot and kicked out a good session. I’m not as strong as I was but I’m OK with that. My shoulder is really improving and it feels like I could work it but I’m not quite ready yet. I took care to eat correctly because I’ve not been sleeping well recently and that’s when my body starts to fall ill. So far I’m kept it in check, eat well, rested well and that’s a good thing.
During the week, I ordered 3 new books which look fun:
- Game Architecture and design
- This one is actually more about the game design process than architecture. That said there is a single chapter on architecture. I started reading the theory about game design on the train back on the day I got it. It was actually really fascinating. So I’ll get back to it soon.
- An introduction to 3D game programming
- I’m not yet started reading this however I did thumb through it while eating a meal. It basically DirectX8 using C# so It looks pretty much a precursor to the more prevalent and more powerful Unity framework. I’m interested in seeing how the basic 3D graphics principles are put into practical application – irrespective of the language/age of the technology.
- Game programming all in one
- This is a wildcard. It huge however but from 2008 so I’m sure there are some useful stuff in it, notwithstanding the age. That said, I’m told that in gaming things don’t move that quickly but I’ve heard other sources say it moves faster! I’m after the concepts, however – the ones that survive the test of time.
On my investment tracker project, I’m working to improve my recently introduced feature – transactions because there are bugs that prevent it from being usable. I’ve started recording them on my Github page. This is a development work in progress so there are still some rough edges particularly error handling and site access (login and registration) is not finished. That said I’m quite happy with the overall progress of the project.
I’ve been looking into Caliburn.Micro recently to help me quickly build a WPF UI for it but this is still in the starting blocks – early phase.
I also upgraded by Fedora box from 29 to 30 which broke my tablet. For some unknown reason (something that seems to pervade this bloody tablet) it didn’t want to log into Gnome. The new version of gnome is special and one of the reasons I wanted to upgrade so that sucked. Up until this time I’d just left it – I’ve got bigger fish to fry. I don’t have a keyboard (USB) so interacting with it at in emergency rescue mode is a non-starter. So I decided to got out and buy a brand new keyboard for the tablet (sounds silly) but it enabled me to finally fix the issue.
Through some trial and error, I found that XOrg could not find libgtk-3.0-dev which sounds to me like the upgrade process made a boo-boo so I uninstalled gdm because that is what probably needed it and reinstalled it. That worked. So, I’ve still got all my content and don’t have to start again. Why go through all this pain and torment? Good question, I guess I’m a masochist. Phew!
So, with the extra keyboard around I decided to use it more routinely and plugged into my laptop and used it to code and it was so much nicer – I loved it! So maybe I’ll continue having a slightly odd-looking setup: A laptop and a tablet with a full-sized keyboard. Whatever works I say.
Still running – always running.
- Details
- Category: Blog
- By Stuart Mathews
- Hits: 3544
Since Retro sounds, Event Manager and some running I've been focusing on a few things lately:
- Game programming - implemented a Resource Manager using C++/TinyXml2
- My Tuesday programming course on C in the City
- Formulation of my frameworks on "Now" and "Zen"
- Meeting protocol
- DK Money book
- University study (Continuing professional development)
- Avengers: End Game
Let's start off from the top.
I implemented a resource manager for my prototype game which is responsible for cataloguing all the images and music files that my game uses.
Basically, to strategically load and unload game assets during the game, you need to know where they are, what they are and which level they belong to.
All this information is centralised into an XML file that holds this information:
<?xml version="1.0" encoding="utf-8"?>
<Assets>
<Asset uid="1" level="1" name="MainTheme.wav" type="fx" filename="Assets/Music/MainTheme.wav"></Asset>
<Asset uid="2" level="2" name="scratch.wav" type="fx" filename="Assets/scratch.wav"></Asset>
<Asset uid="3" level="3" name="high.wav" type="fx" filename="Assets/high.wav"></Asset>
<Asset uid="4" level="4" name="medium.wav" type="fx" filename="Assets/medium.wav"></Asset>
<Asset uid="5" level="5" name="low.wav" type="fx" filename="Assets/low.wav"></Asset>
<Asset uid="6" level="6" name="maze1r.png" type="graphic" filename="Assets/maze1r.png"></Asset>
</Assets>
And the manager basically loads it up and stores this metadata in memory in the form of a list of "Resources" which is what the resource manager does - it deserialises the XML into Resource objects and caches them:
#pragma once
#include <string>
#include <map>
#include "Resource.h"
#include "tinyxml2.h"
#include <memory>
#include "tinyxml2.h"
using namespace std;
using namespace tinyxml2;
class ResourceManager
{
public:
static ResourceManager& getInstance()
{
static ResourceManager instance;
return instance;
}
ResourceManager(ResourceManager const&) = delete;
void operator=(ResourceManager const&) = delete;
std::shared_ptr<Resource> GetResource(string name);
private:
ResourceManager()
{
// Load the resources on creation of the Resource Manager
LoadResources();
}
void LoadResources();
// Record the asset in the catalog of assets
void RecordAsset(tinyxml2::XMLElement * assetElement);
// Make Asset from Asset XMLElement
std::shared_ptr<Resource> GetAsset(XMLElement* element);
// catalog of assets managed by this manager
std::map<std::string, std::shared_ptr<Resource>> m_resources;
};
So now, I can strategically remove things that are in memory that don't need to be - I'll know exactly what the resources are and thus I'll be able to unload them appropriately and load new resources using the path meta-data in the resource objects.
I had to learn how to use TinyXML2 which is supposed to be super fast. it probably is but its a bit weird to use.
For example, you can't just iterate through all the "asset" elements, you need to find the first asset element, then iterate through the remaining 'siblings'. This is probably because the XML file's DOM is stored as a linked-list in memory I think. See TinyXML2
This is how I turn the XML previously shown into the list of Resource objects previously mentioned:
#include "ResourceManager.h"
#include "tinyxml2.h"
#include <iostream>
#include <map>
#include "Resource.h"
using namespace tinyxml2;
using namespace std;
std::shared_ptr<Resource> ResourceManager::GetResource(string name)
{
auto resource = m_resources[name];
return resource;
}
void ResourceManager::LoadResources()
{
std::cout << "Loading all the resources from the Resources.xml ..." << std::endl;;
XMLDocument resourceFile;
// Load the resource file into memory
resourceFile.LoadFile( "resources.xml" );
// Get first Asset
auto pRoot = resourceFile.FirstChildElement();
auto pFirstAssetElement = pRoot->FirstChildElement("Asset");
RecordAsset(pFirstAssetElement);
// Get remaining assets elements
auto pNextAsset = pFirstAssetElement->NextSiblingElement();
do
{
RecordAsset(pNextAsset);
}
while ((pNextAsset = pNextAsset->NextSiblingElement()) != nullptr);
}
void ResourceManager::RecordAsset(tinyxml2::XMLElement * pNextAsset)
{
auto nextAsset = GetAsset(pNextAsset);
m_resources.insert(std::pair<string, std::shared_ptr<Resource>>(nextAsset->m_name, nextAsset));
}
std::shared_ptr<Resource> ResourceManager::GetAsset(XMLElement* element)
{
int uuid;
const char* type;
const char* path;
const char* name;
int level;
element->QueryIntAttribute("uid", &uuid);
element->QueryStringAttribute("type", &type);
element->QueryStringAttribute("filename", &path);
element->QueryStringAttribute("name", &name);
element->QueryIntAttribute("level", &level);
auto asset = std::shared_ptr<Resource>(new Resource(uuid, name, path, type, level));
std::cout << "Fetched Asset " << asset->m_name << "of type " << asset->m_type << std::endl;
return asset;
}
I also turned this into a Singleton and used the same pattern in my event manager that I created previously in Retro sounds, Event Manager and some running. I then substituted the global reference that I previously used for a single EventManager::getInstance() throughout the code. It's all quite elementary but fun.
Apart from that, I've not made other major inroads were made however I'm still scheming...
I'm reading "Game Engine design and Implementation" by Alan Thorn which inspired me to turn my event manager into a singleton and implement the resource manager. It's quite an old book but the main gaming concepts remain the same throughout the years it appears.
I attended the 2nd lecture on C programming on Tuesday and learnt some interesting perspectives about binary and one very quick and easy way of converting to/from binary or Hex.
The other interesting thing that I learnt was about 24bit pictures in relation to how many bits are used to store a single colour in an image. I always find these lateral concepts surprise me from time to time. This is all very serendipitous as I'm loading bitmaps into my game prototype. The other interesting thing I learnt was that another student works for the same company as I do, which is remarkably coincidental.
While studying my course work for "Continuing Professional Development", I've found it quite interesting to learn about some of the emerging and current theories out there around the processes involved in learning. I've become fairly interested in some of the material.
Currently, I'm developing a framework, based on all the study material, that I might use to better reflect on past learning encounters/experiences. I've drawn it up and its currently in the draft stages. I'm calling it my "then framework" as it draws on strategies to reflect on the past.
In parallel, I'm developing a framework to assess situations, which is a precursor to the "then" framework which I'm calling my "now" framework. I know, I'm quite original.
This framework is about understanding or being aware of the current situation, the nature of your strategies and behaviours in these situations and basically defining them so you can better know yourself fundamentally and how you can potentially learn to change these tendencies/strategies etc. moving forward.
Quite interesting really.
On the running front, I'm still loving it. posted a 64 VO2max record last week so things are looking good:
VO2Max record 3.0 hoo-rey! pic.twitter.com/9pmGhvhvCj
— Stuart Mathews (@stumathews) May 9, 2019
As I've mentioned in one of my tweets, I've got another case of Lateral Shoe Disease, which I've now determined is probably because of a few things.
- I under-pronate quite a bit causing excess strain on the sides
- I don't look after my shoes enough after running.
Yeah, regarding point 2, I think what is happening is that the material on the outside as shown below is becoming brittle and weaker because of the dust that I pick up while running. My theory is that this settles within the fabric and then forms clumps that fill in the mesh-like fabric making it harder and more easily prone to tearing. In short, I need to clean my shoes.
Another victim of LSD ie.lateral shoe disease. Subject C : pic.twitter.com/GcwwWDLVTR
— Stuart Mathews (@stumathews) May 4, 2019
And as such, I bought a new pair of trainers. These are not replacements but until the LSD is fully set in, I can delay the onset of eventual demise by using other shoes to run in and hence decrease the frequency of strain those poor old shoes have to endure.
So its a matter of setting up running shoe round robin really.
I did a lot of research on these new running shoes (As I do) and I decided on the Adidas Ultra Boost 4.0 Triple Black. Now, as my Pegasus 33, as shown above, are pretty much the flagship Nike running shoe and I've gone through 2 (almost 3) due to excessive wear and tear, I figured I'd switch brands. So I opted for Adidas' running equivalent.
These are they:
Coming soon on #adidas US.
— adidas alerts (@adidasalerts) November 15, 2018
adidas Ultra Boost 4.0 Triple Black.
Releasing Monday, December 3.
—> https://t.co/9hgziDNgfU pic.twitter.com/feiFpv7zWR
So, In other news, I've also been thinking about developing a new project that effectively defines and constrains meetings.
I often find meetings to be painful and ultimately just talky-talky and usually only benefiting some - or maybe everyone else! So I've been thinking of a meeting protocol such that it defines how one should run a meeting. Specifically, what process to follow and prevent skipping steps. Almost like a workflow, I guess.
It's more of an application that shows meeting attendees where they are in the meeting process and looks to include all participants equally instead of just the ones you shouts the loudest. Quite interesting idea. So that's something I'm keen to do and I'll probably use Angular 6 and deploy it to the cloud. I'm really enjoying this technology at the moment.
I also watched Avengers: End Game and I enjoyed it. I wouldn't say I was excited or absolutely spell-bound by it but that is to be expected - it's not a new movie so I didn't get new-movie-vibe type excitement. I got an appropriate level of awesomeness and for over $1 Billion spent on the film. I'd hope it was appropriate!
I'm not really a serious movie critic however but I like what I like.
More Articles …
Page 25 of 182