Melhores práticas para o Jitterbit App Builder

Introdução

As aplicações do App Builder podem crescer em tamanho e complexidade, envolvendo frequentemente o trabalho de vários desenvolvedores ao longo de muitos meses ou anos. Estas melhores práticas ajudarão você a gerenciar essa complexidade, tornar seus aplicativos mais fáceis de manter e mantê-los funcionando com desempenho máximo.

O ciclo de vida do desenvolvimento de aplicativos

Construa seus aplicativos iterando sobre as seguintes tarefas:

1. Descobrir

2. Modelar

3. Construir e demonstrar

4. Refinar e testar

5. Implantar

6. Manter

1. Descobrir: Coletar requisitos

Antes de começar a construir um aplicativo, você deve ter um esboço do que ele fará e quem o usará. Aqui estão algumas ideias sobre como obter essas informações:

• Ouça e aprenda: Organize workshops presenciais e sessões de design para entender quem usará o aplicativo e o que ele deve fazer.

• Identifique informações-chave: Colete e documente os requisitos principais para dados, personas de usuário, processos de negócios e acesso e segurança.

• Evite suposições: Faça perguntas para fazer o usuário do aplicativo pensar criticamente sobre o que está pedindo para você construir. Questione a lógica e a fundamentação por trás dos processos de negócios dos seus usuários.

• Confirme o entendimento: Releia seu entendimento dos requisitos com seus usuários de aplicativo e outras partes interessadas. Use diagramas de fluxo e outras ferramentas visuais para comunicar melhor as necessidades técnicas com usuários não técnicos.

2. Modelar: Projetar a base

Um modelo de dados sólido é a base de uma aplicação bem-sucedida. Esteja disposto a dedicar tempo a esta etapa para evitar trabalho significativo de reelaboração posteriormente.

