Abordagem de desenvolvimento: entrada da interface do usuário ou saída do modelo de domínio?

Embora eu nunca tenha entregado nada usando o Smalltalk, meu breve tempo brincando com ele definitivamente deixou sua marca. A única maneira de descrever a experiência é o MVC do jeito que deveria ser. Essencialmente, todo o trabalho pesado para seu aplicativo é feito nos objetos de negócios (ou no modelo de domínio, se você preferir). Os controles padrão são vinculados aos objetos de negócios de alguma maneira. Por exemplo, uma caixa de texto é mapeada para o campo de um objeto (o próprio campo é um objeto, por isso é fácil de fazer). Um botão seria mapeado para um método. Tudo isso é feito com uma API muito simples e natural. Não precisamos pensar em vincular objetos etc. Isso simplesmente funciona.

No entanto, em muitas linguagens e APIs mais recentes, você é forçado a pensar de fora para dentro. Primeiro com C ++ e MFC, e agora com C # e WPF, a Microsoft colocou seu mundo de desenvolvedores conectado aos construtores de GUI nos quais você constrói seu aplicativo implementando manipuladores de eventos . O desenvolvimento do Java Swing não é tão diferente, apenas você está escrevendo o código para instanciar os controles no formulário. Para alguns projetos, talvez nunca haja um modelo de domínio - apenas manipuladores de eventos. Estive dentro e fora deste modelo durante a maior parte da minha carreira.

Cada maneira força você a pensar de maneira diferente. Com a abordagem Smalltalk, seu domínio é inteligente enquanto sua GUI é burra. Com a abordagem padrão do VisualStudio, sua GUI é inteligente, enquanto o modelo de domínio (se existir) é bastante anêmico.

Muitos desenvolvedores com quem trabalho valorizam a abordagem Smalltalk e tentam aplicar essa abordagem no ambiente do VisualStudio. O WPF possui alguns recursos de ligação dinâmica que possibilitam; mas existem limitações. Inevitavelmente, algum código que pertence ao modelo de domínio acaba nas classes da GUI.

Então, de que maneira você cria / desenvolve seu código? Por quê?

• GUI primeiro. A interação do usuário é fundamental.
• Domínio primeiro. Preciso garantir que o sistema esteja correto antes de colocarmos uma interface do usuário.

Há prós e contras para qualquer abordagem. O modelo de domínio se encaixa com catedrais de cristal e torta no céu. GUI se encaixa lá com rápido e sujo (às vezes muito sujo).

E para um bônus adicional: como você garante que o código seja sustentável?

Nem

Ao longo dos anos em que desenvolvi software, comecei a praticar uma primeira metodologia, porque sempre há um "meio termo" a ser levado em consideração. Coloque uma interface entre o código da interface do usuário e o código comercial e faça um acordo sobre o que a interface do usuário precisa no momento no domínio.

Deixe-me fazer uma figura para tornar esse conceito claro:

  +------+
  |  UI  | <- Think about how to make an effective user interface
  +------+
      |
      |
 +----------+
 | Contract | <--- This part over here is really REALLY important, man!
 +----------+
      |
      |
+--------------+
| Domain model | <- Think about what the user needs
+--------------+ 

Dessa forma, você pode trabalhar iterativamente na interface do usuário e no modelo de domínio separadamente, se o meio termo deixar claro como os dados que a interface do usuário pode receber.

A razão pela qual vejo por que alguns projetos se tornam insustentáveis é porque a interface entre dados e apresentação foi apressada ou inexistente (o código de manipulação de dados direto está na interface do usuário). Já vi tantos projetos em que o código do banco de dados residia no código do formulário que perdi a fé na humanidade. Apenas os poucos projetos que vi que têm esse meio termo rígido restauram a fé perdida.

Realmente não importa de qual final onde começar primeiro ... o que importa é que você tem que separação clara das preocupações no lugar. Esse contrato no meio define praticamente o aplicativo ou sistema em questão. Pense nisso primeiro antes de ir de baixo para cima ou de cima para baixo .

Domínio primeiro. Preciso garantir que o sistema esteja correto antes de colocarmos uma interface do usuário.

Nada mais pode ser feito para funcionar - exceto em casos simples.

A partir da interface do usuário geralmente leva a softwares frágeis e com erros que podem parecer divertidos, mas geralmente apresentam sérios problemas no modelo.

Não é certo que a interface do usuário esteja fadada ao fracasso - se o modelo for simples o suficiente, a interface do usuário poderá ser criada primeiro com a confiança de que o modelo funcionará bem no final.

Em qualquer caso em que o modelo não possa ser facilmente imaginado, ele deve ser construído primeiro.

