Software frameworks
In computer programming, a software framework is an abstraction in which software providing generic functionality can be selectively
changed by additional user-written code, thus providing application-specific
software. A software framework is a universal, reusable software environment
that provides particular functionality as part of a larger software platform to facilitate development of software applications,
products and solutions. Software frameworks may include support programs,
compilers, code libraries, tool sets, and application programming interfaces (APIs) that bring together all the different components to enable development of a project
or solution.
·
inversion of control:
In a framework, unlike in libraries or normal user applications, the overall
program's flow of control is not dictated by the caller, but by the framework.[1]
·
default behavior: A framework has a default behavior. This default behavior must be some
useful behavior and not a series of no-ops.[citation needed]
·
extensibility: A framework
can be extended by the user usually by selective overriding or specialized by
user code to provide specific functionality.
·
non-modifiable
framework code: The framework code, in general,
is not supposed to be modified, while accepting user-implemented extensions. In
other words, users can extend the framework, but should not modify its code
The designers
of software frameworks aim to facilitate software development by allowing
designers and programmers to devote their time to meeting software requirements
rather than dealing with the more standard low-level details of providing a
working system, thereby reducing overall development time.[2] For example, a team using a web application framework to develop a banking web-site can focus on writing code particular to
banking rather than the mechanics of request handling and state management.
Frameworks
often add to the size of programs, a phenomenon termed "code bloat". Due to customer-demand driven applications needs, both competing
and complementary frameworks sometimes end up in a product. Further, due to the
complexity of their APIs, the intended reduction in overall development time
may not be achieved due to the need to spend additional time learning to use
the framework; this criticism is clearly valid when a special or new framework
is first encountered by development staff.[citation needed] If such a framework is not used in subsequent job taskings, the time
invested in learning the framework can cost more than purpose-written code
familiar to the project's staff; many programmers keep copies of useful
boilerplate for common needs.
However, once a
framework is learned, future projects can be faster and easier to complete; the
concept of a framework is to make a one-size-fits-all solution set, and with
familiarity, code production should logically rise. There are no such claims
made about the size of the code eventually bundled with the output product, nor
its relative efficiency and conciseness. Using any library solution necessarily
pulls in extras and unused extraneous assets unless the software is a compiler-object
linker making a tight (small, wholly controlled, and specified) executable
module.
The issue
continues, but a decade-plus of industry experience has shown that the most effective
frameworks turn out to be those that evolve from re-factoring the common code
of the enterprise, instead of using a generic "one-size-fits-all"
framework developed by third parties for general purposes. An example of that
would be how the user interface in such an application package as an office
suite grows to have common look, feel, and data-sharing attributes and methods,
as the once disparate bundled applications grow unified into a suite which is tighter and smaller; the newer/evolved
suite can be a product that shares integral utility libraries and user interfaces.
See
more: https://en.wikipedia.org/wiki/Software_framework
No comments:
Post a Comment