CSC/ECE 517 Fall 2009/wiki2 19 as: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
Line 5: Line 5:


===Strengths===
===Strengths===
In RDD, Objects are service-providers, information-holders, structurers, coordinators, controllers, and interfacers to the outside world. Each must know and do its part! Thinking in terms of these object role stereotypes enables you to build powerful, flexible applications. Developing consistent control styles for similar parts of your application reduces maintenance costs. Incorporating flexibility into your design at specific “flex points” allows for planned extensions[1].
Information encapsulation is maintained, since objects use their own information to fulfill tasks. This usually supports low coupling, which leads to more robust and maintainable systems. Behavior is distributed across the classes that have the required information, encouraging more cohesive “lightweight” class definitions that are easier to understand and maintain. High cohesion is usually supported[2].
===Weaknesses===
===Weaknesses===



Revision as of 05:05, 9 October 2009

Development Methodologies

Responsibility Driven Design

Overview

Responsibility-driven design (RDD) is a way of designing complex software systems using objects and component technology. RDD was conceived as a shift from thinking about objects as data + algorithms, to thinking about objects as roles + responsibilities. In a responsibility-based model, objects play specific roles and occupy well-known positions in the application architecture. It is a smoothly-running community of objects. Each object is accountable for a specific portion of the work. Objects collaborate in clearly-defined ways, contracting with each other to fulfill the larger goals of the application. By creating such a “community of objects,” assigning specific responsibilities to each, you build a collaborative model of your application[1].

Strengths

In RDD, Objects are service-providers, information-holders, structurers, coordinators, controllers, and interfacers to the outside world. Each must know and do its part! Thinking in terms of these object role stereotypes enables you to build powerful, flexible applications. Developing consistent control styles for similar parts of your application reduces maintenance costs. Incorporating flexibility into your design at specific “flex points” allows for planned extensions[1].

Information encapsulation is maintained, since objects use their own information to fulfill tasks. This usually supports low coupling, which leads to more robust and maintainable systems. Behavior is distributed across the classes that have the required information, encouraging more cohesive “lightweight” class definitions that are easier to understand and maintain. High cohesion is usually supported[2].

Weaknesses

Test Driven

Overview

Test-driven development (TDD) is a software development technique that relies on the repetition of a very short development cycle: First the developer writes a failing automated test case that defines a desired improvement or new function, then produces code to pass that test and finally refactors the new code to acceptable standards.

The following flowchart shows the typical development cycle of TDD:

Strengths

Test-driven development offers more than just simple validation of correctness, but can also drive the design of a program. By focusing on the test cases first, one must imagine how the functionality will be used by clients (in the first case, the test cases). So, the programmer is only concerned with the interface and not the implementation. This benefit is complementary to Design by Contract as it approaches code through test cases rather than through mathematical assertions or preconceptions.

The power test-driven development offers is the ability to take small steps when required. It allows a programmer to focus on the task at hand as the first goal is to make the test pass. Exceptional cases and error handling are not considered initially. Tests to create these extraneous circumstances are implemented separately. Another advantage is that test-driven development, when used properly, ensures that all written code is covered by a test. This can give the programming team, and subsequent users, a greater level of trust in the code.

While it is true that more code is required with TDD than without TDD because of the unit test code, total code implementation time is typically shorter.[9] Large numbers of tests help to limit the number of defects in the code. The early and frequent nature of the tests helps to catch defects early in the development cycle, preventing them from becoming endemic and expensive problems. Eliminating defects early in the process usually avoids lengthy and tedious debugging later in the project.

TDD can lead to more modularized, flexible, and extensible code. This effect often comes about because the methodology requires that the developers think of the software in terms of small units that can be written and tested independently and integrated together later. This leads to smaller, more focused classes, looser coupling, and cleaner interfaces. The use of the Mock Object design pattern also contributes to the overall modularization of the code because this pattern requires that the code be written so that modules can be switched easily between mock versions for unit testing or "real" version for deployment.

Because no more code is written than necessary to pass a failing test case, automated tests tend to cover every code path. For example, in order for a TDD developer to add an else branch off an existing if statement, the developer would first have to write a failing test case that motivates the branch. As a result, the automated tests resulting from TDD tend to be very thorough: they will detect any unexpected changes in the code's behaviour. This detects problems that can arise where fixing something later in the development cycle unexpectedly alters other functionality.

Weaknesses

  • Test-driven development is difficult to use in situations where full functional tests are required to determine success or failure. Examples of these are user interfaces, programs that work with databases, and some that depend on specific network configurations.
  • Because writing test spends time, management may feel that it is waste of time unless the entire organization believing that test-driven development is going to improve the product.
  • The tests themselves become part of the maintenance overhead of a project. Badly written tests, for example ones that include hard-coded error strings or which are themselves prone to failure, are expensive to maintain. There is a risk that tests that regularly generate false failures will be ignored, so that when a real failure occurs it may not be detected.
  • The level of coverage and testing detail achieved during repeated TDD cycles cannot easily be re-created at a later date. Therefore these original tests become increasingly precious as time goes by. If a poor architecture, a poor design or a poor testing strategy leads to a late change that makes dozens of existing tests fail, it is important that they are individually fixed. Merely deleting, disabling or rashly altering them can lead to un-detectable holes in the test coverage.
  • Unexpected gaps in test coverage may exist or occur for a number of reasons. Perhaps one or more developers in a team was not so committed to the TDD strategy and did not write tests properly, perhaps some sets of tests have been invalidated, deleted or disabled accidentally or on purpose during later work. If this happens, the confidence that a large set of TDD tests lend to further fixes and refactorings will actually be misplaced. Alterations may be made that result in no test failures when in fact bugs are being introduced and remaining undetected.
  • Unit tests created in a test-driven development environment are typically created by the developer who will also write the code that is being tested. The tests may therefore share the same blind spots with the code: If, for example, a developer does not realize that certain input parameters must be checked, most likely neither the test nor the code will verify these input parameters. If the developer misinterprets the requirements specification for the module being developed, both the tests and the code will be wrong.

Behavior Driven

Overview

Behavior Driven Development (BDD) is an Agile software development technique that encourages collaboration between developers, QA and non-technical or business participants in a software project.

Strengths

Weaknesses

Domain Driven

Overview

Domain-driven design (DDD) is an approach to the design of software, based on the two premises:

Strengths

Weaknesses

Model Driven

Overview

Model-driven engineering (MDE) is a software development methodology which focuses on creating models, or abstractions, more close to some particular domain concepts rather than computing (or algorithmic) concepts. It is meant to increase productivity by maximizing compatibility between systems, simplifying the process of design, and promoting communication between individuals and teams working on the system.

Strengths

Weaknesses

Reference

[1]http://www.wirfs-brock.com/Design.html
[2]http://en.wikipedia.org/wiki/Test_driven_development