• Crie um diagrama de relacionamento de entidades (ERD): Um ERD documenta seu modelo de dados, facilitando a compreensão das estruturas e relacionamentos das tabelas. Ele oferece uma experiência semelhante a um quadro branco onde você pode fazer alterações facilmente antes de confirmá-las no banco de dados. A seguir está um exemplo de um ERD simples:

  erDiagram
   Student {
       UUID student_id PK "Student ID"
       string name
   }
     Course {
       UUID course_id PK "Course ID"
       string title
   }
     Enrollment {
       UUID enrollment_id PK "Enrollment ID"
       UUID student_id FK "Student ID"
       UUID course_id FK "Course ID"
       string grade
   }
   Student ||--o{ Enrollment : "takes"
   Course ||--o{ Enrollment : "has"

• Projete elementos fundamentais: Além do modelo de dados, crie fluxogramas, diagramas de raias, wireframes e mapas de site conforme necessário para detalhar o design da aplicação.

3. Construir e demonstrar: Desenvolvimento iterativo

Com um design sólido em vigor, você pode começar a construir a aplicação.

• Construa em camadas: Desenvolva seu aplicativo em camadas distintas: Dados, Lógica de Negócios e Interface do Usuário. Construa de cima para baixo a partir da camada de dados.

• Defina um produto mínimo viável (MVP): Defina e liste os elementos principais do aplicativo e obtenha aprovação dos usuários do aplicativo antes de iniciar a construção principal.

• Demonstre cedo e frequentemente: Agende demonstrações regulares das partes funcionais do aplicativo. Isso ajuda os usuários a entender o que é possível e a ajustar suas expectativas e requisitos.

4. Refinar e testar: Incorporar feedback e QA

• Refine: Incorpore feedback das sessões de demonstração para refinar a aplicação e adicionar recursos de design de UI/UX mais granulares.

• Teste: O teste minucioso é importante.

  • QA interno: Sempre realize testes internos primeiro para detectar bugs.

  • UAT do usuário final: Deixe os usuários do aplicativo realizarem o Teste de Aceitação do Usuário. Eles conhecem melhor o processo de negócios e podem fornecer feedback valioso.

  • Use dados realistas: Use dados de teste realistas para garantir que os recursos sejam testados da forma como os usuários finais os usariam.

  • Testes positivos e negativos: Teste tanto para resultados esperados (testes positivos) quanto para comportamentos inesperados (testes negativos).

5. Implantar: Gerenciamento de lançamento

• Empacote e instale: Use o Gerenciamento de Lançamento do App Builder para promover alterações de esquema e atualizações de aplicativos entre ambientes. Isso garante que as alterações sejam replicadas na ordem correta e reduz o risco de erro humano.

• Lançamento inicial: O MVP está ativo em produção. O desenvolvimento é normalmente congelado por um curto período para se concentrar no suporte à produção.

• Lançamentos futuros: O processo de desenvolvimento recomeça para novos recursos e lançamentos futuros.

6. Documentar e manter

• Documentar o processo de negócio: Isso é essencial para transferência de conhecimento, integração de novos desenvolvedores e para manutenção futura.

• Deletar objetos não utilizados: Delete regularmente tabelas, regras e páginas não utilizadas para reduzir a complexidade da aplicação e facilitar o trabalho.

• Não deixe as coisas quebradas: Finalize os recursos em que está trabalhando. Um recurso quebrado ou inacabado cria confusão para outros desenvolvedores e fica mais difícil de completar depois.

Camada de dados

Modelagem de dados

• Convenções de nomenclatura:

  • Use nomes distintos, singulares e descritivos para tabelas (por exemplo, Customer, Order). Evite abreviá-los quando possível.

  • Use UUIDs para todas as chaves primárias e estrangeiras. Uma boa convenção de nomenclatura é TableNameID (por exemplo, CustomerID).

  • Prefixe campos booleanos com "is" (por exemplo, isActive).

  • Regras de negócio tendem a se multiplicar. Use convenções de nomenclatura de regras de negócio para acompanhá-las.

• Chaves e indexação:

  • Chaves primárias de uma única parte: Use chaves primárias UUID de uma única parte. Isso simplifica o modelo de dados e oferece suporte automático aos recursos completos de auditoria do App Builder.

  • Indexar colunas: Indexe todas as chaves estrangeiras. Também indexe qualquer campo comumente usado para classificação, filtragem ou junção de dados para otimizar o desempenho.

• Relacionamentos:

  • Use tabelas de ponte ou junção para gerenciar relacionamentos muitos-para-muitos. Evite designs planos (adicionar várias colunas para dados relacionados em uma única tabela), pois não são escaláveis.

Design de tabela

• Dados configuráveis: Projete seu modelo de dados para ser configurável. Por exemplo:

  • Valores que podem mudar ao longo do tempo (como status) devem ser armazenados em tabelas de pesquisa separadas em vez de codificados na lógica de negócio.

  • Para dados baseados em tempo (como preços), use uma tabela de nível inferior com intervalos de datas efetivas.

• Ativar auditoria: Ative Audit Lite ou Full Audit para todas as tabelas para rastrear automaticamente as alterações de dados para histórico e conformidade.

• Definir uso da tabela: Conforme cria tabelas, defina seu tipo de uso (Developer, Shared ou User data). Isso controla como os dados são promovidos entre ambientes e é crucial para gerenciamento de lançamentos.

• Valores consistentes: Seja consistente em como usa valores como NULL. Um valor NULL deve ter um significado claro e consistente em todo o modelo de dados.

Tabelas de pesquisa e parâmetros

• Tabelas de pesquisa: Use tabelas de pesquisa para gerenciar listas de valores. Elas devem incluir o seguinte:

  • Title: Um valor de exibição legível para humanos. O App Builder usa o tipo de uso Title para gerar automaticamente controles de lista.

  • Enum: Um valor enumerado estático e legível para humanos. Usar enums na lógica de negócio é muito mais claro do que referenciar um UUID bruto.

  • IsActive: Um booleano para controlar quais valores estão disponíveis para seleção na interface.

  • Index: Uma coluna inteira para controlar a ordem de classificação padrão da lista.

• Tabela de parâmetros: Toda aplicação deve ter uma tabela de parâmetros. Esta é uma tabela única que contém apenas um registro e é usada para armazenar configurações e constantes globais da aplicação. Isso evita codificar valores e permite que administradores os alterem através da interface.

Conexões de dados

• Conexões seguras: Configure conexões seguras com fontes de dados externas.

• Use conectores do App Builder: Quando precisar usar dados do banco de dados de outra aplicação no mesmo servidor, use um Conector do App Builder. Isso reduz dependências de implantação, pois não é necessário fazer push dos modelos lógicos e físicos de ambos os bancos de dados simultaneamente.

Lógica de negócio

Design de regras

• Conheça os tipos de regras disponíveis: Entenda quando usar objetos de negócio (para exibir dados), validações (para verificar dados) e regras CRUD (para alterar dados).

• Mantenha as regras simples: Simplifique a forma como os objetos e as regras são construídos. Use subconsultas reutilizáveis sempre que possível para evitar duplicar lógica.

• Lógica orientada por dados:

  • Configure mais, codifique menos: Armazene valores alteráveis em tabelas de configuração, não diretamente nas regras. Isso permite atualizações fáceis pela interface sem exigir um desenvolvedor.

  • Imponha lógica por meio do modelo de dados: Construa a lógica com base na configuração da tabela em vez de codificar valores. Por exemplo, use um campo booleano em uma tabela para controlar um processo em vez de uma instrução IIF com um status codificado.

• Use funções com eficiência: Use as funções mvSQL integradas do App Builder para tarefas comuns.

Convenções de nomenclatura de regras de negócio

Uma convenção de nomenclatura consistente para regras de negócio ajuda a manter aplicativos complexos. Use o seguinte padrão geral: Alvo (Propósito ou Subtipo) Descritor – Filtro Opcional.

Otimização de consultas

• Selecione apenas as colunas necessárias: Inclua apenas as colunas necessárias nas suas regras.

• Faça junções em chaves: Faça junções de tabelas usando suas chaves UUID para melhor desempenho.

• Junções inteligentes: Use o tipo de junção apropriado para suas necessidades. Prefira usar um único tipo de junção externa (como LEFT JOIN) em uma consulta.

• Otimize cláusulas WHERE: Evite usar expressões em ambos os lados de um operador de cláusula WHERE, pois isso pode impactar negativamente o desempenho.

• Faça UNION no nível mais alto: Ao combinar conjuntos de dados, use UNION no nível mais alto possível da sua consulta para melhor desempenho.

Eventos e ações

• Registre eventos no nível da tabela: Sempre que possível, registre eventos (como validações e ações) no nível da tabela. Isso permite que outras regras de negócio herdem essa lógica, fornecendo um único lugar para gerenciá-la.

• Encadeie ações: Use ações de sucesso e falha para vincular múltiplas regras e validações em fluxos de trabalho complexos do tipo "se isso, então aquilo".

• Compreenda os gatilhos: Saiba o que inicia um evento (uma ação do sistema ou uma ação do usuário).

Validações

• Garanta a qualidade dos dados: Use validações para garantir que os dados estejam corretos antes de serem salvos.

• Aplicação em camadas: Aplique validações no nível da lógica de negócio ou da tabela, não apenas na interface, para garantir a integridade dos dados.

UI/UX

Um bom design de UI/UX é crítico para o sucesso de uma aplicação. Uma interface bem projetada deve ser intuitiva, eficiente e confortável para o usuário do aplicativo.

Princípios de alto nível

• Funcionalidade em primeiro lugar: Concentre-se em criar uma aplicação funcional antes de refinar o design visual. A lógica de negócio e as estruturas de dados podem mudar durante o desenvolvimento, o que pode exigir refazer qualquer trabalho de UI prematuro.

• Consistência é fundamental: Todos os elementos, desde botões e fontes até cores e layout, devem ser consistentes em toda a aplicação. Isso cria uma experiência confortável e previsível para os usuários.

• Mantenha a simplicidade:

  • Seja generoso com o espaço: Não comprima elementos na interface. O espaçamento adequado reduz a desordem e a carga cognitiva, facilitando a compreensão das informações.

  • Use estilos sutis: Use estilos limpos e modernos. Por exemplo, as sombras devem ser leves e sutis, não escuras e avassaladoras (a menos que essa seja sua escolha de estilo corporativo).

  • Exclua objetos não utilizados: Remova páginas não utilizadas e outros objetos para reduzir a sobrecarga do aplicativo e facilitar a manutenção.

Layout e navegação

• Escolha a navegação correta:

  • A navegação lateral é geralmente a melhor opção, pois é responsiva, escalável e pode mostrar claramente uma estrutura de pasta/árvore. É mais adequada para aplicativos com muitos itens de navegação.

  • A navegação superior funciona bem para aplicativos com muito poucos itens de nível superior, onde o espaço da tela é uma prioridade. Não é bem adequada para design responsivo ou submenus profundos.

• Estabeleça uma hierarquia visual: Use tamanho, peso e cor para guiar o olhar do usuário do aplicativo para as informações mais importantes da página. Os títulos dos painéis, subtítulos e conteúdo devem ser distintos.

• Simplifique as ações: Dê aos usuários do seu aplicativo um único lugar claro para executar uma ação específica. Evite fornecer múltiplas maneiras de fazer a mesma coisa.

• Organize o conteúdo:

  • Agrupe o conteúdo: Organize telas complexas com grupos lógicos ou abas.

  • Vincule painéis: Conecte painéis de interface para que a seleção de um item em um atualize automaticamente as informações relacionadas em outro.

  • Use pop-ups corretamente: Use janelas pop-up para detalhes ou entrada de dados. Nunca mostre múltiplos pop-ups empilhados um sobre o outro.

Entrada e interação do usuário

• Projete botões claros:

  • Texto orientado para ação: Use verbos de ação nos botões (por exemplo, "Criar Relatório", "Salvar para Depois") em vez de texto genérico como "Sim" ou "Não".

  • Hierarquia de botões: Crie uma distinção visual clara entre ações primárias (cores sólidas e em negrito) e ações secundárias (contornadas ou menos proeminentes).

• Forneça mensagens de erro úteis: As mensagens de erro devem usar linguagem simples, identificar claramente o problema e sugerir construtivamente uma solução. Não confie apenas na cor para indicar um erro.

• Use ícones efetivamente:

  • Use rótulos com ícones reconhecíveis: Use ícones bem conhecidos (como uma lupa para pesquisa) em combinação com rótulos de texto significativos. Muitos ícones não são universalmente compreendidos pelos usuários do aplicativo por conta própria.

  • Mantenha o estilo consistente: Use ícones que compartilhem o mesmo estilo visual (por exemplo, preenchimento, traço e tamanho).

• Melhore a entrada de dados:

• Marque os campos obrigatórios: Indique claramente quais campos são obrigatórios.

• Use controles de lista: Ofereça opções predefinidas para entrada de dados e garanta consistência.

• Use o designer ao vivo: Faça ajustes de interface em tempo real diretamente na aplicação para refinar rapidamente a experiência do usuário.

Tipografia e cor

• Use fontes legíveis e consistentes:

  • Limite as famílias de fontes: Use no máximo duas famílias de fontes. Frequentemente, uma é suficiente.

  • Considere combinações de fontes: Se usar duas fontes, use uma para títulos e outra para o corpo do texto.

  • Evite letras maiúsculas: Não use letras maiúsculas para o corpo do texto, pois é mais lento de ler. Deve ser usado apenas para alertas curtos ou títulos grandes.

• Use uma paleta de cores clara:

  • Limite as cores: Procure usar de 3 a 4 cores: uma dominante, uma secundária e uma ou duas cores de destaque.

  • Use cores semânticas: Use cores comumente associadas para fornecer informações sobre o estado (por exemplo, vermelho para um aviso, verde para sucesso, cinza para um botão desabilitado).

Design para acessibilidade

• Garanta alto contraste de cores: O texto deve ter uma alta taxa de contraste em relação ao fundo (pelo menos 4,5:1 para texto normal).

• Design para navegação por teclado: Garanta que todos os formulários e elementos interativos funcionem para usuários de aplicativos que só conseguem navegar por teclado.

• Garanta que elementos clicáveis sejam grandes o suficiente: Em dispositivos móveis e telas sensíveis ao toque, certifique-se de que botões, links e outros elementos clicáveis sejam grandes o suficiente para serem usados facilmente. Um tamanho mínimo de 32x32 pixels é um bom ponto de partida.

• Teste em dispositivos móveis reais: A melhor forma de confirmar que sua aplicação é verdadeiramente responsiva e utilizável é testá-la em dispositivos móveis reais, não apenas em emuladores de navegador.

Ambientes e implantações

A abordagem de 3 camadas

Desenvolva seus aplicativos em instâncias do App Builder em pelo menos estes três ambientes:

• DEV (Desenvolvimento): Este ambiente permite que os desenvolvedores trabalhem em novos recursos sem impactar os usuários. Todas as modificações e esforços de desenvolvimento devem ocorrer aqui.

• QA (Garantia de Qualidade): Oferece aos usuários do aplicativo um ambiente para testar sem afetar os desenvolvedores ou os dados de produção.

• PROD (Produção): O ambiente ativo para usuários do aplicativo.

Gerenciamento de lançamento e mudanças

• Nunca modifique QA ou PROD diretamente: Sempre construa em DEV, promova para QA para testes e depois promova para PROD após aprovação do QA. Fazer alterações diretamente em ambientes superiores pode desincronizar seus sistemas e comprometer futuras implantações.

• Use o gerenciamento de lançamento do App Builder: Isso garante que qualquer alteração feita em DEV seja replicada para QA e PROD na mesma ordem, evitando erros humanos.

• Faça backup de bancos de dados: Sempre faça um backup do banco de dados de seus ambientes antes de uma implantação de aplicativo ou de uma atualização de versão do App Builder.

• Registros de mudanças descritivos: Feche os registros de gerenciamento de mudanças frequentemente e seja descritivo sobre o que mudou. Isso facilita a revisão de alterações históricas se precisar solucionar um problema.

• Planeje implantações: Seja metódico ao mover aplicativos para produção e defina expectativas com antecedência. Planeje implantações para fora do horário comercial para minimizar o impacto.

Para orientação sobre planejamento de atualizações de versão da plataforma nesses ambientes, incluindo estratégias in-place e Blue/Green, consulte Estratégias de atualização de produção.

Segurança da aplicação

• Use provedores de segurança: Sempre que possível, use um provedor de segurança para autenticação. Não atribua segurança manualmente.

• Acesso baseado em funções (RBAC): Atribua funções aos usuários do aplicativo para controlar o acesso a páginas e ações. Elementos da interface podem ser configurados para se adaptar de acordo com a função do usuário do aplicativo.

• Gerenciamento eficiente de grupos: Organize usuários do app em grupos para simplificar o gerenciamento de permissões.

• Segurança em nível de linha: Use regras de reach para mostrar diferentes subconjuntos de dados a diferentes usuários do app na mesma tela.

• Integre SSO: Use Single Sign-On (SSO) para autenticação de usuário simplificada e segura.

Sistemas de notificação

• Notificações bidirecionais: Projete notificações para que usuários do app possam responder com opções que atualizam dados da aplicação.

• Conteúdo personalizado: Use dados dinâmicos em mensagens para notificações personalizadas.

• Link para páginas públicas: Garanta que qualquer página da aplicação vinculada de uma notificação seja acessível publicamente.

• Gatilhos consistentes: Registre notificações no nível da tabela para disparo confiável.

• Mensagens configuráveis pelo usuário: Permita que usuários do app modifiquem o texto de notificação pela interface. Isso reduz a necessidade de envolvimento do desenvolvedor para simples alterações de texto.