2013 -> 2016 – SG – Commando Developer

Commando Developer (VBA, Python, C++) – Revenue Cash Reinvestment desk support

EmploymeNt Dates sept. 2013 – avr. 2016

Employment Duration 2 ans 8 mois

LOCATION Paris , France

Support and implementation of new program’s functionalities in commando style development (very-fast development) alloying the reinvestment of the cash generated by security lending activities.

Achieved activities :

Functional achievements :
– Achievement of an automatic cash allocation tools for cash distribution with target allocation ratios in Mutual-Funds.
– Programming and improvement of Profit and Lost reporting tools (Performance improvement, new reporting methods setting up…)
– Back office flow achievement and management (Position movement, Cash movement, Security movement, Performance…)
– Monitoring and support activities
– Assistance and retro-engineering of the achieved scripts in commando style

Technical achievement :
– Performance improvement in order to cope with volumes increase with ordered and treated deals (achievement of ACID interfacing between achieved software and database). ADODB Framework
– VBA routines Writing / Re-Writing
– Performance critical VBA script to C++ rewriting
– Applicative migration from VBA Access to MS .NET
– VBA Software adaptation in order to migrate it from Windows XP to Windows 7

Transverse achievement :
– Jython’s DLL writing (Python compiled in Java ByteCode) in order to integrate VBA commando written script in Reuters Kondor K+ package software.

Welder cart project

When you buy a welder, very often the welder does not come with it’s own support cart. Very often your first welding project can be to weld your own carret.

Inspirate yourself

In order to build a cart you should know what are the primary and asides functionalities that the cart should propose. Google Shopping or Bing Shopping are a good source of information.

Another thing to check is the welder manufacturer proposals.

In my case this was the proposal of the manufacturer…

Do not reinvente everything, choose a good basis…

I had to find a good basis, in my case that was a dolly truck.

Diable rigide HAILO, charge garantie 150 kg | Leroy Merlin

Generally the point that you have to check with such products are the price and the presence of the a majority og the component that you need for your project. Entry-level product which are at the same time call product gather those properties.

Check your solution viability

Another thing to check is to check if there is no cheapest solution than the general cost of my project. If the cheapest solution respond to your quality expectation there is no reason to involve into this project and go buy the solution.

Design time

Create a CAD design of your project that report every measurement of the project. Take care of the simplicity of the solution/cart. Complexe stuff are generally expensive to build.

My carret CAD design

The result

After multiple iteration cycle at the end the cart is like this…

Two used dolly truck and one metal sheet.

Missing enhancement :

  • Alimentation cable reel.
  • Welding attachment strap
  • other stuff…

Beware ! The trap here, as you have the power to enhance your trolley is to make a thing that is over complicated. Keep that in mind : Keep it simple as possible !

Database Template Handler Project

As the ORMs (Object Relational Model) are now very used in the computer development project in order to manage interfacing between systems, the DB Template Handler project is an atempt to solve the issue of the heterogeneity between languages that you interface in your data access layout.

The Project try to create a devoted semantic and language basic functionality to manage the generation of every file suitable to database or other DAL interfacing.

Image

The project page :

https://github.com/cosXsinX/DBTemplateHanlder-NetCore3

Jointure implementation in C#

Sometimes when you want to manage your code efficiency you may need to optimize some .Net implementation.

Jointure implementation in C# may be such a case.

Underneath you will find my proposal to implement a jointure in C# environment. This is a generic code and may be optimized in many way for your implementation needs. It use System.Linq but remediation can be done very easily to not depend on this library.

using System;
using System.Collections.Generic;
using System.Linq;

