We use normalization to reduce the data being anomalous or redundant and inaccurate
as these discrepancies when dealing with data can be a small issue that transitions into a
much larger issue down the road. normalization sorts this data into a related table,
dividing the data and establishing relationships between the tables as well. The
consequences of not normalizing a relational database are broad but none of them are
good things to have happen. These issues include inaccuracy, slow and inefficient data
translation, and the data may end up not being what the developer is expecting to see
when putting the database together. There's been a number of these subjects that seem
like mild oversights but in reality are something that could absolutely devastate a
project, especially if that project has a dead line for a client or a development schedule
to keep up with. Normalization allows for us to clear up these discrepancies and it laid
out fairly easily enough that anyone should be able to understand it which helps
especially for those of us who don't have much software development experience as of
yet. Normal forms are being used in software engineering because it helps to split larger
tables into smaller one, so it is easier to link them using relationships. Another reason is
that it improves the integrity of data. Consequences of not using normalization of
databases is that there would be a lot of redundancies within the tables. There could
also be a lot of errors. These can cause things to slow down since it needs time to
break things down. Plus I feel like you will need to an update a lot which will also
cause things to slow down. We use Normalization to minimize the redundancy of data.
It helps to eliminate and reduce the redundancy in database tables. It also helps
streamline data making it more concise. Searching, sorting and creating data is faster.
You can fit more data on a page or layout. It also gives more flexibility since there are
fewer files per table. Since the information can be standardized, the size of the
information and storage it takes can be reduced, fitting more information into one place.
Some of the downfalls of normalization would that the there is a constant need to go
update query tables since the tables contain certain codes. The data is stored as lines of
code rather than genuine data. The data model is also very difficult to manipulate. Most
applications use a simplified connection to the data model so they have issues reading
the more advanced code used in normalization. This will also create a "slow down" in
the data due to longer processing times on the more advanced data coding.
Normalization is the process of organizing data in a database such as how the tables are
created, what belongs in the columns and the relationships between the tables. This
helps by eliminating redundancy within the database that can waste space. Using a
normalization structure when creating a database during the software engineering phase
can help lessen errors and improve performance of the program. If a database is created
without normalization tables could be created that have “Inconsistent dependencies” such
as trying to access an address by searching the zip code.A drawback of normalization
would be creating a longer task, with more tables to join, the need to join them together
increases and causes it to take more time. Normalization of a database is a complex and
difficult task due to the analysis needing to know the purpose of the database and what
it should be optimized for such as reading or writing data, or both. The use of normal
forms has benefits in both the field of software engineering and that of data analysis.
They make it feasible to do data analysis and arrange code in an effective manner. The
First Normal Form (1NF), the Second Normal Form (2NF), and the Third Normal Form
are the three separate types of functional Normal Forms (3NF). Any one of these many
file formats for software components may be seen as a collection of interconnected
processes that carry out a particular activity. The usage of normal forms helps to prevent
unforeseen issues, such as software faults that might lead to the failure of a system. A
few of these errors are the direct result of redundant code, which may be seen as
performing the same thing more than once.The presence of inconsistent data is a
common issue that may lead to disruptions and mistakes in the system. These issues
might arise if there are discrepancies in the information that two or more components of
the system need in order to function properly. Another problem may arise when two
separate pieces of software are integrated into a single program in order to carry out the
same function. This can result in an error when the two separate pieces of software are
utilized in conjunction with one another. The solution to these issues is to make use of
conventional forms in order to locate, simplify, and remove any unneeded components
of the code, as well as any unwanted software functionality. Computer databases are
used everywhere and for everything. Normal From Database are used in software
engineering because they are simple and store data in a logical and related way.
Some of the advantages of doing this are:
Ease of storage
Information is easily retrieved
Information is secure
Data is organized logically which would be like how it would be stored in the real
world
Reduces the database size
Prevents data duplication and ensures each data piece is only stored once
Some of the disadvantages of using normal form database are:
Additional costs for using the database
It slows data performance over other types of databases .Normal form databases are
complex and difficult tasks to complete.In a project if you use and Normal form
database some of the consequence could be time and money. When completing a project
since the normal form database is more complex you would need to ensure the
programmers now how to code and develop that type of database and also give them
more time to create it because it is more complex. Because you need a higher trained
developer, and it will require more time it means that there would be a higher cost for
the project.
Normalization is the process of minimizing redundancy from a relation or set of
relations. Redundancy for engineering is the inclusion of extra components which are
not strictly necessary to functioning, in case of failure in other components. What this
means is it simplifies data in a database for the software engineers to read and
understand. An example would be if we had a data base for customers at a video rental
store. We would have a name, address, and what titles they have borrowed. Instead of
compiling all the titles into one cell, the first normal form (1NF) would separate those
labels into their own row of data, keeping the persons information that has borrowed it. c
Without normalization, it could lead to issues with the hardware, software, and leaves a
risk for inaccurate data. A consequence for not having normalization can create duplicate
information and inaccuracy data as this will increase the overall size. With an increased
database full of potentially inaccurate data, it would really deal a blow to your overall
system performance as it would require additional memory and processing power to
operate.
The main purpose of normal forms is to structure and organize data in a way that
minimizes redundancy, improves the integrity of the data and make it easier to manage
and maintain the database over time. For example, in a company’s employee information
database, the 3NF is used to minimize redundancy and dependency in the database.
Another example, a products database that contains a table that has no repeating groups
of data like a products table, first normal form is used to ensure that each record in the
table is unique, not redundant, easy to update and more accurate.
If the database is not designed using normal form, it can have many consequences that
include data redundancy because multiple copies of the same data will exist that make it
difficult to update and maintain. Thus, data integrity problems and inconsistency will
happen. With multiple copies of data exist, data query is a problem. Not using normal
form in software engineering can lead to several problems that can impact the reliability,
efficiency, and integrity of a database. Relational databases are a simply way to organize
data. You can combine data from other tables, sort results, and have a variety of ways
to organize the data, but it comes with some issues. Normal forms are a way to address
some of those issues. One of the important issues that it addresses is minimizing
redundancy. Another reason normal forms are used is to help make data more
meaningful by reducing anomalies to minimal or zero. This is done by making sure that
a specific set of rules are followed. For example, First normal form (1NF) has six
official requirements for a table:
1. Each column must have a unique name.
2. The order of the rows and columns doesn't matter
3. each column must have a single data type
4. no two rows can contain identical values
5. Each column must contains single value
6. Columns cannot contain repeating groups.
Some of the issues that can occur without normal forms are things like, duplicate data,
not being able to delete partial data without deleting it all or the existence of unnecessary
data. An example of this was the relational database for the gym I use to own. Normal
forms prevented me form accidentally entering the same member twice. It also helped
keep people separated and organized when there where multiple people with the same last
or first names. Normal forms are considered to be a powerful tool for software
engineering and data analysis. These forms can be used to eliminate and reduce data
redundancy in relational databases throughout the process of software engineering.
Software engineers can easily use these forms to eliminate or reduce undesirable
characteristics like update, insertion, and deletion anomalies. The normalization process
classifies the larger table into different smaller parts and uses relationships to relate them
(DBMS normalization: 1NF, 2NF, 3NF and BCNF with examples - javatpoint, 2021).
Moreover, the normal forms are considered to be easy to integrate the database created
and the designed software for the software engineers.
If the software engineer develops a relational database without normalizing it, it can result
in an inefficient, slow and inaccurate database system. It will not produce the expected
data from the database system (Relational Database Normalization Process, 2021). Even it
becomes very difficult to update and handle the database without normalizing the database
as sometimes data can lose. If the database is not using the normal form, then frequent
updating, insertion, and deletion anomalies can occur. Thus, it becomes important to
nominalize the database. For example, poorly normalized tables and a poorly normalized
database can create issues for the software engineer because of the subsequent poor
performance of the database system and excessive disk I/O to the inaccurate database.
