DEV Community: pwn0x80

Category Theory (Functional Style) part-1

pwn0x80 — Sat, 24 Feb 2024 12:01:11 +0000

Category Theory

Category theory is a way to abstract programming, enabling the creation of complex programs that are readable, extensible, and testable. It provides a mathematical abstraction for code.

category consist of type object and morphs

morphs interpreted as a function or operation that transforms data from one form to another.

object in functional programming might refer to a data structure that bundles together related information.

f:a -> b // f is morphs and a is object

morphs might refer to functions or transformations that take one input and produce a modified output without any internal state or side effects these types are known as pure functions.

What is Pure functions

Pure functions are deterministic, meaning they always produce the same output given the same input, and they don't rely on or modify any external state.

what is Composition

To form Relation between two morphs.

The practice of combining simpler functions to build more complex functions. It involves taking two or more functions and creating a new function by chaining them together, where the output of one function becomes the input of the next function.
for example in js/ts - map,filter,reducer

f:a->f:b->c
composition - g∘f

Functional Style

Rules of Category

1> Composition definition
2> Composition associative
3> Composition Identity

Composition Definition

If you have two functions composed one after another, it implies that there exists a third arrow starting from the first function and ending at the second function.

f:A -> B and g:B -> C then k = g * f,
where k:A -> C

composition k is defined as mapping elements from A to C by first applying function f to map elements from A to B and then applying function g to map the result from B to C.

Composition Associative

The order of the Composing function should not matter. Whether you first compose f and g than h or g and h and then f.

f: A -> B, g:B -> C and h:C -> D then,
(f * g) * h === f * (g * h)

it assures us that no matter which order we apply the compositions than final result will be the same.

Composition Identity

f:A -> A

It is a function that maps every element of a set
A to itself.

Understanding the Difference: Subquery vs. Correlated Query

pwn0x80 — Sat, 24 Feb 2024 08:16:35 +0000

In SQL, the order of execution can vary depending on the type of subquery used and the structure of the SQL statement. Let's break down the order of execution for different scenarios:

Ordinary Subqueries:

In ordinary subqueries, the subquery is executed first, and then the outer query is executed.
This means that the result of the subquery is used as input for the outer query.
The performance impact here is usually dependent on the complexity and size of the subquery, as it needs to be executed for each row processed by the outer query.

Correlated Subqueries:

In correlated subqueries, the outer query is executed first, and then the inner query is executed for each row returned by the outer query.
The inner query can reference columns or values from the outer query, making its execution dependent on the results of the outer query.
Correlated subqueries can have a significant impact on performance, especially if the inner query is complex or if it processes a large number of rows for each iteration of the outer query.
Careful optimization is needed to ensure efficient execution, as correlated subqueries can lead to performance bottlenecks if not used judiciously.

Correlated vs. Uncorrelated Subqueries:

A correlated subquery depends on the results of the outer query, as it references columns or values from the outer query.
An uncorrelated subquery operates independently of the outer query, retrieving data without relying on external references.
Correlated subqueries are often used when the inner query needs to filter its results based on values from the outer query, while uncorrelated subqueries are standalone and do not have such dependencies.

When Correlated Query gets Trigger?

In a correlated subquery, the inner query is triggered for each row processed by the outer query. This correlation occurs when we establish a link between the outer query and the inner query, typically by referencing columns from the outer query within the inner query. Each time the outer query processes a row, the inner query is executed in relation to that specific row's values, hence the term "correlated." This dependency on the outer query's results distinguishes correlated subqueries from uncorrelated ones, which operate independently of their surrounding query context.

When does Subquery get Trigger?

In a non-correlated subquery, also known as an independent subquery, the inner query is executed independently of the outer query. This means that the inner query is processed only once, irrespective of the number of rows processed by the outer query. Unlike correlated subqueries, there is no dependency on the outer query's results. Each time the outer query is executed, the inner subquery retrieves its data without reference to specific values from the outer query's current row. This independence allows the subquery to be evaluated just once, potentially making it more efficient compared to correlated subqueries, especially when dealing with large datasets.

Where Subqery can use?

SQL subqueries can be utilized within various SQL statements including SELECT, INSERT, UPDATE, and DELETE. They can be nested within clauses like SELECT, FROM, WHERE, JOIN, and HAVING. Additionally, SQL queries can be combined with operators such as =, <, >, >=, <=, IN, NOT IN, EXISTS, NOT EXISTS, among others.

Subquery Example Code



SELECT id, name FROM users WHERE LENGTH(name) > 
(
SELECT AVG (LENGTH(name)) FROM users
)

Where correlated can used?

SQL correlated can be utilized within various SQL statements including SELECT, INSERT, UPDATE, and DELETE. They can be nested within clauses like SELECT, FROM, WHERE, JOIN, and HAVING. Additionally, SQL queries can be combined with operators such as =, <, >, >=, <= among others.

