DEV Community: Pranati

Anyone can help in tailwind?

Pranati — Thu, 04 Jun 2020 09:23:02 +0000

I am facing some issues with tailwind postcss. None of the class are working.

I am working with simple html file no framework.
Installed tailwind as using npm using vscode.

Any help will be greatful!

Client Server Pattern

Pranati — Wed, 11 Dec 2019 07:52:40 +0000

This pattern consists of two parties; a server and multiple clients.
The server component will provide services to multiple client components

Clients request services from the server and the server provides relevant services to those clients.

Two - Tier Client/Server Structure

A two-tier architecture is where a client talks directly to a server, with no intervening server. It is typically used in small environments

Three tier architectures

In the three tier architecture, a middleware is used between the user system interface client environment and the database management server environment.

The widespread use of the term 3-tier architecture also denotes the following architectures:

• Application sharing between a client, middleware and enterprise server.

Divide middleware products into two categories:

○ Primitive middleware– The middleware layer that is able to tie together many different systems to create a single logical system, a virtual system.

○ Database-oriented middleware – It uses a primitive middleware to more information to and from a database.

• Application sharing between a client, application server and enterprise database server.

Presentation layer
Supports the GUI. Sometimes this is called a GUI-lite application. There may be many different kinds of GUI.

Application logic
Includes all function and procedures that make the application an application for a particular domain.

Database
A large computational server could act as a mathematical engine.

Resoruces

http://infolab.stanford.edu/~burback/dadl/node107.html

https://towardsdatascience.com/10-common-software-architectural-patterns-in-a-nutshell-a0b47a1e9013

Web Architecture Pattern:- Layered Pattern

Pranati — Mon, 02 Dec 2019 06:02:06 +0000

Welcome! In this series we will look at different Architecture Patterns one by one.

Architecture patterns are well known patterns for solving software application architecture problems.

They are high-level strategies that concerns large-scale components, the global properties and mechanisms of a system.

A large complex software goes through a series of deconstruction at different levels.
At large level, architectural patterns are the tools. At smaller level, design patterns are the tools and at implementation level, programming paradigms are the tools.

The first Architecture Pattern:

Layered Pattern

• The most common architecture pattern is the layered 
  architecture pattern, otherwise known as the n-tier 
  architecture pattern

• Components within the layered architecture pattern are 
  organized into horizontal layers, each layer performing 
  a specific role within the application 

• The layered architecture pattern does not specify the 
  number and types of layers that must exist in the 
  pattern.

Most layered architectures consist of four standard layers: presentation, business, persistence, and database

The layers of isolation concept also means that each layer is independent of the other layers, thereby having little or no knowledge of the inner workings of other layers in the architecture.

1.1 Different Layers :

The presentation layer: Contains all of the classes responsible for presenting the UI to the end-user or sending the response back to the client

The Business layer: Represents the underlying domain, mostly consisting of domain entities and, in some cases, services. Business rules, like invariants and algorithms, should all stay in this layer.

The Persistence Layer and Database Layer : Contains all the classes responsible for doing the technical stuff, like persisting the data in the database, like DAOs, repositories.

Usage

• General desktop applications.
• E commerce web applications.

Layered Architecture is about organizing code for a good separation of concerns and nothing else

Resources

https://dzone.com/articles/layered-architecture-is-good
https://www.oreilly.com/library/view/software-architecture-patterns/9781491971437/ch01.html
https://stackoverflow.com/questions/4243187/whats-the-difference-between-design-patterns-and-architectural-patterns

Types of Indexing in Databases

Pranati — Fri, 29 Nov 2019 15:59:36 +0000

The usual index and pointer to the record structure of indexing is not beneficially in all the cases different indexing techniques are used to help combat different records present in databases.

Below are few different types of Indexing.

Primary Index - In primary index, there is a one-to-one relationship between the entries in the index table and the records in the main table.

Dense primary index
• The number of entries in the index table is the same as the number of entries in the main table.
• Each and every record in the main table has an entry in the index.

Sparse Index
• For large tables,to locate a record we find the index record with the largest search key. Value less than or equal to the search key value.
• We start at that record pointed to by the index record, and proceed along the pointers in the file (that is, sequentially) until we find the desired record.

Clustering Index

• It may happen sometimes that we are asked to create an index on a non-unique key, such as Dept-id.
• There could be several employees in each department.
Here we use a clustering index, where all employees belonging to the same Dept-id are considered to be within a single cluster, and the index pointers point to the cluster as a whole.

Multilevel Index/Secondary Index:
• A multilevel index considers the index file, which we will now refer to as the first (or base) level of a multilevel index, as an ordered file with a distinct value for each K(i).
• In this case, the original index file is called the first-level index and the index to the index is called the second-level index.
• We can repeat the process, creating a third, fourth ... top level until all entries of the top level fit in one dis

When the number of keys is high, the data is read from disk in the form of blocks. Disk access time is very high compared to main memory access time. The main idea of using B-Trees is to reduce the number of disk accesses.

We will see use of B and B+ trees in next blog post!

Resources
https://www.tutorialspoint.com/dbms/dbms_indexing.html
https://www.ques10.com/p/14831/how-does-multilevel-indexing-improve-the-efficienc/
https://www.javatpoint.com/indexing-in-dbms

