This is mostly about other stuff and not about Kim Kardashian's butt.

I've had about 7 days off from exercise due to my coming down with a cold. I loathe it when this happens but its actually quite good to take a break from something you do so often. I think psychologically as much as physically. This has meant that I've pulled back from the gym in the mornings and missed my long run on Wednesday.  I always wonder if there was something I could have done to prevent getting sick - could I have not been eating correctly, or was it that I didn't wash my hands enough or am I not sleeping enough? Can you really prevent being ill?

This does coincide with it starting to become colder and I think there is a theory that this helps in getting ill. I've not really thought about why but there you are.

I'm also thinking that when I go back to training, that I'll switch my training program.

I'll switch from what has mainly been a heavily resistance-orientated program to a more well-rounded program. This means that I'll be focusing on a balanced set of training exercises that improve the various areas in fitness, not just strength. So this will include Flexibility, Endurance, Skill, Stamina, Strength, Speed and Power etc. My usual routine is normally doesn't include power moves, agility and speed and it's these that I'll focus on. Currently, I do 3 days of 1.5 hours of resistance exercise and 20 minutes of running and on a Saturday I do around 2h of resistance training. Usually what I do is after my main training session, is to go for a 20-minute run which sort of helps me with my endurance(and helps me get home!)

The other things that have been on my mind are finishing my next assignments for Software Engineering and Continuing Professional Development,(CPD)  both of which have deadlines in December. I've effectively had to rewrite my one assignment which was a bit of pain. The reason was that as part of the CPD I have to study a theory of learning an apply it to past CPD activities I'd done. As it turns out, I wanted to reflect on my past software development activities and projects and work etc as I thought this would be a great way to assess what I've done. Turns out, that I had far too much stuff to reflect on and the Tutor was uncomfortable accepting so much work.

So I did a whole bunch of writing for nothing in this respect. In another respect, I actually enjoyed doing it but that meant that I had to do it again but this time on a much more narrower form of CPD - My degree. That being said, I was able to reference some of the other personal projects I did so all was not lost.

I've found some time to study Understanding how the Linq query syntax works because there is a difference in understanding how it works and just using it because it works. I also found an interesting use of an extension method on a nullable type which I describe in Nullable checking in the Wild-West which was interesting. And I've also been working on my Game Engine ideas with regards to Direct X programming.

I'm also looking potentially at rewriting my C library because I don't use it anymore which is mostly because I don't write as much C and C++ as I used to and because I don't like some of the ways I implemented it. For example, I don't need the threading layer now because C11 now includes a cross-platform implementation of threading. And I also don't like my naming conventions and I'd like to add more data structures like black-red trees which is heavily used in the Linux kernel. I also started thinking maybe I should write it in C++ which lead me to write about C++ in Complex or Elaborate

I've not been able to be as productive in my programming side-projects as I'd otherwise like to these days because of the studies, training and work but I'm getting there. I drew up some pictures of some of the concepts I'm grappling within Direct X mostly to do with the idea of defining vertex data, writing that to vertex buffers and having those buffers sent through the 3D graphics pipeline to have them interpreted by vertex and pixel shaders. Pretty interesting stuff but without pictures, my mind usually goes to sleep.

