Shaping your profesional skills structure

Hey guys,

So, professional shaped skills… What’s that. Basically, it’s the form your skills take concerning your expertise in your individual field(s). This form will depend on both depth and broadness. Trying to learn as many things as possible will lead to little depth and a large broadness of skills. The exact opposite leads to an ‘I’ form where you’ve picked up a single domain and you’ve decided to become an expert.

The problem with being a jack of all trades, we can’t justify our opinion on a particular subject, you may be not be in a place to answer that question. Although your opinion may not be value because you’re not expert, I do believe that trying to learn as many things as possible will bring you baggage. This baggage can help form some sort of highly credible hypothesis when you’re asked, let’s say, by a client a particular question such as what should be done in case you’d like to build a website and include the X feature.

Let’s talk about the expert. The expert is the go to guy. He’s the guy you want in your team to be able to quickly build a project from the ground up and see it through. Some problems may occur and because of his/her experience, you will have sound advice when you need to ask the hard questions. Although becoming an expert may seem like the thing to become, I’d advise to think it over again. Becoming an expert in one thing may lead to problem career wise in my honest opinion. You may wake up on morning and feel like you’ve waisted 5, 8 or even 12 years in a field and it doesn’t attract you any longer. You don’t have anything else to fall on.

This brings me to the principal shapes for professional skills. T-shaped skills is when someone would combine some deep expertise on a topic with a broad and more shallow knowledge on things. Pi-shaped skills would be to have two deep expertise and comb-shaped skills one person having multiple set of skills.

In my case, if I were to pick right now the set of skills I’d like to deepen and the rest would be “noise” helping me getting a better all-around software engineer, I would only pick a few. Here’s the list below.

  1. Artificial intelligence and machine learning
  2. Functional programming
  3. Mobile cross-platform development
  4. Oriented-object architecture/design (OOA/OOD)
  5. User experience design

Yes some of those skills are far from each other and some are pretty close to each other. Thing is, right now, there perfectly aligned with the set of skills I have / want to have. More than that, I think those 5 fields are large enough to let me bounce on feet whenever I feel the need.  I can start projects of my own whenever I’ll feel the need. Bottom line, I may not become the best guy in each of those fields. Nevertheless, I think the challenges those fields will make me face throughout my career will make a better developer.

Which one should people try to aim for ? Try to pick 1 or even 2 skills you’d like to develop in your domain. For someone in software development, I could say you could try with web development and databases and move on to other related subjects once you feel comfortable enough to work juggle with new things. Comb-shaped skills are hard to maintain and it makes sense. You need to spend a lot of time to cultivate them and even more time to maintain them. As you become more and more advanced, you’ll need to read research papers, go to meetups and even conferences to deepen your knowledge.

Right now, the skills I decided to work on may seem hard to maintain. I think we should know our limits and see how much time we can afford to spend on those skills. Since I’ve started my career in software engineering, I’ve been able to see what I’m good at but more importantly, what I’m bad at. With those specifics in mind, I decided on the abilities I want to have in a near/far future. I’ll finish with this: have a broad knowledge to become a better generalist and at least one thing where you are an expert.

Becoming a strong generalist will help you decide what you may like enough to start spending more time in it in order to become a specialist. Don’t forget to have some insights on competitive technology stacks that are out there. Each of them will have their strong/weak points.To work on a project, one would need to be aware of what’s out there to be able to make a wise decision.


Become better, learn better, do code katas !

Become better, learn better, do code katas !

Hey guys

Today, I’m here talking about how to better ourselves us developers. We’re always learning while working and that’s bad. We should instead learn in our own time and practice before trying to use our tools to resolve the bugs in the software and the features requests from the clients. Learning on the job takes that much more time to work on our things when we should only be working on what we’re being paid for. There are many ways to learn and I’m not saying that sharping your skills with code katas is the best way to do it. No. What I’m trying to say is that you should try to spend some of your free time and practice one of your many languages.