Purpose of Indexing in Database

Pranati — Thu, 28 Nov 2019 06:56:16 +0000

The flat file consisting of rows (records) and columns and it takes a lot of blocks to store those records

The records of the file must be allocated to disk blocks as block is the unit of data that transfers between disk and memory.

To store files in a block is termed as File Organisation.

Ordered Organisation: We store the file in sequential order. If the ordering key is also a key field then the field is called ordering key for the file. Binary Search is used to search a record.

Unordered Organisation : In this records are added as they’re inserted so new records are at the end of file. It uses heap data structure.

Below is the records divided into blocks there are total 1000 blocks. In normal sequential file where we use Binary search to search an record we go to the middle element and check it value which also consumes a lot of time.

In Indexing it’s like a book index which will directly take you the page number in our case the block number to which a record belongs or present in it.

The index table consists of the key and a pointer to the location of record in the block.
Suppose we want to find record 10 we will direct locate it’s respective pointer in this case it is 10 then using the pointer value.

• Index record contains two fields (structure of the index file)-
• The key of the original file
• Pointer to the block where the key is available in the original data records
• Binary search is used to search through the indices.

To access a record using indexed enteritis number of block accesses required-

log2Bi+1 , where Bi is the number of blocks in the indexed records

Without Indexing Time Complexity
• Ordered file of r=50000 records
• Block size B =1024 bytes
• Records Fixed sized and unspanned with record length R=100 bytes
• (a) Blocking Factor Bfr = B/R = 1024/200 = 5 records per block
• (b)Numberofblocksneededforfileis
• b= r/bfr = 50000/5 = 10000 blocks
• (c)Abinarysearchonthedatafilewouldneed approx
• log2b = log210000 = 13 block accesses

Indexing values and searching records using Binary Time Complexity
•ordering key V=15bytes long and block pointer P=5bytes long
•Size of each index entry Ri = 20 bytes
•(a) Blocking factor bfri = 1024/20 = 51 entries per block
•(b) Number of entries ri = number of blocks in data file Number of blocks needed for index is
• bi= ri/bfri = 10000/51 = 196 blocks
•(c) A binary search of index file would need
• log2bi = log2196 = 8 block accesses
•PLUS one block access into the data file itself using the pointer
(d) Therefore 9 block accesses needed.

Indexing values using linear Search and searching records using Binary Time Complexity

(a) Linear search requires b/2=10000/2=5000 block accesses Suppose a secondary index on a field of V=9bytes
Thus Ri = 9+6 = 15bytes
(b) bfri = B/Ri = 1024/15 = 68 entries per block
Number of index entries ri = number of records = 50,000
Number of blocks need is bi= ri/bfri = 50000/68 = 735 blocks
(c) A binary search of index file would need
log2bi = log2735 = 10 block accesses
PLUS one block access into the data file itself using the pointer
(d) Therefore 11 block accesses

As from the above calculations the binary search optimisation wins in both the cases to search the indices and average record lookup in the index tables.

There are different types of Indexes which uses different strategies to find the record we will see that in the next post.

Resources:

https://www.datacamp.com/community/tutorials/introduction-indexing-sql

https://gradeup.co/file-organization-i-5282706f-c5a6-11e5-b9cf-3799afe3355e

www.cs.montana.edu/~halla/csci440/n18/n18.html

Database Storage

Pranati — Wed, 27 Nov 2019 14:54:01 +0000

Indexing is a term used in DBMS which is used to reduce the number of operations or lookups to find a record in a database.

Before, we dive right into the concept of indexing lets first understand why we needed it in the first place?

To understand Indexing we need to understand first the disk structure and how the data is stored in the disk.

A disk is divided into sectors ,tracks and blocks .

Each sector consist of multiple tracks->Intersection of tracks and sectors is called blocks ->Each byte of the block is called offset.

To locate a block address we need track id and sector id.

Block address = (sector id, track id)
Typically for study purpose we assume size of block as 512 bytes

To reach particular byte we need -> track id, sector id, block id
By spinning the disk the sectors are changed and by moving the disk tracks are changed

• Typically the entire database is stored on disk.
• Data must be moved from disk to main memory in order for the data to be operated on.
• After operations are performed, data must be copied back to disk if any changes were made.
• Disk storage is called direct access storage as it is possible to read data on the disk in any order (unlike sequential access).
• Disk storage usually survives power failures and system crashes.

Organizing the data on the main memory is done by Data Structures whereas , organizing the data on the disk efficiently so it can be utilized is done by DBMS.

Tables are stored on the hard disk of the database server. The database tables are usually divided into column and rows, just like a regular graphic table.

In a database table, the columns specify the information category and the data type and the rows hold the actual information.

How data is stored in disk
For eg :
Consider a tables with n columns with 100 records
Total size of each row in the table is 128 bytes

If the block size is 512 bytes then,
No of records per block = 512/128 = 4
Means we can store 4 rows in 1 block and next 4 in next block and so on

100 records = 100/4 = 25
25 blocks for 100 records

The time to search a record in a table depends upon the number of blocks.
As the number of records increases so will the number of blocks so to access an block with less time we use Indexing

We will see Indexing in Next blog post!

Resources
https://www.ntchosting.com/encyclopedia/hosting/database-storage/