Showing posts with label SRS. Show all posts
Showing posts with label SRS. Show all posts

Saturday, January 21, 2012

Architecture: What’s in your architecture toolbox?


It is said that there’s a tool for every job. But when that job is IT architecture, in all its permutations, the definition of tool can be a bit fuzzy.

When I set out to get a sense of what community members consider the most important tool in their respective architectural toolboxes, I intentionally left the definition of tool open. I was curious to see how those who responded to my questions would interpret the term.
One of those respondents was Farzad Pezeshkpour, head of architecture and engineering for market and credit risk technology at the Royal Bank of Scotland. His personal choice for the most important tool is Enterprise Architect from Sparx Systems.
“In order to do enterprise architecture well,” Pezeshkpour says, “there must be a consistent way to represent it, using a number of different views at different levels of detail, including logical static, logical dynamic, and deployment. There also must be a consistent naming and referencing mechanism to tie together all the architecture views. And finally, there must be an enterprise architecture repository to store and cross-reference these artifacts.
Having these three core elements in our toolset and processes gives an architectural management information view that helps govern our estate more efficiently and intelligently.”
Architecture is deeply connected to the specific business and technological environment in which an organization operates. Pezeshkpour works at one company, in one environment—which is challenging enough. But what happens if your work as an architect takes you into a variety of different environments?
If you find yourself in that situation, Vennster Managing Partner Ronald van Luttikhuizen advises adaptability when it comes to tools. “Especially if you’re a consultant working for various clients, it greatly helps to use the tooling that is available and already in use by clients and stakeholders, instead of rigidly sticking to your own toolset,” says this Oracle ACE Director. 
That can mean dealing with a variety of Unified Modeling Language (UML), Business Process Model and Notation (BPMN), and other modeling and design tools. As for his personal favorite, van Luttikhuizen also lists Sparx Systems’ Enterprise Architect. “A great tool at a great price,” he says.
But van Luttikhuizen’s toolbox also contains some more-basic applications to help him get his message across. “In the end, architecture is about communication,” he says. “So in the beginning of an architecture-oriented project, the most important tools are a whiteboard, Microsoft PowerPoint, and Microsoft Word.”
Karina Ishkhanova, a solution architect and technical lead for payment systems at School-Day Solutions, agrees with van Luttikhuizen about the importance of basic communication tools. “The first stage in defining the future architecture happens in close collaboration with business departments,” she says. “Whiteboards, paper, and markers are indispensable. Sometimes we even cut paper into components to move them around to help visualize the variations on proximity to other system parts.”

For modeling, Ishkhanova uses UMlet, an open source UML tool, which she values for its simplicity. “At more-advanced stages, I move to Oracle JDeveloper,” she says, “to take advantage of its integration and automation features.”

Communication tools are also vital for Lambda Software President Aki Iskandar.
“By far the most important tool in my toolbox is the one that I ask my clients to hand to me before any discussions, let alone architectural work, starts. It’s the set of three blueprint documents that jointly define well-articulated and complete business requirements, the constraints within the environment, and the architectural diagrams for network topologies,” Iskandar says. “Without them, you may overarchitect or underarchitect the system. You can’t architect a system without knowing the constraints before you start.”
Perhaps his last point is the IT architect’s equivalent of the carpentry maxim “Measure twice, cut once.”
While the choice of tools varies among these four architects, that choice is driven by the shared goal of effective communication in order to ensure a good fit between the up-front plan and the completed project. Isn’t that what IT architecture is all about?

Thursday, November 17, 2011

SDLC: Software life cycle activities

Whichever software life cycle is adopted, the software engineering activities briefly described in the following sections will need to be carried out.

1- Requirements Analysis and Specification
In this phase, the user’s requirements are identified and analyzed. The requirements of the system to be  developed are specified in a Software Requirements Specification (SRS). The SRS is an external specification of the software. Its goal is to provide a complete description of what the system’s external behavior is without describing how the system works internally. The issues of what constitutes a SRS are described lucidly in Davis (1993).

With some systems, such as embedded systems, in which the software is part of a larger hardware/software system, it is likely that a systems requirements analysis and specification phase precedes the software requirements analysis and specification.

With this approach, system functional requirements are allocated to software and hardware before software requirements analysis begins (Davis 1993).

2- Architectural Design
A software architecture (Bass, Clements, and Kazman 2003; Shaw and Garlan 1996) separates the overall structure of the system, in terms of components and their interconnections, from the internal details of the individual components. The emphasis on components and their interconnections is sometimes referred to as programming-in-the-large, and detailed design of individual components is referred to as programming-in-the-small. During this phase, the system is structured into its constituent components and the interfaces between these components are defined.

3- Detailed Design
During the detailed design phase, the algorithmic details of each system component are defined. This is often achieved using a Program Design Language (PDL) notation, also referred to as Structured English or pseudocode. Internal data structures are also designed.

4- Coding
During the coding phase, each component is coded in the programming language selected for the project. Usually a set of coding and documentation standards have to be adhered to.

5- Software testing
Because of the difficulty of detecting errors and then locating and correcting the detected errors, software systems are usually tested in several stages (Ammann and Offutt 2008). Unit and integration testing are “white box” testing approaches, requiring knowledge of the internals of the software; system testing is a “black box” testing approach based on the software requirements specification, without knowledge
of the software internals.

5.1 Unit Testing
In unit testing, an individual component is tested before it is combined with other components. Unit testing approaches use test-coverage criteria. Frequently used test-coverage criteria are statement coverage and branch coverage.

Statement coverage requires that each statement should be executed at least once.
Branch coverage requires that every possible outcome of each branch should be tested at least once.

5.2 Integration Testing
Integration testing involves combining tested components into progressively more complex groupings of components and then testing these groupings until the whole software system has been put together and the interfaces tested.

5.3 System Testing
System testing is the process of testing an integrated hardware and software system to verify that the system meets its specified requirements (IEEE 1990). The whole system or major subsystems are tested to determine conformance with the requirements specification. To achieve greater objectivity, it is preferable to have system testing performed by an independent test team.

During system testing, several features of the software system need to be tested (Beizer 1995). These include the following:

Functional testing. To determine that the system performs the functions described in the requirements                specification.

Load (stress) testing. To determine whether the system can handle the large and varied workload it is expected to handle when operational.

Performance testing. To test that the system meets its response time requirements.

5.4 Acceptance Testing
The user organization or its representative usually carries out acceptance testing, typically at the user installation, prior to acceptance of the system. Most of the issues relating to system testing also apply to acceptance testing.

Thanks to Dr. Hassan Gomma 2011 book "Software Modeling and Design".