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