Abstract ± Brooks claims that the very nature of
VofWZaUe iV Whe UeaVon a VilYeU bXlleW haVn¶W been
produced and though accidental difficulties can be
addressed, the essential difficulties of complexity,
conformity, changeability and invisibility (CCCI)
means there may never be a complete solution. Prior
Wo BUookV¶ SXblicaWion, Whe eVVenWial difficXlWieV ma
have seemed to be inevitable, however, since the
statement 32 years ago, advances have been made and
this paper aims to find out whether NoSQL is a silver
bullet. The discussion in the paper will investigate if
NoSQL can be considered a silver bullet and tackles
the problems of CCCI.
oSQL is a non-relational database, designed to
address performance and scalability
requirements of big data and real-time web
applications that traditional relational databases
cannot sustain (Ganesh-Chandra, 2015). In
comparisons between MySQL and NoSQL, results
from (Abdullah and Zhuge, 2015) shows the
difference in processing time between the two
depending on the number of objects provided,
whilst 1000 objects show a 0.012-time difference,
this changes to 16.220 seconds when 1000000
objects are implemented, MySQL 18.620, NoSQL
2.400. This vast difference is an accomplishment of
NoSQL and how it has changed the approach to big
data. Although can it be considered a solution to
the issues of CCCI?
When discussing the complexity of software,
it is important to acknowledge that scaling-up of a
software entity is not represented by the same
elements just in larger size but rather an increase of
the number of different elements, resulting in these
elements interacting with unpredictable behaviour.
This can also be applied to the complexity of
NoSQL which this paper will investigate further.
WhilVW cRQfRUPiW iVQ¶W XQiTXe WR VRfWZaUe,
the standards that is expected differ greatly. In
mathematics, new algorithms might be designed to
outperform previous models, but the fundamentals
stay the same. In software, there needs to be
conformity depending on the interface,
specifications and laws which can change over a
SeUiRd Rf WiPe. If Whe VRfWZaUe dReVQ¶W PeeW WheVe
requirements, it could be considered as
unprofessional quality or simply a failure. When
implementing a NoSQL database, it does not need
to conform to a structure like a relational database
needs to, however, there would need to be
conformity when analysing the data for the client to
make use of it.
There is a variety of reasons software might
need to change in the current environment. Demand
for innovation from consumers, change in legality
or software unable to keep up with technology
advances. Regardless of the reason, there is an
ever-increasing number of consumers, Facebook
has an estimated 100 billion messages shared per
day (About Facebook, 2019). The modern system
needs to handle high amounts of data in new ways
that traditional methods cannot withstand, and with
data warehouses being indispensable (Mehmood
and Anees, 2019) software engineers and the
system need to keep up with the change.
Unlike most professions, software systems
are invisible, code is not a physical object, nor can
the designs be constructed in the same manner as
available to an architect. Though tools like ERD
and schema make a representation that software
eQgiQeeUV caQ agUee RQ, bXW Whe dRQ¶W cRPSUeheQd
the final product. In systems that are large or
abstract the diagrams are more complex but still
need to conform with the current standard and
adapt to change when required whilst still being
There has been research carried out to tackle the
problem of complexity in NoSQL. The work
conducted by Corbellini (2017) to determine which
method of NoSQL is most viable when using
AQ iQYeVWigaWiRQ iQWR NRSQL aQd cRQVideUiQg Whe
iQheUeQW difficXlWieV iQ SRfWZaUe EQgiQeeUiQg.
Sam Town, 0009630977, Software Engineering, [email protected]
Key Words ʹ NoSQL, Complexity, Conformity, Changeability,
Invisibility, Silver Bullet, Essential Difficulties
bigdata, suggests that as NoSQL databases are a
broad spectrum (Corbellini et al, 2017), there
would be a solution to the majority of problems in
current database systems although, Corbellini
(2017) also proposes that not every application
requires a NoSQL database due to the complexity
involved (Corbellini et al, 2017). Mior (2017)
continues the discussion of complexity regarding
schema designs for NoSQL applications (Mior et
Although it is important to choose a good
schema, there is not an established methodology or
tools to guide this process (Mior et al, 2017)
leading to the design of NoSQL databases
remaining a complex issue in comparison to
relational databases (Mior et al, 2017). This
suggests the complexity of designing and
implementing a NoSQL database is still a
continuous problem within the industry.
In contrast to this Ramzan et (2019), implies
that the rise of bigdata has led to NoSQL being the
most viable database solution and the complexity is
not due to NoSQL but rather a result of relational
databases needing to shift to the flexible database
(Ramzan et al, 2019).
However, the study by Ramzan (2019) investigated
the migration from traditional relational databases
to NoSQL and did not expand on the complexity
for programmers to understanding or create a
There is a need for programmers to conform to a
standard, this leads to a collective understanding
and reducing the complexity of software design,
this should also apply to NoSQL databases
however, though Miro (2017) agrees of the
importance of a good schema design, they argue
µWheUe aUe QR WRRlV RU eVWabliVhed PeWhRdRlRg WR
gXide aQd VXSSRUW Whe SURceVV¶ (Miro et al, 2017),
leaving the design to previous experience based on
practice rather than theoretical understanding.
A study by Lucchese and Henrique (2017)
was done in order to understand the suitability of
NoSQL storage systems dependent on the
application requirements by using a metric system.
µBig DaWa iV a UaWheU QeZ cRQceSW aQd iWV ecRVVWeP
of tools and applications has been subject to
cRQVWaQW WUaQVfRUPaWiRQ¶ LXccheVe aQd HeQUiTXe
(2017). This suggests that as Big Data and NoSQL
develops, the tools available will also progress and
lead to conformity by software engineers.
Although, even with more advanced tools, this
would not mean NoSQL has dealt with the issue of
conformity completely as expressed by Schreiner
(2019), there is not a standard query language for
NoSQL leaving a steep learning curve for
NoSQL is the result of a need for change the
currently used methods, applications have seen the
amount of data exponentially grow in recent years
(Abdullah and Zhuge, 2015). The success of
NoSQL databases has also led to hybrid methods
being created as programmer need to move beyond
the original domain.
Work by Schreiner (2019) also investigates
this, by implementing relational schemata and SQL
instructions to equivalent schemata and using
access methods of any key-oriented NoSQL
database (Schreiner et al 2019) would reduce the
overall processing time. The results from this study
showed a reduction in processing time and a 95%
confidence interval (Schreiner et al 2019).
Research from Wu (2017) also investigates the
notion of a hybrid NoSQL-SQL database in
relation to real-time geospatial data, showing
improvements in update and query speed whilst
reducing latency when compared to MongoDB and
MySQL (Wu et al, 2017). This suggests that
NoSQL is not stagnated and can change from its
original design, however, though this could be
considered successfully in Brooks terms, there is
still the issue of the complexity of hybrid versions
and not conforming to an agreed upon standard.
NoSQL is non-relational, not constraint in the same
ways as traditional SQL, allowing the developer
more autonomy when designing the database.
However, Zhang (2019) argues that since there are
few rules and restrictions, the design of storage
schema for NoSQL can be difficult, as there could
be a lack of understanding or experience by the
Sellami and Defude (2018), also agreed on
this point, claiming that as programmers need to be
familiar with data models of different application
programming interfaces (APIs), complex queries
cannot be achieve in a declarative way and needs
extra implementation effort (Sellami and Defude,
NoSQL helps software engineers in storing larger
amounts of real-time data more dynamically in
contrast to traditional methods, although, as the
data does not need to be defined, it can be argued
the structure of NoSQL is of less-quality in this
regard. Ganesh (2015) expresses the downsides to
NoSQL are its lack of a universal language, each
NoSQL product is unique and relational databases
have matured over the past 40 years allowing for an
ecosystem of applications and tools available.
In terms of CCCI, NoSQL does not reduce
Whe cRPSle[iW aV ³PaQ cRPSaQieV aQd RSeQ
source communities promoting its own
implementation, making the use of NoSQL
technology in a production environment a tough
deciViRQ´ CRUbelliQi eW al (2017). ThiV VhRZV WhaW
the variety of NoSQL databases also contributes to
Conformity continues to remain an issue, the
lack of a universal language and a need for
established methodologies means both conformity
and complexity cannot be fully solved.
In terms of transitioning a relational
database to a NoSQL database, further research
needs to be done to reduce the complexity and
making change more intertwined with the cultural
matrix of software engineers. However, the use of
NoSQL in hybrid applications shows the potential
of challenging the issues of changeability.
Due to the very nature of software, invisibility
will remain an issue as it is not something physical.
With more conformity, leads to more changeability,
then leads to more complexity and increases
NoSQL shows the progression of the current need
of databases and though it makes improvements in
handling bigdata, it does not deal with the four
issues of software expressed by Brooks. For
example, the metric system on NoSQL suitability
by Lucchese and Henrique (2017) takes a step in
dealing with conformity, nonetheless without a
standard query language, NoSQL will always
remain complex (Schreiner et al 2019). There are
benefits of using NoSQL but as negativities remain
in understanding and implementing the software,
the concept of a silver bullet cannot be applied to
NoSQL as it would need to eradicate all negative
issues regarding to the CCCI.
5. Future Work
Future work on this subject could include further
investigation on creating a standard query language
tool, Mahajan, Blakeney and Zong (2019) have
done research into improving the energy efficiency
of NoSQL databases via using query optimizations
however, not enough research has been done into
the theoretical side of implementing a universal
standard query language.
 G Abdullah, A. and Zhuge, Q. (2015) From
Relational Databases to NoSQL Databases:
Performance Evaluation, Research Journal of
Applied Sciences, Engineering and Technology,
11(4), pp. 434-439.
 About Facebook. (2019). Company Info | About
Facebook. [online] Available at:
10 Nov. 2019].
 Brooks (1987). No Silver Bullet Essence and
Accidents of Software Engineering. Computer,
 Corbellini, A., Mateos, C., Zunino, A., Godoy,
D. and Schiaffino, S., 2017. Persisting big-data:
The NoSQL landscape. Information
Systems, 63, pp.1-23.
 Ganesh Chandra, D. (2015) BASE analysis of
NoSQL database, Future Generation Computer
Systems, 52, pp. 13-21.
 Lucchese, F., 2018. From P2P to NoSQL: a
continuous metric for classifying large-scale
storage systems. Journal of Parallel and
Distributed Computing, 113, pp.227-249.
 Mahajan, D., Blakeney, C. and Zong, Z. (2019)
Improving the energy efficiency of relational
and NoSQL databases via query
optimizations, Sustainable Computing:
Informatics and Systems, 22, pp. 120-133.
 Mehmood, E. and Anees, T., 2019.
Performance Analysis of Not Only SQL SemiStream Join Using MongoDB for Real-Time
Data Warehousing. IEEE Access, 7,
 Mior, M.J., Salem, K., Aboulnaga, A. and Liu,
R., 2017. NoSE: Schema design for NoSQL
applications. IEEE Transactions on Knowledge
and Data Engineering, 29(10), pp.2275-2289.
Ramzan, S., Bajwa, I.S., Ramzan, B. and
Anwar, W., 2019. Intelligent Data Engineering
for Migration to NoSQL based Secure
Environments. IEEE Access.
Schreiner, G., Duarte, D. and dos Santos
Mello, R. (2019). Bringing SQL databases to
key-based NoSQL databases: a canonical
Sellami, R. and Defude, B. (2018) Complex
Queries Optimization and Evaluation over
Relational and NoSQL Data Stores in Cloud
Environments, IEEE Transactions on Big
Data, 4(2), pp. 217-230.
Wu, C., Zhu, Q., Zhang, Y., Du, Z., Ye, X.,
Qin, H. and Zhou, Y. (2017) A NoSQL±SQL
Hybrid Organization and Management
Approach for Real-Time Geospatial Data: A
Case Study of Public Security Video
Surveillance, ISPRS International Journal of
Geo-Information, 6(1), p. 21.
Zhang, D., Wang, Y., Liu, Z. and Dai, S.
(2019) Improving NoSQL Storage Schema
Based on Z-Curve for Spatial Vector
Data, IEEE Access, 7, pp. 78817-78829.
- Assignment status: Already Solved By Our Experts
- (USA, AUS, UK & CA PhD. Writers)
- CLICK HERE TO GET A PROFESSIONAL WRITER TO WORK ON THIS PAPER AND OTHER SIMILAR PAPERS, GET A NON PLAGIARIZED PAPER FROM OUR EXPERTS