Discovering early aspects

Elisa L.A.  Baniassad; Paul C.  Clements; João Baptista da Silva Araújo Júnior; Ana Maria Diniz Moreira; Awais Rashid; Bedir Tekinerdoǧan

doi:10.1109/MS.2006.8

Discovering early aspects

Elisa L.A. Baniassad, Paul C. Clements, João Baptista da Silva Araújo Júnior, Ana Maria Diniz Moreira, Awais Rashid, Bedir Tekinerdoǧan

DI - Departamento de Informática

Research output: Contribution to journal › Article

135 Citations (Scopus)

Abstract

Traditionally, aspect-oriented software development (AOSD) has focused on the software life cycle's implementation phase: aspects are identified and captured mainly in code. But aspects are evident earlier in the life cycle, such as during requirements gathering and architecture development. Identifying these early aspects ensures that you can appropriately capture aspects related to the problem domain (as opposed to merely the implementation). Additionally, it offers opportunities for early recognition and negotiation of trade-offs and allows forward and backward aspect traceability. This makes requirements, architecture, and implementation more seamless and lets you apply aspects more systematically. Many techniques exist for dealing with early aspects in practice, but a holistic approach is lacking. This article is an overview of how to exploit early aspects and charts aspects as they move from project inception to development.

Original language	English
Pages (from-to)	61-70
Number of pages	10
Journal	Ieee Software
Volume	23
Issue number	1
DOIs	https://doi.org/10.1109/MS.2006.8
Publication status	Published - 1 Jan 2006

Keywords

Aspect oriented software development
Software life cycle

Access to Document

10.1109/MS.2006.8

http://www.scopus.com/record/display.uri?eid=2-s2.0-31344463651&origin=resultslist&sort=plf-f&src=s&st1

Fingerprint Dive into the research topics of 'Discovering early aspects'. Together they form a unique fingerprint.

Cite this

@article{73a62e8b3a2a4cefa75139cd8687655c,

title = "Discovering early aspects",

abstract = "Traditionally, aspect-oriented software development (AOSD) has focused on the software life cycle's implementation phase: aspects are identified and captured mainly in code. But aspects are evident earlier in the life cycle, such as during requirements gathering and architecture development. Identifying these early aspects ensures that you can appropriately capture aspects related to the problem domain (as opposed to merely the implementation). Additionally, it offers opportunities for early recognition and negotiation of trade-offs and allows forward and backward aspect traceability. This makes requirements, architecture, and implementation more seamless and lets you apply aspects more systematically. Many techniques exist for dealing with early aspects in practice, but a holistic approach is lacking. This article is an overview of how to exploit early aspects and charts aspects as they move from project inception to development.",

keywords = "Aspect oriented software development, Software life cycle",

author = "Baniassad, {Elisa L.A.} and Clements, {Paul C.} and J{\'u}nior, {Jo{\~a}o Baptista da Silva Ara{\'u}jo} and Moreira, {Ana Maria Diniz} and Awais Rashid and Bedir Tekinerdoǧan",

year = "2006",

month = jan,

day = "1",

doi = "10.1109/MS.2006.8",

language = "English",

volume = "23",

pages = "61--70",

journal = "Ieee Software",

issn = "0740-7459",

publisher = "IEEE Institute of Electrical and Electronics",

number = "1",

}

TY - JOUR

T1 - Discovering early aspects

AU - Baniassad, Elisa L.A.

AU - Clements, Paul C.

AU - Júnior, João Baptista da Silva Araújo

AU - Moreira, Ana Maria Diniz

AU - Rashid, Awais

AU - Tekinerdoǧan, Bedir

PY - 2006/1/1

Y1 - 2006/1/1

N2 - Traditionally, aspect-oriented software development (AOSD) has focused on the software life cycle's implementation phase: aspects are identified and captured mainly in code. But aspects are evident earlier in the life cycle, such as during requirements gathering and architecture development. Identifying these early aspects ensures that you can appropriately capture aspects related to the problem domain (as opposed to merely the implementation). Additionally, it offers opportunities for early recognition and negotiation of trade-offs and allows forward and backward aspect traceability. This makes requirements, architecture, and implementation more seamless and lets you apply aspects more systematically. Many techniques exist for dealing with early aspects in practice, but a holistic approach is lacking. This article is an overview of how to exploit early aspects and charts aspects as they move from project inception to development.

AB - Traditionally, aspect-oriented software development (AOSD) has focused on the software life cycle's implementation phase: aspects are identified and captured mainly in code. But aspects are evident earlier in the life cycle, such as during requirements gathering and architecture development. Identifying these early aspects ensures that you can appropriately capture aspects related to the problem domain (as opposed to merely the implementation). Additionally, it offers opportunities for early recognition and negotiation of trade-offs and allows forward and backward aspect traceability. This makes requirements, architecture, and implementation more seamless and lets you apply aspects more systematically. Many techniques exist for dealing with early aspects in practice, but a holistic approach is lacking. This article is an overview of how to exploit early aspects and charts aspects as they move from project inception to development.

KW - Aspect oriented software development

KW - Software life cycle

UR - http://www.scopus.com/record/display.uri?eid=2-s2.0-31344463651&origin=resultslist&sort=plf-f&src=s&st1

U2 - 10.1109/MS.2006.8

DO - 10.1109/MS.2006.8

M3 - Article

VL - 23

SP - 61

EP - 70

JO - Ieee Software

JF - Ieee Software

SN - 0740-7459

IS - 1

ER -