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