Untitled Coding Blog

This post has actually been "baking" in the back of my mind for quite some time now. Initially I actually wanted to do a presentation with most of the content of this post based on some important open source project but I could not find the motivation to actually finish the presentation because it ended up being a bit complicated. Also, this post is actually the result of me interacting with a few developers at the very beginning of their careers and also seeing the behavior of various students at university. So this post will be mostly about some of the obstacles that most people face in the beginning of their careers but not only this. The first thing that comes in my mind is that people panic too fast when trying to learn something and actually stop trying, thinking and focusing on learning. I looked into this and I noticed several things. One of the most obvious thing is that people are scared of abbreviations or pompous words. And in this field you will notice them a

This post has be "baking" in the back of my mind for quite a while now and I think it's almost done baking. I got the idea to write this post while I was working at my previous employer. There I would develop some pretty complicated functionalities that took a long time to develop with quite some effort. And after that I was frustrated because those functionalities were hardly used anywhere. So my question after that was why did we develop them anyway? After those incidents I happen to read about the release of some new mobile phone. I think it was the release of Samsung Galaxy S9. It had around 98% of the same features as the previous model, the S8, including the main functionalities used by everyone. The new functionalities were hardly used by anyone. But on the other hand it gave the consumers a reason to upgrade their phone. And it gave other consumers that were looking into buying a new phone a reason to buy a Galaxy S9 over another phone from another brand. As

Lately I participated in a couple of interviews. During those interviews, the interviewers tried to classify me as either a medium level developer or a senior developer. That's when it occurred to me to think about the progress that I made in the past 6 years or so since I have been professionally developing commercial software. Honestly, over the course of these years I have learned to look from the perspective of other developers when writing code. Equally as important, I learned that when I have a complex problem to solve, my job isn't actually to solve that problem directly. But rather my job is to find out ways to make that complex problem more simple and then to come up with a series of simple functionalities which add up to a simple solution. This has a lot of consequence on the way I develop software. For example, if you need to develop a big application, you can think of that application as a series of smaller applications that need to collaborate together to do wh

By default ASP .Net MVC allows developers to customize the way the framework handles user membership. Back in the old days when people used ASP .Net Webforms the main way to do this was to implement a custom membership provider. ASP .Net MVC introduced a new way to do this, using a series of interfaces. In the old way of doing things, a developer had to implement a single abstract class called "MembershipProvider". The new approach pretty much split up this big class into multiple simpler interfaces each providing a part of the functionality of the whole membership system. It is called Identity. It also introduced better support for 3rd party authentication using external systems such as Facebook, Twitter and so on. It is actually built over the old membership system and is available in ASP .Net Core too but it might differ in some ways. The most important interfaces are: IQueryableUserStore and IUserStore, which store the users registered on the website, including th

So a couple of years ago while I was in university I was really passionate about 3D graphics and making 3d models for games. But it was not enough to make 3D models, I wanted to get them into games. That's how I got into contact with open source project because the software used to get assets into games was an open source project. And now that I think about it, it was totally worth it. I meet some really amazing people. For example, the project that I took over was developed initially by someone who eventually started working for Apple. I took a look at the code he wrote and figured out I can do the same without too much effort. So I continued his work. Now honestly it wasn't that complicated and I am not boasting here but at the same, it felt like something amazing for me. It was one of his first projects and later he moved on to much more complicated and serious stuff. The link for the project can be found here:  https://github.com/Alecu100/maya_nif_plugin I also got to l

This is the final part of the series about the C# code analyzer and interpreter that I created a while back. The actual execution and interpretation of the C# code are explained in this post. It is the last post in this series. To begin with, in very simple terms each word in the C# code can have an associated action that needs to be executed when the code is read by the analyzer in the proper order. For example, a word in the code might be a variable name. In this case, the reference corresponding to that variable is located and stored in a temporary buffer once the word is read. After that, it can be used from the buffer for another operation like invoking a method on the object/objects that the reference references. In case it has to call a method, it needs to locate the body of the method and jump to the method implementation and start reading it. With constructors, it is pretty much the same thing with the only difference being the fact that it always returns a single object and

Over the past years I had some interesting experiences at work, interesting as in not bad, and I learned some curious facts about working as a team on features from their technical design to coding them. I am not a technical leader and  I didn't implement any of these concepts, I just noticed them. But I still need more experience with these. That's why I am writing about this. I also have to do a presentation about this and this post is a bit of practice for the presentation. There might be other better approaches, but currently this is what seems best to me. So I had to work on the same team with two different approaches: one in which a single person was designed as a technical lead making all the important decisions and the other in which there was no person that made all the technical decisions. In the first approach that person had to come up with the entire technical solution for something and all the other people had to follow and code that design blindly. In techn

A couple of months ago I had the chance to look a bit into the famous CoreCLR source code and actually compile it. It took me a while to understand it and how use it. This is probably some really advanced stuff that most of the time you don't need to know. It is actually composed of 2 main parts. One is the actual virtual machine which takes and runs the intermediate language code. The other part is the actual core .net library called "System.Private.CoreLib.dll" with the base types such as the string type or the numeric types. The second  These 2 parts are strictly related together. They need to have the same version and build type, release or debug. The second part that contains the source code for the core type in .Net is actually a separate assembly written in C#. The unusual thing here is that people expect the types to be in "System.Core.dll" but it's not. That assembly is just a stub for the real assembly containing the actual implementation for the

I initially posted this as a post on facebook but decided to also add it here. Warning, it contains bad language. Still, I won't change it because it suits the context really well. I repeat, it contains bad language. Take it as a bit of a joke with some truth to it. So over the course of the years, I have listened to a lot of actually bad experiences from various developers and reading between the lines I came up with the following conclusions about job descriptions and what they actually mean sometimes. Most of the time the things listed in the descriptions are alright but sometimes there is something really fishy behind the bullet points on a job description. These pretty much point the worst possible meaning behind them in a funny and sarcastic way. "Dynamic" or "agile" environment = we are disorganized as fuck so we expect you to figure out by yourself what to do, how to do it and what's important to do. Also, you have to constantly adapt yo