namespace org.maximilienzakowski.Jointures
{
    public static class Extensions
    {
        public static TJ[] InnerJoin<TL, TR, TK, TJ>(this IEnumerable<TL> lefts, IEnumerable<TR> rights, Func<TL, TK> onLeftKey, Func<TR, TK> onRightKey,
           Func<TL, TR, TJ> jointureBuilder)
        {
            var leftsWithKeys = lefts.Select(l => new Tuple<TL, TK>(l, onLeftKey(l)));
            var rightsWithKeys = rights.Select(r => new Tuple<TR, TK>(r, onRightKey(r)));
            var rightGroupsByKey = rightsWithKeys.GroupBy(r => r.Item2, m => m.Item1).ToDictionary(m => m.Key, m => m.ToArray());
            var defaultJoineds = new TR[] { };
            var enumerable = leftsWithKeys.SelectMany(m =>
            {
                TR[] joineds = defaultJoineds;
                if (m.Item2 != null)
                {
                    rightGroupsByKey.TryGetValue(m.Item2, out joineds);
                }
                return (joineds ?? defaultJoineds).Select(joined => jointureBuilder(m.Item1, joined));
            });
            return enumerable.ToArray();
        }
        public static Tuple<TL,TR>[] LeftJoin<TL,TR,TK>(this IEnumerable<TL> lefts, IEnumerable<TR> rights, Func<TL,TK> onLeftKey, Func<TR,TK> onRightKey)
        {
            return LeftJoin(lefts, rights, onLeftKey, onRightKey, (left, right) => new Tuple<TL, TR>(left, right), default(TR));
        }

        public static Tuple<TL,TR>[] LeftJoin<TL,TR,TK>(this IEnumerable<TL> lefts, IEnumerable<TR> rights,
            Func<TL,TK> onLeftKey, Func<TR,TK> onRightKey,TR defaultJoined)
        {
            return LeftJoin(lefts, rights, onLeftKey, onRightKey, (left, right) => new Tuple<TL, TR>(left, right), defaultJoined);
        }

        public static IList<TJ> LeftJoin<TL,TR,TK,TJ>(this IEnumerable<TL> lefts,IEnumerable<TR> rights, Func<TL,TK> onLeftKey,Func<TR,TK> onRightKey, Func<TL,TR,TJ> jointureBuilder)
        {
            return LeftJoin(lefts, rights, onLeftKey, onRightKey, jointureBuilder, default(TR));
        }

        public static TJ[] LeftJoin<TL,TR,TK,TJ>(this IEnumerable<TL> lefts, IEnumerable<TR> rights, Func<TL,TK> onLeftKey,Func<TR,TK> onRightKey, 
            Func<TL,TR,TJ> jointureBuilder, TR defaultJoined)
        {
            var leftsWithKeys = lefts.Select(l => new Tuple<TL, TK>(l, onLeftKey(l)));
            var rightsWithKeys = rights.Select(r => new Tuple<TR, TK>(r, onRightKey(r)));
            var rightGroupsByKey = rightsWithKeys.GroupBy(r => r.Item2, m => m.Item1).ToDictionary(m => m.Key, m => m.ToArray());
            var defaultJoineds = new TR[] { defaultJoined };
            var enumerable = leftsWithKeys.SelectMany(m =>
            {
                TR[] joineds = defaultJoineds;
                if(m.Item2 != null)
                {
                    rightGroupsByKey.TryGetValue(m.Item2, out joineds);
                }
                return (joineds ?? defaultJoineds).Select(joined => jointureBuilder(m.Item1, joined));
            });
            return enumerable.ToArray();
        }


        public static Tuple<TL,TR>[] FullJoin<TL,TR,TK>(this IEnumerable<TL> lefts, IList<TR> rights,
            Func<TL,TK> leftKeyFunc, Func<TR,TK> rightKeyFunc, TL defaultLeft = default(TL), TR defaultRight = default(TR))
        {
            var leftJoinedToRight =
                lefts.LeftJoin(rights, leftKeyFunc, rightKeyFunc, defaultRight).ToArray();
            var joinedRightKeys =
                new HashSet<TK>(leftJoinedToRight
                    .Where(m => m.Item2 != null)
                    .Select(m => rightKeyFunc(m.Item2)).Distinct());
            var defaultLeftAndMissingRights =
                rights
                    .Select(m => Tuple.Create(m, rightKeyFunc(m)))
                    .Where(m => !joinedRightKeys.Contains(m.Item2))
                    .Select(m => Tuple.Create(defaultLeft, m.Item1)).ToArray();
            var fullJointure = leftJoinedToRight.Concat(defaultLeftAndMissingRights).ToArray();
            return fullJointure;
        }
    }
}