Useful Software Engineering Resources

About

It’s hard to remember everything you learn over the years especially if you don’t use it very often. That’s why I think it’s good to have a compilation of cheatsheets, reference books or other types of resources like blog posts/videos/PDFs.

So in this post, I will “bookmark” some useful software engineering resources and cheatsheets for myself(or anyone else who stumbles upon this post).

PDFs on Almost Anything Software Related

This site has an absolutely amazing collection of very detailed PDFs with lots of information compiled from different online sources.

You will find pdfs on lots of computer-related stuff. For example, programming languages: Javascript, PHP, Java, C, C++, C#, … frameworks: .NET, Angular, React, … plus other various tools and algorithms.

And best of all it’s all completely free! Check it out here.

Software Design Patterns

This is a cheat sheet of software design patterns. When you are designing software it’s useful to check/keep in mind some of these patterns as they might “nicely” and effectively solve your problem.

I originally found this design pattern cheat sheet here.

I also found a nice pdf online that explains these design patterns in a little bit more detail. Or if you prefer videos, here is a great playlist going over each design pattern with an actual implementation in code.

System Architecture Design Patterns

Similar to software design patterns there are also common design patterns for the whole system/software architecture. This blog post here summarizes 10 of the most common ones.

I mainly work with Azure cloud and microservices/distributed services. I’ve found the following learning resources provided by Microsoft to be quite useful:

Big O Notation and Computational Complexity

Here you can find a Big O notation(both space/time complexity) cheat sheet for common algorithms and data structures.

Neural Networks

This is a collection of different neural networks. The original image and explanations for each neural network can be found here.

Git and Gitflows

Most of the time I prefer using UI-based git tools that are part of the IDEs I use(Visual Studio, VS Code) or a separate app like the Github Desktop. However time to time you might need the git CLI commands.

In such cases, a git cheat sheet comes very handy: git cheat sheet pdf from Github or git cheat sheet pdf from Gitlab

Git workflows are different ways of organizing or structuring your git repository branches and commits/merges. There are a few common workflows in the sketch below:

Here is a great explanation of different git workflows made by Atlassian.

Brush Up Your Math Skills

Brush up your math skills with betterexplained.com or with 3Blue1Browns videos.

Writing Documentation

A lot of times I simply use something like Word or OneNote to write brief technical documentation. And I use diagrams.net to make all sorts of diagrams for my documentation.

Another tool I also like to use is BookStack. It has more advanced and better-integrated features. But the best of all is that it’s free and can be self-hosted.

The most obvious type of code documentation are inline comments within your source code.

I mostly work with .NET and Visual Studio where XML comments are supported by the IDE. These can either be used by IntelliSense to provide you with information when coding or by tools like DocFX that automatically generate documentation for your code from the XML. Meanwhile, if you are working with PHP check out phpDocumentor.

Visual Studio also has features such as class diagrams to view your classes and code maps that will visualize the code flow/dependencies for you automatically.

Desgin Principles

I think that it’s good to have an understanding of the general ideas behind these design principles however take everything with a grain of salt. Don’t blindly stick to these. Instead, try to understand them and see in which cases they would benefit you the most. Here I will list a few of the more common ones. There are many more like decoupling, abstracting and reusing your code, failing gracefully, etc… but as I wrote before don’t get too fixated with always following all of these down to a T.

CAP Theorem (Consistency, Availability, Partition Tolerance)

Applies to distributed systems and states that you can only have two of the aforementioned characteristics. This comes into play a lot with cloud based systems and horizontal scaling. Here is a good explanation of the CAP Theorem by IBM and here is a very neat visualization of the CAP Theorem.

ACID Principles (Atomicity, Consistency, Isolation, Durability)

Applies to databases or data operations.

Atomicity All changes to data are performed as if they are a single operation. That is, all the changes are performed, or none of them are. For example, in an application that transfers funds from one account to another, the atomicity property ensures that, if a debit is made successfully from one account, the corresponding credit is made to the other account.

Consistency Data is in a consistent state when a transaction starts and when it ends. For example, in an application that transfers funds from one account to another, the consistency property ensures that the total value of funds in both the accounts is the same at the start and end of each transaction.

Isolation The intermediate state of a transaction is invisible to other transactions. As a result, transactions that run concurrently appear to be serialized. For example, in an application that transfers funds from one account to another, the isolation property ensures that another transaction sees the transferred funds in one account or the other, but not in both, nor in neither.
Durability After a transaction successfully completes, changes to data persist and are not undone, even in the event of a system failure. For example, in an application that transfers funds from one account to another, the durability property ensures that the changes made to each account will not be reversed.

Source: https://www.ibm.com/docs/en/cics-ts/5.4?topic=processing-acid-properties-transactions

SOLID Principles (Single Responsibility, Open Closed, Liskov substitution, Interface Segregation, Dependency Inversion)

Applies to object oriented programming and it outlines some ideas to help develop better software with OOP. Here is a great post about SOLID Principles with actual code examples of the implementations.

OLAP vs OLTP

OLTP(online transactional processing) are your typical databases that are optimized for CRUD operations and are used for the operational aspect of your applications. OLAP(online analytical processing) databases on the other hand use different data structures optimized for analytics. For example, a cube structure is like a table(rows and columns) with a third dimension(another layer or multiple layers of rows and columns).

Here is a great post about OLAP vs OLTP by IBM.

(update)AI Tools

It’s about time I updated this post and added AI tools like chat GPT and GitHub Copilot to this list. You probably already heard of these as everyone’s been talking about them for the past year or so.

I have also been using Chat GPT and Github copilot for about a year now. I find them to be useful tools that at least somewhat boost my productivity. I don’t think they can replace programmers any time soon(unless we get AGI) but I do see these types of AI tools becoming more important and a regular part of a developer’s workflow just like IDEs, debuggers, compilers and libraries did through the past decades.

What I like about these chat bot like LLMs is the ability to refine your initial prompt/query unlike with a regular search engine. A lot of times this makes getting to the desired information much quicker

Last But Not Least This Very Blog

Last but not least feel free to check out some of the posts on this very blog.

GPU Acceleration For Your C# App With ILGPU