Through code katas, one can learn and practice many core and advances computer science/software engineering concepts. A code katas is a problem that must be solve in any way possible. The fun of doing them is trying different ways to solve a problem and see which way would be the best way to resolve the issue. Using a code kata platform such as Codewars, after solving a problem, you can see the solutions of other people. This way, even if you’re an advanced user of X language, seeing other solutions can bring you perspective and show some internal API function you couldn’t have thought of.

And yes, I know you want to become better. One cannot become a master of his/her craft without devoting time to practice and practice. Practice makes better. It’s undeniable. We need to practice and better ourselves. This way, you can be a even better software engineer at work and earn that well deserved promotion. If you’re an entrepreneur, well practicing will help you learn things that code bootcamp couldn’t show you because you have a limited time to see a bunch of stuff.

But let’s get one thing clear. It’s not productive to repeat the same problem. It does not bring you closer to the path of enlightenment. Let’s look at it this way. When we’re babies, we must practice for a long while before we can learn out to walk by ourselves. But after that, “practicing walking” doesn’t make your walking any better, does it ? Practicing the same thing will be beneficial if only you try to include constraints and twists to make it an even better scenario. For instance, well this time, I can only used one kind of data structure or I have to used a maximum of X local variables or I can only used a certain amount of character space.

Code katas bring you closer to the path of enlightenment in cases where you do make it harder and trying other problems. As you solve more code katas, try to take on harder problems. Doing so, this practice is actually worthwhile and those challenges will introduce you to new ways of thinking. I think you can pretty much gather that I strongly recommend acting this way. One thing that I must say is this: try to solve your katas without using an IDE. You’ll be able to remember your basics and try to focus on a simple solution without letting the IDE make life easier for you.

I’ve been talking about using efficiently code katas to improve yourself. I can’t speak for everyone out there, but I would like to attain mastery as quickly as possible. As I said before, to get to the level of skills that you would like to get, you need to practice at an higher level of difficulty. Being used to practice to a hard level, what you do on a constant basis will seem that much easier.

To become better, we must :

  1. Practice smarter. Not repeat the same things but try harder challenges or adding twists in scenarios and make those challenges harder.
  2. Cast aside some of your personal time. Doing nothing more than what you have to do won’t bring where you’d like to be.
  3. Don’t use IDE. IDEs will make it that much easier to use complicate constructs and will auto-complete your solution. Well, I’m saying that for people who are practicing for an interview. You have to remember your language API and be able to solve a problem in front of the technical team who’ll judge if you are at the right technical level.
  4. Look at other’s people code. See, when you solve a problem, you might think that the solution you have is the best one and that was the only way to do it. Looking at other people solutions will bring you clarity and will broaden your vision.


On an ending note, you can’t learn everything you want to learn through code katas only. You must also cast time aside for personal projects or try to contribute on open source work. All of this work is necessary to bring you a little closer to the level you’d to be on. And when do get on that level, try to go even further !


GSOC 2015 : From NRefactory 6 to RefactoringEssentials

GSOC 2015 : From NRefactory 6 to RefactoringEssentials

Hey guys,

In spirit of my withdraw from the Google Summer of Code program this summer, I thought I’d do a piece of the project I successfully completed last summer. So what brought me to the program last year ? I spent a few weeks on working on a new thing in .NET called Roslyn. For my internship, I had to develop design semantic rules that my senior programmer was giving me. The first one I had to do was detect when developers were using “synchronization primitives” such Mutex, Monitor or Semaphore. Internally, they had developed something else to help better avoid dead/live locks. Acting this way, they could refactor previous projects and make sure to use their internal structures.

That one took me a while because there weren’t any useful (in my opinion) links that I could find on the subject (Winter 2015). The one I am most fond of was one where my senior found out that they were many times developers were making syntactically and orthographic errors. My job was to develop an algorithm which could pinpoint those mistakes in either variables/members/parameter/method names or even in comments. Part of my algorithm to match the errors was to used a dictionary having all the possible errors for a word as values and the correct word as the key. Doing so, I had part of the solution to develop the refactoring in case my code analyzer picked up anything.