O pior caso é quando algum programador pensa que pode imaginar o modelo. Eles podem ter omitido detalhes importantes, casos especiais, exceções ou considerações de desempenho. Como a GUI já foi criada e muitas considerações foram omitidas, o modelo é terrível.

Isso realmente depende do aplicativo em questão.

Se você estiver construindo um aplicativo cliente / servidor fechado, qualquer uma dessas abordagens seria suficiente; pois você manipulará o back-end para atender às necessidades de front-end inevitavelmente.

Se você estiver criando um aplicativo cliente / servidor aberto no qual um serviço da Web em potencial será exposto para uso dos seus clientes, é essencial ter consciência de como esse serviço pode ser usado por um cliente para desenvolver um front end.

Muitas vezes, ultimamente, no que diz respeito a uma série de pequenos ciclos iterativos no desenvolvimento (Scrum, Kanban, etc ...), o front end e o back end são feitos em paralelo. Trata-se de fornecer o que você precisa para essa iteração; desconsiderando a construção, caso precisemos dela . Em uma abordagem paralela, as duas extremidades ficam muito mais próximas ao longo do desenvolvimento, o que pode aliviar a necessidade de mudanças contínuas quando o front end e o back end se fundem. Esta é a minha abordagem preferida quando possível.

Você mencionou...

... O WPF possui alguns recursos de ligação dinâmica que possibilitam; mas existem limitações. Inevitavelmente, algum código que pertence ao modelo de domínio acaba nas classes da GUI ...

Não sabe o que você quer dizer com alguns ? WPF e SL são conhecidos por sua funcionalidade de ligação. É interminável. Se você está sendo forçado a inserir código na sua Visualização em um aplicativo WPF baseado em MVVM, algo precisa ser tratado. Comportamentos anexados são uma maneira de implementar o comportamento sem vincular eventos no View, bem como muitas outras abordagens para garantir que o seu View permaneça limpo.

O front end de uma postura de interação do usuário não deve ter nada a ver com a implementação de back end. O único trabalho de back-end para um front-end é fornecer dados por meio do processamento de dados ou outros meios. Isso está relacionado ao tipo de aplicativo que está sendo desenvolvido.

Garantir a manutenção do código fonte é realmente uma questão completamente diferente. Em um nível alto, refere-se às melhores práticas de codificação, além de seguir padrões, arquiteturas e tecnologias comprovadas.

Prefiro projetar a interface do usuário básica primeiro (mesmo que seja apenas no papel), com a contribuição do cliente. O cliente pode realmente não saber o que deseja até vê-lo. Você nem sempre pode confiar no que o cliente diz. Você pode investir semanas escrevendo um modelo de domínio robusto apenas para descobrir que ele não se encaixa no que o cliente descobre que deseja depois que começa a ver os protótipos da interface do usuário.

Tentamos dirigir nosso software com testes automatizados. O teste automatizado da interface do usuário consome muito tempo. Os scripts para verificar alguns valores em um console são mais fáceis.

Com isso em mente, temos o cuidado de manter a lógica de negócios separada da interface do usuário.

Lembro-me de uma vez até ter um desenvolvedor líder gritando comigo que a arquitetura Document / View era considerada obsoleta quando sugeri que precisávamos parar de vincular todo o nosso código comercial à interface do usuário (e estávamos usando o win32 em C ++ na época, portanto, esta programação de arrastar e soltar coisa nem era problema nosso). Eu estava simplesmente pasmo.

Na IMNSHO, simplesmente não há desculpa para não ter pelo menos uma camada de negócios versus interface do usuário. Se o seu produto fizer algo levemente interessante, é absolutamente necessário que essa separação permita a reutilização do código.

Como desenvolvedor de C #, eu definitivamente não acho que você se dedique a trabalhar de fora para dentro. Eu prefiro fazer o modelo de domínio primeiro, na verdade.

Para o WPF, a única desvantagem do modelo que eu descrevi é que às vezes você precisa mediar entre a interface do usuário e o modelo de domínio. Ainda assim, embora isso às vezes signifique mais trabalho, também significa código mais limpo.

Certamente, domínio primeiro!

A beleza do Smalltalk era que você poderia "conduzir" com facilidade um modelo de domínio de várias maneiras, incluindo "imprimi-lo" em um espaço de trabalho ou em um inspetor. Somente quando você tinha certeza de que seu domínio estava funcionando como desejado, você se atreveu a criar a GUI perfeita.

Isso não quer dizer que Smalltalkers não funcionou nos dois simultaneamente, mas quando sua GUI falhou em implementar a lógica de negócios, você geralmente corrigiu o modelo de domínio primeiro, em vez de colocar casos especiais em sua GUI.