cosXsinX - maximilienzakowski.org

2016 -> 2017 La Française AM (Quant support & NoSQL Data migration)

Marklogic Integrator (Big Data – NoSQL) and Matlab/C#/Java Quant technical support

Risk database and workflow migration responsible

Employment Dates Feb. 2017 – Jul. 2017

Employment duration 12 month

Location Paris, France

Technical Achievements

– SQL Server 2014 (OLAP and OLTP association) vs Marklogic benchmark
– Stored procedure and pipeline processing workflow integration (XPath, T-SQL)
– Marklogic bi-temporality integration, alerting, pipelines features integration
– Big Data management steps integration :
–> data Ingestion : HTTP Web-dav protocol, MLCP
–> pre-control : Custom Excel parametric content validator integration
–> processing : transformation routine integration (XQuery -> Functional implementation)
–> post-control : XML/XSD design and ruleset integration
–> persistence : instance identity definition and persistence integrity management (XQuery -> Functional implementation)
– Data Exposition with ODBC interface server and Rest Services
– Process installation tools development (Powershell, Roxy, Ruby, REST)
– Data driven development :
–> Data consistency tests designing, integration and automation (Data driven development)
–> Integration/Processing performance testing
– Related BI programs tools benchmarking (QlikView, PowerBI,Tableau)

Management tasks

– Standup meeting organization (Agile)
– Milestone meeting organization, demonstration and presentation (Weekly) (Agile)
– Coordination with system administration for delivery purposes and hardware sizing
– Coordination of the offshores development teammates (communication with Serbia – MS Line)
– Technical and teaching support to Risk service on Marklogic, XQuery, XSD, XSLT, Javascript, JSON…voir plus

Integration of insurance financial products market stress testing simulator (Solvency II and derivates legislation) (massive computation).

Analysis tasks

– AIOPA Solvency II legislation rulesets analysis
– Customer needs analysis and computation model conceptualization

Quant support

– Excel requested GUI dashboard integration and interfacing (VBA, Matlab XLLink)
– Datasource interfacing and retrieved data correction workflow setup (C#, Matlab, COM)
– Custom inversion control Matlab architecture integration (Matlab, Java)
– Stress application (Vol shocking, Rate shocking …)
– Pricing engine interfacing, computation orchestration (Matlab 2016 R2)
– Simulation result database design and integration (SQL Server 2014)
– Matlab/Sql Server interfacing (Matlab, ADO.Net and Matlab Database, ODBC)
– Matlab process logging routine integration with log4j integration (not logm)
– Remote console listener implementation for monitoring purposes (Java, Swing)
– Database report result extraction tools implementation (SQL Server, C# 4, Excel Interop framework)
– Test Driven Development (TDD) and Data Driven Development
– Performance optimization with Matlab vectorization and functional programmation rules
– Multiserver computation with Matlab Parallel extension (Parpool and DHCP) -> custom serialization management
– Technical documentation writing
– Black Scholes diffusion computation optimization with Graphic Cards (Nvidia CUDA 8.0, Tesla and GTX 680)

Solution commissioning
– Data and result validation
– Performance tuning and monitoring

Others
– TFS source control tools introduction
– Continuous delivery introduction with related job setup (Gated checkins, builds, testing and delivery)

PinkFlower.fr

Pinkflower.fr is a website of a massage parlour which aims to get persons rid of stress and improve their well beings. They propose a large range of massage which are all of great quality.

This massage parlour is located in Plessis-Bouchard (Postal code : 95130), France

I helped in this project to :

Design the website
Setup the website
Choose and setup scheduling functionality
Setup the galleries
Setup SEO (Search Engine Optimization) in order to have the website well referenced.

You can visit the website at : https://www.pinkflower.fr/

Energia – Analiza – Urządzenia

I actively collaborated with Tomasz SZYMANSKI in order to help him to set up his website.

This website give you advise, definitions and propose you devices in order to measure and benefit from different kind of energy advantages.

Website url : https://energia-orgonu.com/

Screen shot of the Energia – Analyza – Urządzenia website.

2012 -> 2013 – CNC -Intranet platform development

CNC – From August 2012 until September 2013

CNC (Centre National de la cinématographie) is a French organisation which deals with French cinema administration

This works consisted in designing, programming and installing an intranet website for the CNC

The intranet technical architecture was composed with three part :

SQL Server database
Web Service Layer
Internet server client which query the web service and provide internet HTML (internet) content for light client

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.

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.

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;
        }
    }
}