update(post): singleton pattern

TODO: add different color for code markdown
      add differnet color for footnotes
      add different color for dark and white theme for github comments

Author: Andebugulin

_posts/2018-12-22-distill.md

@@ -1,11 +1,12 @@
 ---
 layout: distill
-title: studying tymplate
+title: studying template
 description: an example of a distill-styled main elements
 tags: distill formatting
 giscus_comments: true
-date: 2024-04-09
+date: 2024-09-04
 featured: false 
+slug: studying-template
 
 authors:
   - name: Andrei Gulin 
@@ -79,9 +80,6 @@ Additional details, where math $$ 2x - 1 $$ and `code` is rendered correctly.
 
 ---
 
-## Layouts
-
-The main text column is referred to as the body.
 It is the assumed layout of any direct descendants of the `d-article` element.
 
 <div class="fake-img l-body">
@@ -94,9 +92,6 @@ For images you want to display a little larger, try `.l-page`:
   <p>.l-page</p>
 </div>
 
-All of these have an outset variant if you want to poke out from the body text a little bit.
-For instance:
-
 <div class="fake-img l-body-outset">
   <p>.l-body-outset</p>
 </div>

_posts/2024-09-05-distill.md

@@ -0,0 +1,149 @@
+---
+layout: distill
+title: singleton pattern
+description: singleton pattern (C#)
+tags: code c#
+giscus_comments: true
+date: 2024-09-05
+featured: false 
+slug: singleton-pattern
+
+authors:
+  - name: Andrei Gulin 
+
+# Optionally, you can add a table of contents to your post.
+# NOTES:
+#   - make sure that TOC names match the actual section names
+#     for hyperlinks within the post to work correctly.
+#   - we may want to automate TOC generation in the future using
+#     jekyll-toc plugin (https://github.com/toshimaru/jekyll-toc).
+toc:
+  - name: Introduction 
+  - name: Code Blocks
+  - name: Thoughts 
+  - name: Learnt material 
+
+# Below is an example of injecting additional post-specific styles.
+# If you use this post as a template, delete this _styles block.
+# _styles: >
+#   .fake-img {
+#     background: #bbb;
+#     border: 1px solid rgba(0, 0, 0, 0.1);
+#     box-shadow: 0 0px 4px rgba(0, 0, 0, 0.1);
+#     margin-bottom: 12px;
+#   }
+#   .fake-img p {
+#     font-family: monospace;
+#     color: white;
+#     text-align: left;
+#     margin: 12px 0;
+#     text-align: center;
+#     font-size: 16px;
+#   }
+---
+
+## Introduction
+
+In this report, I will try to delve into the singleton pattern. How to implement it and when and where it is useful to apply.
+
+---
+
+## References
+
+[Singleton pattern](https://refactoring.guru/design-patterns/singleton)
+
+---
+
+## What does it do?
+
+1. The singleton pattern controls how many instances of a class can be created<d-footnote>To control access to shared resources, such as a database connection or a file.</d-footnote>
+
+2. Provide a global access point to that instance<d-footnote>With simple global variable that store important content, this content may be overwritten almost by everything, however singleton allows the access, but it as well protects from overwriting it</d-footnote>
+
+  * Imagine that you created an object, but after a while decided to create a new one. Instead of receiving a fresh object, you’ll get the one you already created
+
+  {% details note %}
+  this behavior is impossible to implement with a regular constructor since a constructor call must always return a new object by design
+  {% enddetails %} 
+
+
+---
+
+## Implementation
+
+1. Make the default constructor private, to prevent other objects from using the `new` operator with the Singleton class.
+
+2. Create a static creation method that acts as a constructor. Under the hood, this method calls the private constructor to create an object and saves it in a static field. All following calls to this method return the cached object.
+
+
+ *  If your code has access to the Singleton class, then it’s able to call the Singleton’s static method. So whenever that method is called, the same object is always returned.
+
+---
+
+## Code example
+
+```c#
+// The Database class defines the `getInstance` method that lets
+// clients access the same instance of a database connection
+// throughout the program.
+class Database is
+    // The field for storing the singleton instance should be
+    // declared static.
+    private static field instance: Database
+
+    // The singleton's constructor should always be private to
+    // prevent direct construction calls with the `new`
+    // operator.
+    private constructor Database() is
+        // Some initialization code, such as the actual
+        // connection to a database server.
+        // ...
+
+    // The static method that controls access to the singleton
+    // instance.
+    public static method getInstance() is
+        if (Database.instance == null) then
+            acquireThreadLock() and then
+                // Ensure that the instance hasn't yet been
+                // initialized by another thread while this one
+                // has been waiting for the lock's release.
+                if (Database.instance == null) then
+                    Database.instance = new Database()
+        return Database.instance
+
+    // Finally, any singleton should define some business logic
+    // which can be executed on its instance.
+    public method query(sql) is
+        // For instance, all database queries of an app go
+        // through this method. Therefore, you can place
+        // throttling or caching logic here.
+        // ...
+
+class Application is
+    method main() is
+        Database foo = Database.getInstance()
+        foo.query("SELECT ...")
+        // ...
+        Database bar = Database.getInstance()
+        bar.query("SELECT ...")
+        // The variable `bar` will contain the same object as
+        // the variable `foo`.
+```
+
+---
+
+## Pros and Cons of the Singleton Pattern
+
+### **Pros**
+
+- **Single Instance**: Ensures that a class has only one instance.
+- **Global Access**: Provides a global access point to that instance.
+- **Lazy Initialization**: The singleton object is only initialized when it's requested for the first time, saving resources.
+
+### **Cons**
+
+- **Violates Single Responsibility Principle**: The pattern solves two problems at once—controlling instance creation and providing global access.
+- **Masks Bad Design**: Can hide design issues, as components may become overly dependent on each other.
+- **Multithreading Issues**: In a multithreaded environment, special handling is required to avoid creating multiple singleton instances.
+- **Difficult to Test**: Unit testing can be challenging because many frameworks rely on inheritance for mocking. The private constructor of a singleton makes mocking difficult, and static methods can’t be easily overridden in most languages.
+