Correlated Subquery Example Code



SELECT name FROM employees e1
WHERE  salary >  ( 
SELECT AVG (salary)
FROM  employees e2
WHERE e1.team_id = e2.team_id
);

how to setup an absolute path in a React TypeScript project

pwn0x80 — Thu, 22 Jun 2023 19:55:22 +0000

To set up absolute paths in a React project you can follow these steps:

Install the required dependencies:



npx create-react-app my-app --template typescript
npm i cargo

Configure absolute paths:
make change on tsjsconfig.json and create carco.config.js file in the root directory of your React project with the following content:

tsjsconfig.json
configuring the baseUrl and paths in your tsconfig.json.

The base directory for resolving module paths is the src directory, as the "baseUrl" is set to "src".
Aliases for module paths are specified in the "paths" section. We've defined two aliases here:
"@components/": This alias corresponds to the path./components/. For instance, the resolution of "@components/Button" would be "./components/Button".
The alias "@utils/" corresponds to the./utils/ path.
For instance, the resolution of "@utils/helpers" would be "./utils/helpers".
Make sure to modify the paths and aliases in accordance with the organisation of your project.




{
   "compilerOptions":{
      "baseUrl":"src",
      "paths":{
//add paths line                          
         "@components/*":[
            "./components/*"
         ],
         "@utils/*":[
            "utils/*"
         ]
      },
      "target":"es5",
      "lib":[
         "dom",
         "dom.iterable",
         "esnext"
      ],
      "allowJs":true,
      "skipLibCheck":true,
      "esModuleInterop":true,
      "allowSyntheticDefaultImports":true,
      "strict":true,
      "forceConsistentCasingInFileNames":true,
      "noFallthroughCasesInSwitch":true,
      "module":"esnext",
      "moduleResolution":"node",
      "resolveJsonModule":true,
      "isolatedModules":true,
      "noEmit":true,
      "jsx":"react-jsx"
   },
   "include":[
      "src"
   ]
}

caraco.config.js

The tsConfigPath property is set to "./tsconfig.json", indicating the file path where the TypeScript configuration (tsconfig.json) is located.

This file contains the "baseUrl" and "paths" configurations for alias resolution.



const CracoAlias = require("craco-alias");

module.exports = {
    plugins: [
        {
            plugin: CracoAlias,
            options: {
                source: "tsconfig",
                // baseUrl SHOULD be specified
                // plugin does not take it from tsconfig
                baseUrl: "./src",
                // tsConfigPath should point to the file where "baseUrl" and "paths" are specified
                tsConfigPath: "./tsconfig.json"
            }
        }
    ]
};

how to use indexedDB

pwn0x80 — Wed, 12 Oct 2022 09:46:36 +0000

A short but comprehensive guide to IndexedDB

IndexedDB is a standard for storing structured data on the client side. This article is a guide on the functional way to use application of this technology.

Introduction

This is a key/value store (NoSQL database), which is considered the ultimate solution for storing data in browsers. IndexedDB is an asynchronous API. This means that performing priority operations will not block the flow of the user interface. IndexedDB can store an indefinite amount of data, which depends on the user.

It is supported on all modern browsers.
It supports transactions, versioning, and provides good performance.

Inside the browser we can also use:

— Cookies that may contain a small number of strings.

— DOM storage (or Web storage) is a term that usually defines localStorage and sessionStorage as two key/value type stores. sessionStorage does not save data that is cleared after the session ends, but localStorage does.

— Local/session storage has the disadvantage of limiting the available space: from 2 MB to 10 MB of space per site.

— In the past, there was a Web SQL wrapper for SQLite. But now Web SQL is outdated and is not supported in some modern browsers. It has never been a generally accepted standard, so it should not be used, however, 83% of users still have this technology on their devices in accordance with Can I Use.

Although it is technically possible to create several databases for a site, one is usually created. You can create multiple repositories inside this database. The database is private for the domain, so one site cannot access the IndexedDB repositories of another.

Creating a Database

When starting with this indexedDB it is necessary to open a connection, then specify the Database Schema that it will have, this refers to the structure of the objects that will be stored, and finally, carry out the desired transactions.

One of the most noteworthy advantages of IndexedDB is that, being independent of whether there is internet connection or not, the application can work both online and offline.

Working with the database begins with an open request:

const request = indexedDB.open(DB_Name, 1, ()=>{});

The first two parameters are obvious. The third parameter, which is optional, is a callback that is called only if the version number is greater than the currently installed version of the database. In the body of the callback function, you can update the structure (stores and indexes) of the database.

The object store is created or updated in the callback with:
db.createObjectStore(‘storeName’, options, ()=>{}) or we can implement in
request.onupgradeneeded =()=>{}.

The open method returns an IDBOpenDBRequest object, in which we are interested in three event handlers:

onerror ;
onsuccess ;
onupgradeneeded .

Onerror will be called in case of an error and will receive an error object in the parameters.

