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. b 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.
