https://www.patterns.dev/posts/singleton-pattern

Singleton Pattern

Singletons are classes which can be instantiated once, and can be accessed globally. This single instance can be shared throughout our application, which makes Singletons great for managing global state in an application.

Tradeoffs

Restricting the instantiation to just one instance could potentially save a lot of memory space.

Singletons are actually considered an anti-pattern, and can (or.. should) be avoided in JavaScript.

In many programming languages, such as Java or C++, it's not possible to directly create objects the way we can in JavaScript. In those object-oriented programming languages, we need to create a class, which creates an object.

However, the class implementation shown in the examples above is actually overkill. Since we can directly create objects in JavaScript, we can simply use a regular object to achieve the exact same result.

Global behavior

A Singleton instance should be able to get referenced throughout the entire app. Global variables essentially show the same behavior: since global variables are available on the global scope, we can access those variables throughout the application.

Having global variables is generally considered as a bad design decision. Global scope pollution can end up in accidentally overwriting the value of a global variable, which can lead to a lot of unexpected behavior.

In ES2015, creating global variables is fairly uncommon. The new let and const keyword prevent developers from accidentally polluting the global scope, by keeping variables declared with these two keywords block-scoped. The new module system in JavaScript makes creating globally accessible values easier without polluting the global scope, by being able to export values from a module, and import those values in other files.

However, the common usecase for a Singleton is to have some sort of global state throughout your application. Having multiple parts of your codebase rely on the same mutable object can lead to unexpected behavior.

State management in React

In React, we often rely on a global state through state management tools such as Redux or React Context instead of using Singletons. Although their global state behavior might seem similar to that of a Singleton, these tools provide a read-only state rather than the mutable state of the Singleton.

https://roadmap.sh/backend

What is an operating system?

Source: https://edu.gcfglobal.org/en/computerbasics/understanding-operating-systems/1/

Computer Basics: Understanding Operating Systems

• It manages the computer's memory and processes, as well as all of its software and hardware.
• It also allows you to communicate with the computer without knowing how to speak the computer's language.
• Most of the time, there are several different computer programs running at the same time, and they all need to access your computer's central processing unit (CPU), memory, and storage. The operating system coordinates all of this to make sure each program gets what it needs.
• Most servers run Linux because it's relatively easy to customize.
• Operating systems for mobile devices generally aren't as fully featured as those made for desktop and laptop computers, and they aren't able to run all of the same software.

Operating System Summary

Source: https://www.guru99.com/os-tutorial.html

Operating System Interview Questions

https://career.guru99.com/top-50-operating-system-interview-questions/

What is the Operating System?

• An operating system is a software which acts as an interface between the end user and computer hardware.
• The OS works as an intermediary between the user and computer. It helps the user to communicate with the computer without knowing how to speak the computer’s language.
• The kernel is the central component of a computer operating system. The only job performed by the kernel is to the manage the communication between the software and the hardware.
• Two most popular kernels are monolithic and microkernels
• The management of processes, devices, files, I/O, storage, and memory are some of the varying functions of an operating system

What is Semaphore?

A semaphore is simply a variable that is non-negative and shared between threads. A semaphore is a signaling mechanism, and a thread that is waiting on a semaphore can be signaled by another thread. It uses two atomic operations, 1) Wait, and 2) Signal for the process synchronization.

A semaphore either allows or disallows access to the resource, which depends on how it is set up.

Components of Operating Systems

An operating system is a large and complex system that can only be created by partitioning into small pieces. These pieces should be a well-defined portion of the system, which carefully defined inputs, outputs, and functions.

Although Mac, Unix, Linux, Windows, and other OS do not have the same structure, most of the operating systems share similar OS system components like File, Process, Memory, I/O device management.

Operating Systems: Crash Course Computer Science

Source: https://www.youtube.com/watch?v=26QPDBe-NB8&ab_channel=CrashCourse

