Résumé

C#, VB.NET, LINQ

WinForms, WPF, ASP.NET Web Forms, ASP.NET MVC, ASP.NET Web API, Entity Framework, Moq, etc.

HTML, Bootstrap, JavaScript

KnockoutJS, jQuery

Java, RxJava

SQL

ORM: Entity Framework in .NET, Sugar ORM in Android

xUnit, Moq, JUnit, Mockito

Git, SVN

Learned CS through free materials of Stanford's CS106B last 2012, through "Nand to Tetris (Part 1)" course last 2015, and through MIT OpenCourseWare 6.0001 this 2017

... also through "Computer Science Distilled" of Wladston Filho

The SOLID principles

Clean Architecture model of Uncle Bob Martin

Also have knowledge on some design patterns such as Decorator, Strategy, Factory, Command

Also, a little knowledge on some DDD concepts

Believes in Agile Software Development practices such as collective ownership of the code base, code review (even pair programming or mob programming), discarding practices that does not work in a particular team and retaining those that work, and others you might want me to believe in that works in software development

Believes that TDD can greatly help us make software that is maintainable. (Of course that does not mean that I'm going to force it on others. )

Googling Stackoverflow

I know a little bit of Python.

I also like solving algorithmic problems, but am able to solve only the simple ones, at least for now...
You can view my solutions to some simple problems here.

An avid fan of Uncle Bob Martin (I visit his blog often).

I read.

(Please click here if you want a peek into how I currently think)

I had read "How to Win Friends and Influence People" in the past (year 2007 or 2008, I think), and I am rereading it sometimes to review the things I learned from it..

(I included this here because this might give me plus points... because I saw a job posting in the past where reading this book is one of the requirements if one is hired. )

github.com/hantrungkien

github.com/jboyflaga2
github.com/jboyflaga

hantrungkien.github.io

jeremiahflaga.blogspot.com
jboyflaga2.blogspot.com

Software Developer for web using .NET (and Sitecore) at Jairosolutions

I experienced being in a team creating web pages using the Sitecore CMS and ASP.NET.

The team members only worked at home as outsource developers for GetModal, building contest pages for www.verizoninsider.com.

Contributions:

Nothing extraordinary. Just finished the tasks assigned to me.

Lesson(s) Learned:

This is where I was first exposed to DDD. Our employer made us study DDD because we will be using it in an in-house project. But I was not lucky to be involved in the in-house project because the employement of three junior developers, which inlcuded me, stopped after six months due to a problem unbeknownst to me.

I just saw the initial structure of the project. I saw that there was a Core module, which I now understand to be the module which holds the business rules. There was also an Infrastructure module(s), which holds the data layer and some other parts of the system. There was no presentation layer yet during the time that I saw the project.

Software Developer for web using .NET at Mynd Consulting

I was part of a team that works for a client named Common Census. We were developing and maintaining a web application that is used in enrollment for insurance.

We were using ASP.NET WebForms and the MVP design pattern to build the software. We used MS Test and Moq in writing Unit Tests. There was also a legacy desktop version of the enroller that we were maintaining.

There were also a few parts of the web app that were being converted to ASP.NET MVC. So I also had a little experience using ASP.NET MVC at work.

Contributions:

Nothing extraordinary. Just did the tasks assigned to me.

Lesson(s) Learned:

1. I started to understand what Object-Oriented programming is.
   
   (When I applied for this job, I claimed to know OOP. But I later realized that I really did not know OOP. I only knew about what a class is, what an interface is, what an abstract class is, what polymorphism is, but I did not not yet have a full understanding about their uses.)
   
   This is where I started to understand the Dependency Inversion Principle (specifically, the Constructor Injection thing), the use of the Factory design pattern, and other things.


2. I learned that programmers at this level of their carreer needs lots of guidance/mentoring from their seniors (most especially when the project is in a complex state already, and if the seniors don't want the juniors to mess with the code ).
   
   (When I become a senior developer someday, I intend to guide/mentor my teammates who are in the beginning years of their carreer... provided of course that they also share some of their knowledge with me. )


3. This is the time where I, and my teammates, plunged into the Clean Code book because one of our team leads made us read one chapter of the book each week, and spend about an hour each week discussing that chapter.
   
   Unfortunately, for some reasons unknown to me, our discussions stopped after a few meetings. We did not finish the book. We only discussed up to chapter five, I think. And I read up to chapter 8 of the book only.


4. This is where I experienced writing unit tests after-the-fact, that is, after the production code is already written. — It was hard.
   
   But despite that experience, I'm not against writing tests. I am even a TDD advocate today through the influence of Uncle Bob Martin. But writing tests after the production code is already written requires a somewhat different skillset than doing TDD. I was, and is still, not skillfull on writing tests after-the-fact. But I'm trying to be good at it also.