A brief look at UML

 Hello! For my first real blog, I like to talk about an entirely different blog I read written by Fredrik Klingenberg, titled "UML Sequence Diagrams". For one of my classes where we talk about software design processes, UML diagrams were something that was taught to us very early on, and I got the impression that they would be something I would see a lot of for the rest of my career. As such, I wanted to find a blog that could give me an idea of how they would be realistically applied, and after some digging I found this. 

In the blog, he talks about not only what the diagrams are and how to construct them, but more importantly how to actually use them in a day-to-day basis. Firstly, if you are unfamiliar, a UML Diagram is a graphical tool used to visualize the structure and behavior of a software system. Think of it sort of as the visual equivalent of pseudocode, if you shifted the focus to more of an overview of the entire project. Visualizing the codebase in this manner isn't an exact science, for instance you decide how much detail you want to include; something that changes depending on your reason for making one. As such, you may end up having to put more effort into making one than you originally wanted to which could offset the benefits you get from doing so. Fredrik provides insight for how he balances things out by explaining how these diagrams should be developed in tandem with the code, and how this can be done more easily.

To do this, he talks about using a tool called Mermaid, which is effectively a way to create a diagram from pseudocode. It's very similar to a tool we were taught to use in class, called PlantUML, the key difference is that Mermaid is simpler, but faster. These "diagram as code" tools can also be version controlled which helps with keeping them updated as the code changes. 

I chose this blog specifically because it shows an anecdotal perspective of how UML is used in the real world; my main takeaways are that completeness isn't necessarily the main priority of them, rather they need to be able to communicate (effectively but also quickly) the code, how it works, and it's reason for existing. Shifting your priorities like this allows you to make them more quickly, which in my opinion makes them more realistic to not only create, but actively update as the project develops. Moving forward I definitely think that adopting this approach is a good idea, and probably something I will start doing.