• An operating system is just a computer program, but with special hardware related privileges that enable it to run and manage other programs.
• Serve as intermediaries between software programs and hardware peripherals (software abstraction, api's, device drivers)
• Multitasking - allows many programs to be in progress all at once, sharing the same CPU
• Memory allocation (physical memory -> virtual memory) - 5:00
• Memory protection - Memory access rights. Makes sure a program (process) can only access the memory that has been allocated to it.
• Terminal - Historically, a keyboard and screen that connect to a computer but don't possess any processing power themselves. Allows for a multiple concurrent sessions, with each session (user) being allocated a small portion of the computers resources.
• Core OS functionality (memory management, multitasking, i/o interfacing) is handled by the kernel (the program at the core of an operating system).

Introduction to Operating System

Source: https://www.youtube.com/watch?v=vBURTt97EkA&list=PL9hkZBQk8d1zEGbY7ShWCZ2n1gtxqkRrS&index=1

• An operating system is a program that manages the computer hardware.
• It also provides a basis for application programs and acts as an intermediary between the user and hardware.
• It handles the allocation of resources & the management of memory and makes sure these things are done in a secure manner.
• Hardware consists of resources such as the CPU and memory, as well as I/O devices like the mouse and keyboard
• System programs - programs that exist to interact with & control hardware
• Application programs - programs that exist to allow the user to perform a specific task or function

https://www.patterns.dev/posts/proxy-pattern

Proxy Pattern

With a Proxy object, we get more control over the interactions with certain objects. A proxy object can determine the behavior whenever we're interacting with the object, for example when we're getting a value, or setting a value.

Generally speaking, a proxy means a stand-in for someone else. Instead of speaking to that person directly, you'll speak to the proxy person who will represent the person you were trying to reach. The same happens in JavaScript: instead of interacting with the target object directly, we'll interact with the Proxy object.

Mechanics

Instead of interacting with an object directly, we want to interact with a proxy object. In JavaScript, we can easily create a new proxy by creating a new instance of Proxy.

The second argument of Proxy is an object that represents the handler. In the handler object, we can define specific behavior based on the type of interaction. Although there are many methods that you can add to the Proxy handler, the two most common ones are get and set.

A proxy can be useful to add validation. A user shouldn't be able to change person's age to a string value, or give them an empty name. Or if the user is trying to access a property on the object that doesn't exist, we should let the user know.

Reflect

JavaScript provides a built-in object called Reflect, which makes it easier for us to manipulate the target object when working with proxies.

Previously, we tried to modify and access properties on the target object within the proxy through directly getting or setting the values with bracket notation. Instead, we can use the Reflect object. The methods on the Reflect object have the same name as the methods on the handler object.

Tradeoffs

Proxies are a powerful way to add control over the behavior of an object. A proxy can have various use-cases: it can help with validation, formatting, notifications, or debugging.

Overusing the Proxy object or performing heavy operations on each handler method invocation can easily affect the performance of your application negatively. It's best to not use proxies for performance-critical code.

https://www.patterns.dev/posts/provider-pattern

Provider Pattern

In some cases, we want to make available data to many (if not all) components in an application. Although we can pass data to components using props, this can be difficult to do if almost all components in your application need access to the value of the props.

We often end up with something called prop drilling, which is the case when we pass props far down the component tree. Refactoring the code that relies on the props becomes almost impossible, and knowing where certain data comes from is difficult.

Mechanics

Let's say that we have one App component that contains certain data. Far down the component tree, we have a ListItem, Header and Text component that all need this data. In order to get this data to these components, we'd have to pass it through multiple layers of components.

Passing props down this way can get quite messy. If we want to rename the data prop in the future, we'd have to rename it in all components. The bigger your application gets, the trickier prop drilling can be.

This is where the Provider Pattern can help us out! With the Provider Pattern, we can make data available to multiple components. Rather than passing that data down each layer through props, we can wrap all components in a Provider. A Provider is a higher order component provided to us by the Context object. We can create a Context object, using the createContext method that React provides for us.

Each component can get access to the data, by using the useContext hook. The useContext hook lets us read and write data to the context object.

The Provider pattern is very useful for sharing global data. A common usecase for the provider pattern is sharing a theme UI state with many components.

Hooks

We can create a hook to provide context to components. Instead of having to import useContext and the Context in each component, we can use a hook that returns the context we need.

Instead of wrapping the components directly with the Provider component, we can create a HOC that wraps the component to provide its values. This way, we can separate the context logic from the rendering components, which improves the reusability of the provider.

Each component that needs to have access to the ThemeContext, can now simply use the useThemeContext hook.

Tradeoffs

Pros

The Provider pattern/Context API makes it possible to pass data to many components, without having to manually pass it through each component layer.

It reduces the risk of accidentally introducing bugs when refactoring code. Previously, if we later on wanted to rename a prop, we had to rename this prop throughout the entire application where this value was used.

We no longer have to deal with prop-drilling, which could be seen as an anti-pattern. Previously, it could be difficult to understand the dataflow of the application, as it wasn't always clear where certain prop values originated.

Cons

In some cases, overusing the Provider pattern can result in performance issues. All components that consume the context re-render on each state change.

In smaller applications, this won't matter too much. In larger applications, passing a frequently updated value to many components can affect the performance negatively.

To make sure that components aren't consuming providers that contain unnecessary values which may update, you can create several providers for each separate usecase.

Like most young adults, I had no idea what I wanted from life, or what I wanted to do for employment, when I graduated high school. I went to university under the impression that it would help me answer at least one of those questions. When the time came to select a field of study, I chose "business administration" because it seemed delightfully generic with a wide spread of subject matter that I could leverage into a different path when I made up my mind.

I never made up my mind. I graduated with a major in business and a minor in accounting, which I had somehow picked up along the way.

I would spend the next 8 years working bookkeeping and financial analyst roles for companies in a variety of industries, which helped to keep things fresh and exciting to an extent. I then decided to double down on accounting and pursue my CPA in order to elevate my career to the next level. It was during this grueling endeavour, this deep dive into the world of accounting, that I finally came to a realization - I did not enjoy what I was doing, at all. The idea of spending years getting my designation, only to then then spending the rest of my life performing audits or reconciliations filled me with an absolute sense of dread. I realized it wasn't the work itself that had kept me going the last 8 years; the constant changing of environments, the fact that I always doing something new, had simply masked the fact that I didn't feel any sense of fulfillment or satisfaction.

It was time for a change...

https://roadmap.sh/backend

Operating System Summary - Advanced Topics

Source: https://www.guru99.com/os-tutorial.html - Advanced stuff

The microkernel

• A kernel is an important part of an OS that manages system resources.
• A microkernel is a software or code which contains the required minimum amount of functions, data, and features to implement an operating system.
• In Monolithic Kernel approach, the entire operating system runs as a single program in kernel mode
• A Microkernel is the most important part for correct implementation of an operating system.
• A microkernel comprises only the core functionalities of the system.
• A monolithic kernel is a large process running in a single address space, whereas Microkernel can be broken down into separate processes called servers.
• Microkernel architecture is small and isolated therefore it can function better
• Providing services in a microkernel system are expensive compared to the normal monolithic system

System calls

Summary:

Categories	Windows	Unix
Process control	CreateProcess()ExitProcess()WaitForSingleObject()	fork()exit()wait()
Device manipulation	SetConsoleMode()ReadConsole()WriteConsole()	loctl()read()write()
File manipulation	CreateFile()ReadFile()WriteFile()CloseHandle()	Open()Read()write()close!)
Information maintanence	GetCurrentProcessID()SetTimer()Sleep()	getpid()alarm()sleep()
Communication	CreatePipe()CreateFileMapping()MapViewOfFile()	Pipe()shm_open()mmap()
Protection	SetFileSecurity()InitlializeSecurityDescriptor()SetSecurityDescriptorGroup ()	Chmod()Umask()Chown()

