Discovering Early Aspects

E. Baniassad; P. Clements; J. Araujo; A Moreira; A. Rashid; B. Tekinerdogan

doi:10.1109/MS.2006.8

Discovering Early Aspects

E. Baniassad, P. Clements, J. Araujo, A Moreira, A. Rashid, B. Tekinerdogan

Research output: Contribution to journal › Article › Academic › peer-review

140 Citations (Scopus)

293 Downloads (Pure)

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	Undefined
Article number	10.1109/MS.2006.8
Pages (from-to)	61-70
Number of pages	10
Journal	IEEE software
Volume	23
Issue number	500-266/1
DOIs	https://doi.org/10.1109/MS.2006.8
Publication status	Published - 15 Jan 2006

Keywords

CR-D.2
EWI-8896
METIS-237854
IR-66816

Access to Document

10.1109/MS.2006.8

http://doi.ieeecomputersociety.org/10.1109/MS.2006.8

Cite this

@article{540a3b20c00e4fe08d858a1f006b055a,

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 = "CR-D.2, EWI-8896, METIS-237854, IR-66816",

author = "E. Baniassad and P. Clements and J. Araujo and A Moreira and A. Rashid and B. Tekinerdogan",

note = "10.1109/MS.2006.8 ",

year = "2006",

month = jan,

day = "15",

doi = "10.1109/MS.2006.8",

language = "Undefined",

volume = "23",

pages = "61--70",

journal = "IEEE software",

issn = "0740-7459",

publisher = "IEEE",

number = "500-266/1",

}

TY - JOUR

T1 - Discovering Early Aspects

AU - Baniassad, E.

AU - Clements, P.

AU - Araujo, J.

AU - Moreira, A

AU - Rashid, A.

AU - Tekinerdogan, B.

N1 - 10.1109/MS.2006.8

PY - 2006/1/15

Y1 - 2006/1/15

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 - CR-D.2

KW - EWI-8896

KW - METIS-237854

KW - IR-66816

U2 - 10.1109/MS.2006.8

DO - 10.1109/MS.2006.8

M3 - Article

SN - 0740-7459

VL - 23

SP - 61

EP - 70

JO - IEEE software

JF - IEEE software

IS - 500-266/1

M1 - 10.1109/MS.2006.8

ER -