So, back to the GSoC 2015 program. I saw the Mono Project project, NRefactory. The NRefactory library defined code issues and code actions which are basically code analyzer and code fix providers in Roslyn. The library was implemented using FxCop. But there were more traction at the time towards Roslyn. The idea behind the project was to port NRefactory 5 to version 6 using the Roslyn API. Code issues were define and the task was to reimplement them in code analyzers and define a proper code fix provider. Here’s below a non-exhaustive list of what I’ve implemented over the course the summer.

  • Rewrite if return to a simple return
  • Remove redundant code : invoking ToCharArray on a string
  • Remove redundant code : empty finally blocks
  • Remove redundant code : useless parameters in a method declaration
  • Making a member static once I’ve seen that value is never changed

So here’s a link to my GitHub repo.

Kevin out.



Augmented Tactics: A role playing game prototype

Augmented Tactics: A role playing game prototype


Today, I’ll be talking about a special project I have not only designed from A to Z but also implemented. Well, it’s not as  big as this sentence let’s it sound. I worked on developing a prototype of a mobile game in augmented reality. Being a huge fan of tactical RPGs, I found it natural to try to develop a tactical RPG prototype. Augmented Tactics tries to replicate the same experience players had when playing Final Fantasy Tactics. After working on this for about 2 months, and I will do it again this fall, I feel compel to talk about the work I did so that others might found inspiration for their project. When I’ll complete the next phase of the prototype, this time called “SmartTactics”, I will then talk about its progress.

What did I want to achieve ?

Being a huge fan of TRPGs like I’ve mentioned earlier, what I wanted to achieve was to re-create a typical battle system. Such a system would include a certain number of characters of different class ( Magician, Swordsman, Lancer, etc) in both parties. Those classes would have the special abilities such as attacking with a weapon (sword, axe or whatever) or spells and also,each of those classes would have a tactical advantage to one or more.

In many games, players must move their character in a squared field where depending of the character’s stats and class, he/she can move from 1 to a maximum squares (let’s say 7) during the movement phase. I wanted also to give different options to the player during the attack phase. With that in mind,  attacking an enemy from the side would give a bonus when attacking, which would be added to the attack bonus if that character had any special role advantage.

Characters coming from a Magician sub-class such as Spellsword, Healer, Dark Mage, etc, would have each have 1 to 2 different spells depending of the sub-class and the strength of those spells. Something that would be a fun mechanic (in my honest opinion) would spells that could interact with the environment. For instance, a spell that could create a line of fire and if a character goes through that line, he/she will suffer burn side-effects until the side-effect goes away or a special item is used to counteract that effect.

Talking about fun mechanics for my prototype,  each class would have certain number of action points which would include actions such as moving, attacking, rotating and so on and so on. The player would need to correctly use those points to form a strategy to defeat the AI. Not only that, working with Unity would provide me the chance to play with augmented reality.  Vuforia is an easy API that seamlessly integrates with the game engine and can project the 3D models using a special anchor in the real world.

Developing under TDD

In an effort to develop this game correctly, I design the tests using NUnit. I don’t have to tell you that TDD enabled me to think of the code I wanted to do in order implement, for instance, a character builder. The character builder creates a character, gives it stats and different kind of information. There’s one example below.

 [TestCategory("Character Builder")]
 public void CharacterBuilder_BuildAnNormalHealer_Successful()
var character = new CharacterBuilder().CreateCharacter()
        .WithStats(0, 10, 10, 10, 10, 10, 10, 10)
    Assert.IsInstanceOfType(character, typeof(BaseEnemy));
    Assert.IsInstanceOfType(character, typeof(NormalHealer));


Player abstraction