Onsuccess will be called if everything went well, but the method will not receive an open database instance as a parameter. The open database is available from the request object: request.result .

While everything was the same as before, but now the differences begin. The second argument to the open method is the version of the database. The version can only be a natural number. If you pass a fraction, it will be rounded up to an integer. If there is no database with the specified version, then onupgradeneeded will be called , in which you can modify the database if an old version exists, or create a database if it does not exist at all.

The index gives you the ability to get the value by that particular key, and it must be unique (each element must have a unique key).

const db = request.result;
const store = db.createObjectStore(Object_Store, { keyPath: “id” })

Thus, a generic database connection function might look like this:

let createIndexedDB = (indexedDB) => {
  return new Promise((resolve, reject) => {
    //db Name
    const request = indexedDB.open(DB_Name, 1);
    request.onerror = (err) => reject(err);
    request.onupgradeneeded = () => {
      const db = request.result;
      const store = db.createObjectStore(Object_Store, { keyPath: "id" })
      store.createIndex(name, [name], { unique: false });
    }
    request.onsuccess = () => {
      console.info("successfully open db")
      resolve(request.result);
    }
  })
}

unique specifies whether the index value must be unique and
no duplicate values can be added.

store.createIndex(name, [name], { unique: false });

Working with records

As mentioned in the introduction, any operations on records in IndexedDB occur within a transaction. A transaction is opened with the transaction method . In the method, you must specify which ObjectStore you need and the access mode: reading, reading and writing, version change. The upgrade mode is essentially the same as the onupgradeneeded method.

I didn’t measure specific numbers, but I think from a performance point of view it’s better to carefully set transaction parameters: open only the ObjectStore you need and don’t ask for a write when you only need to read.

let option = db => (method, arg, callback) => {

const transaction = db.transaction("Object_Store", method);

let store = transaction.objectStore("Object_Store")

return callback(arg, store)

}

let modeOption = (option2func) => {

let getAlldb = (arg) => option2func(“readwrite”, arg, (arg, store) => store.getAll())

let dataViewdb = (arg) => option2func(“readonly”, arg, (arg, store) => store.getKey(arg))

let dataDeletedb = (arg) => option2func(“readwrite”, arg, (arg, store) => { store.delete(arg) })

let dataPutdb = (arg) => option2func(“readwrite”, arg, (arg, store) => { store.put(arg) })

return ({ dataViewdb, dataDeletedb, dataPutdb, getAlldb })

to connect transactions (modeOption) and createIndexedDB we use custom promise base piping


let pipe = (...functions) => (input) => func.reduce((next, func) =>
  next.then(func), Promise.resolve(input)
)

Always check for browser support before using the IndexedDB API. You never know which browser the user is using:


const indexedDB =

window.indexedDB ||

window.mozIndexedDB ||

window.webkitIndexedDB ||

window.msIndexedDB ||

window.shimIndexedDB;

let globalstore = indexedDB == null ?

console.log(“Broswer did not Support”)

:

pipe(

createIndexDB,

option,

modeOption

)(indexedDB)

Example-

https://github.com/pwn0x80/radio/blob/main/src/services/indexedDB.js


let readwriteStore, readonlyStore;
let createIndexDB = (indexedDB) => {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open('audioDatabase', 1);
    request.onerror = (err) => reject(err);
    request.onupgradeneeded = () => {
      const db = request.result;
      const store = db.createObjectStore('audio', { keyPath: "id" })
      store.createIndex("nameDB", ["trackName"], { unique: false });
    }
    request.onsuccess = () => {
      console.info("successfully open db")
      resolve(request.result);
    }
  })
}


let option = db => (method, arg, callback) => {
  const transaction = db.transaction("audio", method);
  let store = transaction.objectStore("audio")
  return callback(arg, store)
}



let modeOption = (option2func) => {
  let getAlldb = (arg) => option2func("readwrite", arg, (arg, store) => store.getAll())
  let dataViewdb = (arg) => option2func("readonly", arg, (arg, store) => store.getKey(arg))
  let dataDeletedb = (arg) => option2func("readwrite", arg, (arg, store) => { store.delete(arg) })
  let dataPutdb = (arg) => option2func("readwrite", arg, (arg, store) => { store.put(arg) })
  return ({ dataViewdb, dataDeletedb, dataPutdb, getAlldb })


}
let pipe = (...func) => (input) => func.reduce((pro, fun) =>
  pro.then(fun), Promise.resolve(input)
)


const indexedDB =
  window.indexedDB ||
  window.mozIndexedDB ||
  window.webkitIndexedDB ||
  window.msIndexedDB ||
  window.shimIndexedDB;
let globalstore = indexedDB == null ?
  console.log("browser does not support")
  :
  pipe(
    createIndexDB,
    option,
    modeOption
  )(indexedDB)

export default () => {
  return globalstore
}

~pwn0x80 :)