File systems

• A file is a collection of correlated information which is recorded on secondary or non-volatile storage like magnetic disks, optical disks, and tapes.
• It provides I/O support for a variety of storage device types.
• Files are stored on disk or other storage and do not disappear when a user logs off.
• A File Structure needs to be predefined format in such a way that an operating system understands it.
• File type refers to the ability of the operating system to differentiate different types of files like text files, binary, and source files.
• Create find space on disk and make an entry in the directory.
• Indexed Sequential Access method is based on simple sequential access
• In Sequential Access method records are accessed in a certain pre-defined sequence
• The random access method is also called direct random access
• Three types of space allocation methods are:
• Linked Allocation
• Indexed Allocation
• Contiguous Allocation
• Information about files is maintained by Directories

Real-time operating systems

• RTOS is an operating system intended to serve real time application that process data as it comes in, mostly without buffer delay.
• It offers priority-based scheduling, which allows you to separate analytical processing from non-critical processing.
• Important components of RTOS system are: 1)The Scheduler, 2) Symmetric Multiprocessing, 3) Function Library, 4) Memory Management, 5) Fast dispatch latency, and 6) User-defined data objects and classes
• Three types of RTOS are 1) Hard time 2) Soft time ,and 3) Firm time
• RTOS system occupy very less memory and consume fewer resources
• Performance is the most important factor required to be considered while selecting for a RTOS.
• General-Purpose Operating System (GPOS) is used for desktop PC and laptop while Real-Time Operating System (RTOS) only applied to the embedded application.
• Real-time systems are used in Airlines reservation system, Air traffic control system,etc.
• The biggest drawback of RTOS is that the system only concentrates on a few tasks.

Remote procedure calls

A remote procedure call is an interprocess communication technique.

• Three types of RPC are 1) Callback RPC 2)Broadcast RPC, and 3) Batch-mode RPC
• RPC architecture has mainly five components of the program: 1) Client 2) Client Stub 3)RPC Runtime 4) Server Stub, and 5) Server
• In RPC method the processes do not share address space
• RPC offers simple call syntax and known semantics
• RPC method helps clients to communicate with servers by the conventional use of procedure calls in high-level languages.
• The biggest drawback of RPC method is that it is highly vulnerable to failure as it involves a communication system, another machine, and another process.

CPU scheduling

Process management

Deadlock

FCFS scheduling algorithm

Paging

Livelock

IPC

Round robin scheduling

Process synchronization

Priority scheduling algorithm

Memory management

Shortest job first

Virtual memory

Bankers algorithm

Welcome to my site! If you found this, color me impressed.

There's not much going on right now, and it's still very much a work in progress, so feel free to subscribe to my newsletter and I'll let you know when things are up and running.

Thanks for stopping by!