I know that some systems are faulty  because of their design. Such design problems can be categorized as “too coupled”. Having that in mind,  most of the code is based on the following classes : CharacterObservable ,IChoiceAction and ICharacterActionCommand. The first abstract class give the power to manipulate characters at any stages, whether I’m building that healer class or that berseker is about to die and I have to notify the game manager to launch the dying sequence before destroying the game object. For those who find CharacterObservable  name funny, I based the work on the Observer pattern.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Assets.GameCoreLogic.Managers;
using Assets.Map_AI;
using Assets.Scripts.CharactersUtil;
using UnityEngine;

namespace Assets.GameCoreLogic.Human_Game_Objects
public abstract class CharacterObservable : MonoBehaviour,IGameObjectObservable, ICharacter
protected ArrayList ObserversList = new ArrayList();
public BaseCharacterStats BaseStats { get; set; }
public Health Health { get; set; }
public List<ICharacter> CurrentEnnemies { get; set; }
public List<ICharacter> TeamMembers { get; set; }
public int MovementPoints { get; set; }
public PlayerDirection Direction { get; set; }
public Cell CurrentCoordinates { get; set; }
public Cell OldCoordinates { get; set; }
public bool IsDead { get; set; }
public int[] Position { get; set; } // [0]=x, [1]=y
public Animator Animator { get; set; }
public CharacterType CharacterType { get; set; }
public Role CharacterRole;
public bool isDamage;
public bool healthWasRaised;

public abstract bool CanDoExtraDamage();
public abstract void CheckIfCharacterDead();

public void Attach(IGameObjectObserver observer)
if (observer == null)
throw new ArgumentNullException(nameof(observer));
if (ObserversList.Contains(observer))
throw new InvalidOperationException("Cannot have duplicate observers.");

public void Detach(IGameObjectObserver observer)
if(observer == null)
throw new ArgumentNullException();
throw new InvalidOperationException("Cannot remove observer when observer not in the list.");
if(ObserversList.Count == 0)
throw new InvalidOperationException("The observer list is empty. Cannot detach.");

public abstract void Notify();

IChoiceAction interface let’s me create the sequence of action the AI can do. Through the interface, the AI can build an attack sequence to either attack the closest human player or the one most likely to get a maximum damage due to a certain number of parameters.

using Assets.Scripts.Artificial_Intelligence;
using Assets.Scripts.CharactersUtil;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Assets.Map_AI;

namespace Assets.GameCoreLogic.AI_Core_Logic
public interface IChoiceAction
#region Movement Decisions
bool ArePlayersWithinRange(List<BaseCharacter> humans);

bool CanMoveAway();

bool ShouldMoveAway();

void MoveAway();

bool IsFacingPlayer(BaseCharacter bs);

KeyValuePair<BaseCharacter, Tile> FindClosestTarget(List<BaseCharacter> humans);

KeyValuePair<BaseCharacter, Tile> FindEasiestTarget(List<BaseCharacter> humans);

void MoveTowardsTarget(BaseCharacter bs);


#region Attack and Defend

bool ShouldInvokeDefend();

void InvokeDefend();

void AttackPlayer(BaseCharacter bs);

void AttackPlayer(List<BaseCharacter> bsList);


#region Healer Needed
bool IsHealNeeded(BaseEnemy be);

Tile FindHealer(List<BaseEnemy> myParty);

bool IsHealerWithinRange(Tile healerPosition);

void MoveTowardHealer(bool healerIsInRange);


void FinishTurn();

ICharacterActionCommand interface let’s me build the battle system. Through that interface, I can notify the command manager when the player wants to attack an enemy or when I need to move to a certain place.

using Assets.GameCoreLogic.Managers;
using Assets.Scripts.CharactersUtil;
using Assets.Scripts.GameCommands;

namespace Assets.GameCoreLogic.Game_Command_Actions
public interface ICharacterActionCommand
IReceiver Receiver { get; set; }
bool IsExecuted { get; set; }