I ordered a 9-cell battery for my laptop because I find that a 1-hour session on the train in the morning to work and back tends to deplete me and my battery by about between Rayners lane and Ruislip. I got it on Friday night and plugged it in and my laptop almost fainted with its new-found power(it couldn't believe it!). I'm just wondering now if I can taking something that will revitalise me at around Rayners Lane too... Anyway, its now got a big, fat bum, (a bit like Kim Kardashian's butt) see here if you like (a picture of the battery, that is)

I also ordered a new SSD drive for my ageing tablet, which I think is so old that the SSD started to fail. After spending like 4 hours figuring out how to get into the guts of my tablet, I was able to see that the SSD was one of these mini-chip-like peripherals about the size of a watch face. I inherited this tablet from a colleague who got it for free by attending a Microsoft Build event - I used it at the time to research Metro and Windows 8 Algorithms for App-DNA back in the day. It's a bit old now but seeing that I can quite happily work on any machine with an SSH connection, it's just absolutely fine. 

So, I took down the serial and looked it up on eBay and found a supplier for a 128Gb card for around 30 pounds. This I thought was reasonable and it that would be double the space I had...bonus! Turns out, it works great, fitted it and installed Ubuntu 14. Not bad, so now I'm getting some good use out of it on my desk at home.

These two are the only computer's I own - the laptop and the tablet. Though, I do have a Rasberry Pi too, which now that I think about would be a perfect project to write a game for. It's a restricted environment so I'd have to use C++ and be careful with my memory and loops. Cool!

In other news, I watched Deadpool, Office Space, Idiocracy and I'm busy reliving my childhood and watching MacGyver which is pretty awesome. I used to watch that every Friday night at 7 pm when I was a kid. Someone at work brought in season 5 DVD for me to watch which I thought was very good of him. I didn't think much of Idiocracy however it was perspective-inducing I guess. Office space was quite enjoyable and Deadpool was OK. 

I've finished playing Fable II and this has been quite a bit of fun, but finding the time do anything apart from studying and work has been difficult which I guess is why doing them is so satisfying. I'll probably move so play Metro: Last light or Dantes Inferno, however, I think its unlikely that I'll have another good attempt until I've finished my assignments..or now that I come to think about it, take some time off.

I watched the new Wreck-it Ralph at the cinema last weekend and I enjoyed it - quite like the first one. It's nice to see how my early childhood fascination with technology is now becoming mainstream as shown in this movie: Its how Ralph breaks the internet and it's cool to see topics like YouTube, Amazon, Instagram, eBay are now embraced in everyday life. This is my life, these are my friends!

Also what I really need to do is find a way to use my Perl knowledge because I've not found a good use for it of late not ever since I finished reading the Camel book earlier this year.

I've also been studying more interesting math facts recently about how to interpret really large numbers like 3212345678998765. Which, is equal to 3 Quadrillion 212 Trillion, 345 Billion, 678 Million, 9998, 765 ! But why?

Legend for the table below:

TH = Thousands, H = Hundreds, T = Tens, U = Units

So it becomes obvious how, where and why occurrences of TH x TH x TH ...n form the named numbers Quadrillion, Trillion, Billion, Million appear in the decimal system and its the iteration of 1000x1000 ⁿ.where n is Bi, Tr, Quad etc... Pretty interesting.

The key that is missing for many students is how Bi(2) meaning 2, Tri(3) meaning 3 , Quad(4) meaning 4, relate to the number it represents.  For example, if you are told that a Quintillion(6) is 10¹⁸ , which you often are, this's not obvious that this is because of 1000x1000⁶ which is 10¹⁸!! I think its a failure of teaching, in general, to explain why certain things are certain things - like this video demonstrates which awesomely demonstrate this failure of teaching: A negative x negative = positive.

The decimal system, in general, is a brilliant system and its all credit to the Indians! Here is something I drew up which puts this system into perspective.

That's pretty much most of what I've been up to recently. Now back to essays and word counts... 

When it comes to using LINQ expression syntax, I was a relatively late adopter not needing to really understand how it works. I'd just quite happily work with Select(o=>) and SelectMany() without knowing how fundamental they are in LINQ query syntax expressions. That is until I started using languageExt(though never mind about that for now). 

I won't be talking about LanguageExt in this article, rather how types, in general, interact with LINQ. This is however crucial when considering how languageExt types interact with LINQ.

An important aspect of understanding how the LINQ query syntax works is understanding why some objects can be used in LINQ query expressions while others can't.

In most cases, we seem to be able to use them on objects that implement the IEnumerable<T> interface. Why? But before I answer why, let see the LINQ syntax query in action:

from item in ienumerable

We also have this variant:

x = from itemA in IEnumerableA
    from itemB in IEnumerableB
    select itemA + itemB;

Ok, let's try and figure out what these things are doing and why we should worry about them at all.

What are these trying to achieve? Fundamentally what IEnumerable and Linq expressions are trying to do allow you to do this:

foreach(var a in listA)
    {
        foreach(var b in listB)
        {
             yield return Process(a, b);
        }
    }

Cool? Maybe not, interesting? definitely. So this means that it's trying to prevent you from having to keep writing for-each statements like the above. Why?

Because that's boiler-plate code - common code that you tend to write over and over again. What's wrong with the boiler-plate code?

Well its tedious and if we can remove the need to write it, then there will be no errors in any of it that you write. There are other reasons but another on is that you've replaced a conditional syntax with an expression. Nevermind that for now.

So if you look at a typical the LINQ syntax query again:

x = from itemA in IEnumerableA
    from itemB in IEnumerableB
    select itemA + itemB;

How this relates to the looping constructs we saw earlier, is that each "from X in Y" is represented by a for-each X in Y.

If you can think of it that way, it'll be much easier. Then when you're IN that for-each, theoretically, the next "from X in Y" represents the next level for-each(), so you're in the inner for-each loop: 

foreach(var a in listA) // from a in listA
    {
        foreach(var b in listB) // from b in listB
        {
             yield return Process(a, b); // select Process(A,b)
        }
    }

Looked another way:

x = from itemA in IEnumerableA // foreach(var itemA in IEnumerableA) {
    from itemB in IEnumerableB //    foreach(var itemB in IEnumerableB) {
    select itemA + itemB;      //      return itemA+itemB;
                               //    }
                               // }

So we've substituted a for-each conditional for a Linq expression. 

 So we've established that "from X in Y" is executed when in a Linq Expression where Y is an IEnumerable type and X is each item that it gets in the for-each loop. Ok, that's cool, but where is this for-each stuff thats supposedly being substituted for "from X in Y" written? Don't get me wrong i love not having to write foreach statements but there is it?

The answer that this common for-each code is put into the Select() and SelectMany() extension methods for the IEnumerable type. This is so that we don't have to write those for-each statements, they have been put into Select() and SelectMany() functions elsewhere. Extension methods are after-the-fact add-ons for classes, they are static classes however.They 'hook' onto the type without yuo needing to incorporate that method into the types code/definition. Here is what I mean:

To see the image in full res please go here

This would be a good time to go for a cup of tea and then come back once this stuffs percolated in your mind(or has started an internal fight in your mind, either way)

Ok, let's break down this diagram.

Firstly Select() and SelectMany() do roughly the same thing initially and then SelectMany() just does one extra bit.

Select and SelectMany() both perform a for-each on an item in the IEnumerable, effectively extracting each item from the IEnumerable and then it runs a transformation function on each of those items it got. 

That's basically what Select() does and the result of that function is then put back into a new IEnumerable. SelectMany() is the same up to that point. We'll get to how SelectMany() differs later but for now there are  two observations now need to make about Select()'s implementation:

1. The function that is run on each obtained item in the IEnumerable is called a mapping function and its supplied by the user. You can see its passed in as a parameter to Select and called map.
2. The result of running of mapping function on each item has the results put into the same place of the original item but in a new IEnumerable.(the original Enumerable is untouched and in fact, IEnumerables cannot be modified which is why they are made into a similar but new IEnumerable from the first)
3. This has effectively mapped each item in the original IEnumerable to the result of the map(item) function into a new IEnumerable. We also say that this has transformed the original item and put it into a similar but new IEnumerable as the original (but now it has the mapped() result version instead of the original item)

See, no magic, You can see the for-each stuff that's used in the Linq expressions now:

public static class EnumerableExtensions
    {
        public static IEnumerable<B> Select<A, B>(this IEnumerable<A> self, Func<A, B> map)
        {
            foreach(var item in self)
            {
                yield return map(item);
            }
        }       
    }

Note that extension methods like Select work on a Type indicated by the this operator in the first parameter to the extension method. In this instance the extension method if for the IEnumerable type.

Anyway, all this code is what happens when you see this:

x = from itemA in IEnumerableA  // foreach var itemA in IEnumerableA
    select itemA.Upper(); // this is basically the mapping function run for each item in IEnumerableA
                               
                               

the select clause (select item.Upper()) is passed in as the map() function.

Ok, but what about when you have two from clauses as the previous examples had? We've just explained that Select() makes the above work but that only has on from clause in it.

When you have two from clauses in it, thats when SelectMany() function is used:

public static class EnumerableExtensions
    {        
        public static IEnumerable<C> SelectMany<A, B, C>(
            this IEnumerable<A> self, 
            Func<A, IEnumerable<B>> bind, 
            Func<A, B, C> project)
        {
            foreach(var a in self)
            {
                foreach(var b in bind(a))
                {
                    yield return project(a, b);
                }
            }
        }
    }

As I said earlier, SelectMany() starts of the same way that Select() does, it performs a foreach on each item in the IEnumerable and runs a function on it. However this function is called a binding function and this functions results aren't passed immeditable back into the IEnumerable, they have to do a little bit more:

1. Again it gets each item in the IEnumerable (exactly like the Select() implementation)
2. It runs a bind() function instead of a map() function on each item - conceptually this is the same in the Select() implementation
3. The bind() function is provided by the user and it must be designed to return another IEnumerable (though we still wont pass the result back into the IEnumerable yet)
4. Another foreach it performed on the result of the Bind() function 
5. Each of those items(in the newly produced list) are passed into a Project() function, another function that the user provides, now the results of this secondary function are passed back into a similar but new IEnumerable as the original.

Quick observations about the SelectMany() implementation:

• You provide two functions in SelectMany() instead of one (as in the Select())
• The first is like a map() in Select() but is called bind() and both operate on each item in the IEnumerable (and they both transform)
• Where map returns a value, bind() returns an IEnumerable, those list of values are further processed by a project() function 
• The project function is the 2nd function passed into SelectMany() - Select() doesn't have a 2nd function.

Look at my diagram again and see if this starts to make sense:

 So that's fundamentally why the Linq Syntax query works on IEnumerables (or any types that have Select() and SelectMany()).

Why this is important in languageExt is because its types behave like IEnumerables that have also implemented Select() and SelectMany() and thus appear in Linq query syntax like this:

using static LanguageExt.Prelude;
 
   Option<string> optionA = Some("Hello, ");
   Option optionB = Some("World");
   Option optionNone = None;
 
   var result1 = from x in optionA
                 from y in optionB
                 select x + y;
 
   var result2 = from x in optionA
                 from y in optionB
                 from z in optionNone
                 select x + y + z;

So Option<T>, Either<L,R> can be viewed being able to do a for-each(var item in Option<t>) ...because that's exactly what happens in the above when its used in Linq syntax query expressions!

In the same way that a for-each gets each item in a list or an IEnumerable, the for-each gets an item from the option, or either and depending on its value, will determine if the next inner for-each will run or not.

And this article goes a long way into explaining how these types can be in those Linq expressions, to begin with. In the next instalment in this functional programming series, I'll explain a bit more about how actually works, but with this introduction, you can see that it has manipulated the Select() and SelectMany() methods so that it can be used in LINQ queries.

Note: List<T>, Arraylist<T> etc are all IEnumerables

I’ve adjusted to my new routine, I’ve successfully swapped my morning routine to an evening routine. This means I’m racing to the gym after work instead of comprimising important hours of sleep in the early morning. Studies have shown that neglecting the early morning hours of rest is deterimental to memory and learning. That’s according to the sleep scientist, Matt Walker in his book Why we sleep. So I’ve decided that I can reverse my routine.

That book has been fairly influential to me in other ways. I no longer drink coffee. Not because its unhealthy, which it isn’t really. More for the fact that it can impair your ability to sleep well and I know how impactful a bad night’s sleep has on running, gym and thinking at work. That being said, I do yearn for a warm cup of coffee from time to time. 

Someone offered me a free cup of coffee and whilst I thanked him for the gesture, I declined. After he’s puzzled gaze seemed to have lingered for more than I could stand, I qualified my ‘no thank you’ gesture with, ‘ I don’t drink coffee’ which I hesitated to mention and all of which I needn’t have done if it didn’t seem so weird that I didn’t want a free coffee. I got the same puzzled look when someone offered me a slice of pizza and another instance back when someone offered me chocolate: I always say as politely and graciously as I can, ‘ thanks very much but I’m ok’ because I don’t want to offend their goodwill but sometimes they are adamant that I’m being unusual! I like to be actively involved in my day-to-day decisions and its like my training - I stick to it. You’ve got to listen to yourself and respect your own choices and see them through. I like carrying through with my dicisions, otherwise it would’t be me!

I went for another run on Wednesday and it was great but tiring - I went down to Limehouse basin again but instead of running back up or going along the Thames, I went up another canal, adjacent to Regents canal which is the one I came down with towards Limehouse Basin Marina. It was so nice.

It was quiet and it was flat and winding. There was lots of graffiti and I’ve come to really embrace this form of street artwork on my runs. I probably wont see better quality and creative instances anywhere else other than in Shoreditch and surrounding areas.

I’m started becoming fairly familiar with these longer runs and I routinely take a gel with me and drink it at around 1 hours into the run. I’m now thinking of taking water with me too though I’ve not been one who’s been used to running with water. I’ll try it because it will make my run easier methinks. Here are the details of my last long run:

I recently started a new university degree and I’m looking forward to this year’s two modules. The first one is about continuous professional development which is about analysis of 400 hours of my last professional projects in software development with the view to assess/predict my future directions in the industry. This is a fairly interesting and a new way of doing things for me as I’m used to the more direct, technical things like learning how MongoDB works or designing mobile apps or programming full-on. I’ve not done this kind of assessment before: I’m going to have to do more reporting and analysis modules like this moving forward I think, ultimately culminating in my professional project which is the capstone of this degree.  The other module is more on par with traditional direct teaching - the software engineering bread butter stuff I’m more familiar with: teaching you software engineering best practises etc around software planning and management such as source control and requirements gathering etc. My last module was quite heavy into python and data analysis so  I’m offsetting things a bit by doing the slightly more theoretical stuff first perhaps as a strategy to recover from all the programming! I seem to recover in training by resting and I recover from studying by studying something something slightly more different and less familiar.

I think its safe to say that I wont be having much free time, especially at this level of study.

I’ve been working on my investment tracker app in my spare time, I’m learning a great deal about many things, primarily investing in general but in terms of software development I’ve learned an incredible amount about Angular 6+.

The last few features that I needed to implement were graphically representing some of the underlying investment data I have, This is primarily drawing visualisations. I’ve cobbled a pie, bar and interactive directed graph visualisations. I’ve not really learnt how to master their construction however I’ve not needed to in order to meet my requirements. So now I can easily see how various aspects of my investments relate(directed graph) and how over subscribed I am to certain aspects - a bar graph because easily shows equality inconsistencies more than I pie chart. Here is what the bar graph looks like:

The features of my investment tracker are complete. This is a great thing to achieve because its been a project that I’ve dynamically invented requirements as I’ve recognised the need. The last feature I implemented was what are called custom aspects. These are ways that you can define aspects to define an investment in a more specific way. It’s anologous to properties I guess and I sure I could represent it as this. This is how it looks:

It’s basically custom aspects where the default aspects or ‘entities’ of an investment are Factors, Risks, Groups and Regions. So now you’re not constrained to defining your investment by just four aspects - you can add as many as you like!

I’ve also strayed into the world of modal pop-ups and this has got me into trouble when I’ve got lots of data like as is the case with the shared relationships graph - the directed graph I mentioned earlier, see:

My goal now is to use it - because that’s why I developed it in the first place. Being a software developer must be one of the best jobs in the world as its all about thinking, modelling thought and solving problems in space. It’s truely fulfilling when you apply your fascinations and desires into it.

I also decided, for the first time in a long while, to fire up the XBox 360 and play a few games. I’ve purchased 3 games which is a bit OTT because one game usually takes. Like 3-6 months for me to finish. However the 3 games are all appealing and would quite probably make the succession anyway. They are Fable 3 which I’ve started and I’m enjoying tremendously as its very much Kingdoms of Amalur however I yearn for it to be more like it. The next 2 titles are in the queue and they are Castlevania, something to do with Dracula is the story. The next is Metro: Last Light which is not like the others - this is a first person shooter and It looked great when I played the preview more than I year ago - this is how long it been since I’ve played properly on my XBox!

I’ve got a day off today and I spent it developing the bar graph in my investment app. I’ve also been learning Perl and I’m fixing to use it on something. I really enjoy reading books on the train to work. I’ve not played any games today but maybe I will later now that I’ve done all things I wanted to do with the investment app. I’ve been writing perl for a while but I’m trying to improve: 

Oh and I’ve got Linux running on my Windows 10 box which is Great! I’ve installed an X server and I’m using xfce4-terminal which is far more superior than Windows’ default terminal. I’m very happy that Microsoft has invested so much in Linux this way because really this is now proper Linux within Windows the only difference is that the windows kernel is servicing the underlying the syscalls the apps request. Awesome. Not sure how this will influences the Linux kernel...as we’re not using one...

I also started to think about Parameter type validation recently.

We had a discussion about how validation firstly needs to be done and secondly how horrible it looks if its done multiple times throughout the code. It was briefly mentioned how this can be achieved using the C# type system to do on parameter. This idea in my mind wasn't appreciated and the conversation moved on without exposition on how this can be done. C++ Tends to take this approach a lot and its an approach that favours abstraction to achieve simplicity.

The idea is that if you have a function prototype like this:

int SetName( string firstName, string lastName )

Now this is a contrived example. Which apart from aall other other deficiencies in this line of code is intended by the programmer to mean subtract a from b. Another thing the programmer intends is that this function be correct when its precondition is that b > a.  As I said many deficiencies in this prototype hide intention, pre-conditions and other aspects that the function assumes or requires. This isn't about these kinds problems. I'd like to talk about how ugly the code around it looks:

Base case scenario this code is used like this:

// Is first Name or Last name empty dunno, no indication that it is or should be checked
var result = SetName(formFirstName, formLastName)

Somewhat better but now you can proliferate checking code all over the code:

// precondition check
if(!formFirstName.IsNullOrEmpty())  // basic check
    var result = SetName(formFirstName, formLastName)

But the question arises, "Where should the pre-condition checks occur? In the function or before it". I'd argue that it should be done before but I don't like seeing conditions like the above in the code. You can make the input into the function (a or b ) validate itself before its used in the function by making a new type which cannot be constructed when the a or b is invalid:

int SetName(Person person)

And so in the construction of Person you do your validation and this also as a side effect does the post-condition validation for the function.

But what if your constructor throw an exception during construction - that's bad and so we wont use one! How do we get around that? Easy. Smart constructors. This highlights 3 key aspects:

1. You can force validation of function inputs by using new a new type to validate construction of that type.
2. You can avoid exception which might have occurred during validation when constructing this new type.
3. (Bonus) Can also enforce immutability of the input so that functions can be more pure (the input cannot be changed in-place).

namespace FunctionalProgramming
{
    /// <summary>
    /// This is an immutable object because:
    /// a) Has private setters and that means its state cannot be changed after creation
    /// b) All properties are immutable - either strings or native types or System.Collections.Immutable types
    /// c) Any change that needs to take place must result in a newly create object of this type
    /// </summary>
    public class Person
    {
        public string FirstName { get; }
        public string LastName { get; }

        /// <summary>
        /// Notice this is a private constructor so a Person cannot be created normally...there must be another way in!
        /// It must be created indirectly via .Of() or .New() which then can use the private constructor below
        /// </summary>
        /// <param name="firstName">the persons first name</param>
        /// <param name="lastName">The persons last name</param>
        private Person(string firstName, string lastName)
        {
            if (!IsValid(firstName, lastName))
            {
                throw new ArgumentException("Invalid input");
            }
            FirstName = firstName;
            LastName = lastName;
        }

        /// <summary>
        ///  This pretends to be a constructor by being the only method allowed to call the constructor.
        ///  The actual and real constructor is only called if input is valid to this function 
        ///  As a result it gaurentees no exceptions can ever be thrown during creation of the object through
        ///  this method.
        /// </summary>
        /// <param name="firstName">Persons first name</param>
        /// <param name="lastName">Persons last name</param>
        /// <returns></returns>
        public static Option<Person> Of(string firstName, string lastName) 
            => IsValid(firstName, lastName) 
                ? Option <Person>.Some(new Person(firstName, lastName)) 
                : Option <Person>.None;

        private static bool IsValid(string firstName, string lastName)
            => string.IsNullOrEmpty(firstName) && string.IsNullOrEmpty(lastName);

    }
    
}

Something like that anyway ;-)