After working for the last three years with TFS’s classic source control TFVC, I recently moved to a new company and with that, to Git.
Before working with Git, I loved working with TFVC. I thought it was great and pretty much the most I can expect from a source control.
Git however changed the way I work with source control and even the way I think about source control.
This post is a small taste of what Git does and how my workflow changed accordingly. It is not a Git tutorial, but rather my impressions from it. I do link at the end to some additional resources.
After a relatively short time looking for a job, I joined my a new company: CodeValue.
Specifically, I’m working on the OzCode project (which is awesome).
But a bit later on that… First let me tell you a bit about my job hunt experience.
After three years and three months in Cellebrite, I decided to leave the company and pursue other challenges.
Cellebrite was a great place to work at with great people and I enjoyed my time there.
This post is a recap of my time in Cellebrite and why I eventually decided to leave.
I started a software developer in a team of 6, working on a large WPF application. After working in a startup company, I was impressed on how professional and orderly everything was. We had TFS work items, we had a build machine, we had an installer to create our Setup files, we had update distribute system. I was truly impressed.
In-office Nerf wars
When starting with WPF, I had a hard time realizing when to use converters and just how powerful they can be. I would often create styles with complicated Data Triggers, or abuse my ViewModel instead of doing some simple converter magic.
I’ll share with you some converter tips and tricks that make my development easier every day.
Before reading this, check out my last post. I talked about navigation techniques in MVVM and how I didn’t like them too much. I also talked about learning Asp.NET Core is and how good the navigation / routing system is in there.
So, following the pain, I decided to create a lightweight navigation WPF framework similar to the one in Asp.NET Core. We’re still using MVVM, but adding controllers which makes it MVVMC, Model-View-ViewModel-Controller (This is how the library is called as well).
Everything is available on GitHub.
Now let’s see how to use MVVMC with a WPF application:
Have you ever encountered an over designer? An over designer is a software developer that had some life changing event and became obsessed about architecture. The result being, obsessive decoupling, endless coding of Factories, creating deep (also needless) inheritence hierarchies and various use of design patterns for no good reason.
I believe the over deisgner is a mutation in the natural evolution of a software developer.
Software Developer’s Evolution
Not every software developer reaches to Senior level. Few reach to Jedi Master and some rare geniuses evolve to Jon Skeet’s level.
I believe somewhere during the transition from Code Monkey to Senior a mutation occurs: The Over Designer.
Have you ever considered how WPF does navigation between pages with MVVM?
You’ve got your View and ViewModel, which present a single page, or some area in your page. But what’s the guideline to actually change the content of the page to a new View and ViewModel?
I think MVVM doesn’t really explain that. Which is strange because in almost any application you’d have multiple pages and some sort of flow.
And what about wizard-type applications? What is supposed to happen when I click that “Next” button?
Recently I worked on an ASP.NET Core project and I discovered Microsoft did a very good job implementing navigation with MVC. It’s extremely intuitive and easy to understand.
So after mulling over this for a while, I did the only reasonable thing anyone in my situation would do. I went ahead and built a framework in WPF to implement navigation like in ASP.Net Core.
Recently I was dealing with a couple of bugs in C# regarding timeout behavior. The solutions were pretty interesting so I decided to share them.
In WPF you can do everything in many different ways. It’s not always clear what is better. For example, we got many different ways to reuse a UI component. We can use Templates, User controls, Custom controls, ViewModels with data templates and so on. So which is better? The answer is obvious. Always use user controls!
Just kidding 🙂 The answer is always different, depending on your specific scenario. And a lot of times, it’s far from obvious what’s better. Just for the fun of it, let’s explore one of those scenarios where it’s not so clear which is better.
A long time ago, on my first programming job I had a design problem that I couldn’t solve.
This problem haunted me. The reason was that it seemed so simple, and yet I couldn’t find a good solution for it.
Eventually I did a huge refactor, but instead of solving it correctly I simply changed one problem to another.
Recently, years later, in a different company, I came up with that great solution I was after.
So besides telling you I’m thinking about code from years ago way too much, I want to share with you my exciting great solution. Continue reading