void Execute(ICharacter caller);
void Execute(ICharacter caller, ICharacter characterToAttack);
void Execute(ICharacter caller, int raiseDefense);

Acting this way, my code looks for either interfaces or abstract classes. Being not couple, the code becomes very reusable in my opinion and it made that much easier for testing after designing my tests.

Artificial Intelligence

Map Intelligence

After designing the map as a List of List of tiles,  I made it simple to highlight the tiles in the game to show the entire range of movement of a given character during the move phase, if the player desires to move the character, it’s up to him. In order to know what to highlight, I look at the move points available for the character, and I try to create paths that are still “opened” for the A* pathfinder algorithm. That algorithm enables to find the shortest path between point A and point B. That an useful algorithm for the character intelligence.

Character Intelligence & Move Selector

All characters all have the same the same intelligence. Being that I only had 2 months to build a working prototype, I couldn’t put too much time working in a field in which I wasn’t familiar (AI). Basically, characters can decide to

  • Move towards the closest enemy and attack it (ClosestTargetCommandSequence)
  • Go towards the enemy which will suffer the greatest damage (AttackMostDamageableTargetCommandSequence)
  • Upgrade temporally the defense stats for the course of a turn (DefensiveCommandSequence)
  • Efficient Attack which would be able to plan 2-3 turns ahead to see which would mostly be always attacking most damageable targets and staying clear of small parties that could kill you. (That was planned but neither designed or implemented)
  • Move towards the healer when health is low or heal member in party with the lowest health.
  • Move away from danger which could be something like this character has a tactical advantage on self or if I attack this character, I’m putting myself in danger because I’ll be close to a party of three and health is below X %.

The move selector enables the AI to select which command sequence to perform at each turn. Depending of the situation, each of the command sequences are created and weighted. For instance, moving to the fullest of the available move points doesn’t give a big weight. But, having a low health (~30 % for example) gives a much bigger weight. The sequence with the highest weight is perform through the use of a List<Action>. This is custom AI. I wasn’t really using AI algorithms except the A* implementation that I found online.

What I’m planning for phase 2 -> SmartTactics

For phase 2, I’m thinking of using many AI algorithms to help build the hard mode of the prototype. Using supervised and unsurpervised learning algorithms, I will be able to create a better AI that I had developed last fall. First, I’ll train the AI to adjust itself against players with high offensive stats and low defensive stats. Then, I’ll make so to train it using high defensive stats and low offensive stats. I’ll see how the AI reacts when placed in a simulated environment where characters have mixed stats.

To make things more stimulating, I will let the AI get experience and be able to level up its characters. Doing so, I will have to let it learn how best upgrade the stats using its brain to see which stats give better reaction in the field for a given class after leveling up. I would also like to see if that smarter brain can pick the best equipment from the merchant for any class.

I would use many different parameters to help the smart brain to practice and get better over time, things such as getting bonus points if brain get beat its best time, the experience concerning when a given strategy was used or the remaining health points of a targeted enemy.

I’ve been dabbling with F# during my internship and at my part-time job this summer. With that in mind and wanting to pursue my work in functional programming, I was thinking to port the game in F# in either Urho3D, Xenko, Duality or even Unity game engine. So the Augmented Tactics prototype will be ported from C# to F#. Being that I remain in .NET, the work wouldn’t be herculean. Another thing would be to make fixes and implement small lacking features from the first prototype.

You can look at the work I did during those 2 months here :


GSOC 2016 : The end

Hi guys,

Well because of health problems, I won’t be able to meet the expectation for the midterm evaluation coming next week and I will have to step down from the program. It pains me to do so since the project was taking me out of my comfort zone and forcing to adapt to a new stack and way of thinking. I thought that such a project was a necessary stepping stone for my growth as an aspiring software engineer  to be (graduation in July 2017).

Next year, I will apply again and with luck, my health won’t be an issue this time around !