AOP (Aspect Oriented Programming) quando se popularizou com o AspectJ, e depois com o Spring era visto como o próximo paradigma de programação, a cura pra todos os males, a coisa mais bonita do universo.
Pra quem não conhece, AOP consiste em uma técnica (alguns dizem que é até um paradigma de programação) no qual essencialmente você trabalha com a interceptação de eventos em seu código fonte.
Por exemplo, você quer colocar um log em todos os controladores do seu sistema para saber quanto tempo levam para executar. Uma alternativa, a mais ingênua, seria fazer algo como isto:
def controlador {
def tempoInicial = getTempoInicial()
// faz todo o trabalho duro
def tempoFinal = getTempoInicial() - tempoInicial
logaTempoTotal(tempoFinal)
}
E aí repetiria este código em todos os seus controladores, todas as suas actions, todos os pontos do universo que quisesse medir o tempo de execução. Com a AOP você implementa o que chamamos de aspecto, isto é, a lógica que você quer compartilhar (a medição do tempo, que mencionei agora, por exemplo) e simplesmente configura os pontos nos quais este código será executado.
Este código é literalmente um interceptador: você diz quando começa a sua execução, o que ele irá envolver, e quando irá terminar. Frameworks de segurança, como o Spring Security, por exemplo, fazem essencialmente isto.
Minha experiência é mais com Java, mas em outras plataformas o mesmo conceito se aplicou. Em nosso caso ele apareceu com maior evidência em dois momentos: AspectJ (https://www.eclipse.org/aspectj/), que a partir do momento de compilação você define aonde os aspectos vão ser inseridos no seu sistema e o Spring (https://spring.io), que tinha uma abordagem na minha opinião bem mais interessante por ser bem menos evasiva.
E, claro, tem também o Groovy, que na própria linguagem, por ser dinâmica, já te permite fazer isto usando os recursos que lhe são naturais (e o que mostra o próprio poder da linguagem). Se não me engano, neste vídeo eu mostro isto: https://www.youtube.com/watch?v=AQBxfYBifAk
Mas apesar de algo tão poderoso, AOP acabou meio que caindo no esquecimento. Não houve uma adoção em massa da técnica. Eu consigo ver duas razões:
- Descrevê-lo é muito difícil - quando fui escrever meu livro sobre Spring, por exemplo (Vire o Jogo com Spring Framework) o capítulo mais difícil foi justamente sobre AOP.
- É um perigo para a manutenção: como o código não está visível, se você se esquecer que o aspecto existe, pesadelos de manutenção irão ocorrer.
Então trago a discussão aqui: qual a sua experiência com a AOP? Por que você acha que não foi adotado em massa?
).