Orientação a Eventos versus Orientação a Aspectos
Autor: José Lopes | Publicado: 2009-03-15T23:55:00-03:00

Paradigma Orientado a Eventos
Diferentemente de paradigmas como Estruturado e Funcional, o paradigma Orientado a Eventos está mais para uma técnica de programação do que para um paradigma propriamente dito. A Wikipedia define este paradigma como aquele em que o fluxo do programa é determinado por eventos.
Nota: Entenda-se por evento, qualquer interação do usuário com o programa, como pressionar de alguma tecla ou movimentação no mouse, além de mensagens de outros programas ou threads.
A mesma fonte ainda define o paradigma como uma técnica de arquitetura onde a aplicação possui uma iteração principal, que possui duas áreas bem definidas: a detecção de eventos e o tratamento dos mesmos. 
Para termos uma noção do que isto significa, tomemos o seguinte exemplo escrito em Python e PyGTK, que cria uma janela com um botão, que se fecha quando este botão é clicado.
#!/usr/bin/env python


"""Implements simple operations on PyGTK.

Hello World is a simple Python program which
uses PyGTK to show a window with a Hello World
button. This window closes when button is clicked.

It's an adaptation of the original code in 
PyGTK tutorial

"""


import pygtk
pygtk.require('2.0')
import gtk


class HelloWorld:
    
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        
        self.window.connect("delete_event", self.delete_event)
        self.window.connect("destroy", self.destroy)
        
        self.window.set_border_width(10)
        self.button = gtk.Button("Hello World")
        
        self.button.connect("clicked", self.hello, None)
        self.button.connect_object("clicked", gtk.Widget.destroy, self.window)
        
        self.window.add(self.button)
        
        self.button.show()
        self.window.show()

    def run(self):
        gtk.main()
    
    def destroy(self, widget, data=None):
        print "destroy signal occurred"
        gtk.main_quit()
    
    def delete_event(self, widget, event, data=None):
        print "delete event occurred"
        return False

    def hello(self, widget, data=None):
        print "Hello World"


# 
# Main
# 

if __name__ == "__main__":
    hello = HelloWorld()
    hello.run()
Listagem 1. Exemplo de código orientado a eventos.
Na listagem 1, temos como exemplo de loop principal, a função run(). Nas linhas 26, 27, 32 e 33, temos a ligação dos eventos (i.e., signals) com os seus respectivos tratadores (i.e., callbacks). Estes tratadores são definidos na forma de funções e quando um evento é detectado em um componente do programa, o mesmo procura no seu código pelo tratador específico daquele evento, redirecionando o fluxo de execução para o mesmo, caso exista. No caso, quando o botão for clicado, por exemplo, o fluxo de execução do programa será desviado para o método hello() (linha 32), que imprimirá uma mensagem na tela. Repare que este mesmo botão possui outro evento associado a ele (linha 33), que executa o método de destruição da janela. Assim, ao clicar no botão, uma mensagem é impressa e a janela se fecha.
Vantagem e Desvantagem
Uma vantagem da programação orientada a eventos é que o conceito de eventos facilita a criação e manipulação de interfaces gráficas para programas. A desvantagem é que o entendimento deste paradigma é complicado para iniciantes, pois a maioria está acostumada a programas sequenciais, com uma única entrada e uma única saída.
Programação Orientada a Aspectos
A Programação Orientada a Aspectos (POA) objetiva separar semanticamente o código, como forma de torná-lo mais legível e fácil de se manter que nos outros paradigmas. Ao se programar Orientado a Objetos, o programador tenta encapsular várias características comuns dentro de classes, que são instanciadas ao longo do programa, criando os objetos. Já na na POA, o objetivo é aglomerar essas chamadas, de forma com que todos os aspectos do programa sejam codificados juntos.
Este é um paradigma relativamente novo e os seus conceitos ainda não estão amadurecidos como os da OO, por exemplo. Por isso não há tanto suporte para ele quanto em outros paradigmas. Apesar disso, todas as fontes pesquisadas apontam que este paradigma está em pleno desenvolvimento e que seu futuro é promissor. A grande desvantagem apontada para este paradigma é a depuração do código, que segundo a Wikipedia é complicada. Já a vantagem é a organização do código, que facilita a manutenção do software.
A linguagem orientada a aspectos mais usada atualmente é a AspectJ, que foi criada pelo próprio desenvolvedor&nbsp; do paradigma, Gregor Kiczales e sua equipe na Xerox PARC. Recomendo a leitura dos textos sobre o paradigma, na seção Leitura Recomendada, para mais detalhes sobre o assunto e exemplos de códigos e ferramentas para este tipo de programação.
Conclusão
Na Programação Orientada a Eventos (POE), o programador tem a preocupação de quando algo vai acontecer. Este acontecimento pode se dar a qualquer momento ou pode até não acontecer, mas o programa tem de estar preparado para ele. Para isso, existem os conceitos de signals e callbacks, que detectam o acontecimento de um evento e tomam as medidas necessárias para tratá-lo. Isto ajuda muito na confecção de interfaces gráficas, pois nunca se sabe qual será a ação do usuário, além de possibilitar que o programa torne-se mais flexível, adaptando-se à maioria dos usuários.
A POA apresenta um conceito relativamente novo e promissor para codificação de softwares, mas o preço dessa juventude é a falta de maturidade do paradigma e a falta de ferramentas (linguagens, componentes e IDEs). 


Leitura Recomendada
Event-Driven Programming – Um bom tutorial em inglês
Wikipedia – Página da Wikipedia sobre o assunto, em inglês
Dextra – Entendendo a Programação Orientada a Aspectos
UFSC – Programação Orientada a Aspectos

Clube de Revista
Anterior – Paradigma Funcional
Próximo – ?