Melhores práticas para o Jitterbit App Builder

Introdução

As aplicações do App Builder podem crescer em tamanho e complexidade, muitas vezes envolvendo o trabalho de vários desenvolvedores ao longo de meses ou anos. Essas 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 mostrar

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 de como você pode 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ários, 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. Desafie a lógica e a razão por trás dos processos de negócios de seus usuários.

• Confirme a compreensão: Leia de volta sua compreensão dos requisitos com os usuários do aplicativo e outros interessados. Use diagramas de fluxo e outras ferramentas visuais para comunicar melhor as necessidades técnicas a usuários não técnicos.

2. Modelar: Projetar a fundação

Um modelo de dados sólido é a base de uma aplicação bem-sucedida. Esteja disposto a gastar tempo nesta etapa para evitar retrabalho significativo mais tarde.

• Crie um diagrama de entidade-relacionamento (ERD): Um ERD documenta seu modelo de dados, facilitando a compreensão das estruturas de tabelas e relacionamentos. Ele fornece uma experiência semelhante a um quadro branco, onde você pode fazer alterações facilmente antes de comprometê-las ao banco de dados. O seguinte é 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"

• Elementos fundamentais de design: Além do modelo de dados, crie fluxogramas, diagramas de swimlane, wireframes e sitemaps 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.

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

• Definir 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 ajustar suas expectativas e requisitos.

4. Refinar e testar: Incorporar feedback e QA

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

• Testar: Testes rigorosos são importantes.

  • QA interno: Sempre realize testes internos primeiro para identificar 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: Utilize dados de teste realistas para garantir que os recursos sejam testados da maneira que os usuários finais os utilizariam.

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

5. Implantar: Gerenciamento de lançamentos

• Empacotar e instalar: Use o Gerenciamento de Lançamentos 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 geralmente é congelado por um curto período para focar no suporte à produção.

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

6. Documentar e manter

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

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

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

Camada de dados

Modelagem de dados

• Convenções de nomenclatura:

  • Use substantivos distintos, singulares e descritivos para tabelas (por exemplo, Customer, Order). Evite abreviá-los sempre que 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).

  • As regras de negócios tendem a proliferar. Use convenções de nomenclatura de regras de negócios para mantê-las organizadas.

• 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 suporta automaticamente todas as capacidades de auditoria do App Builder.

  • Indexar colunas: Indexe todas as chaves estrangeiras. Além disso, indexe quaisquer campos que sejam comumente usados para ordenaçã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 (adicionando várias colunas para dados relacionados em uma única tabela), pois não são escaláveis.

Design de tabelas

• 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 consulta separadas, em vez de codificados diretamente na lógica de negócios.

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

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

• Defina o uso da tabela: Ao criar tabelas, defina seu tipo de uso (Desenvolvedor, Compartilhado ou Dados do Usuário). Isso controla como os dados são promovidos entre ambientes e é crucial para o gerenciamento de lançamentos.

• Valores consistentes: Seja consistente na forma como você usa valores como NULL. Um valor NULL deve ter um significado claro e consistente em todo o seu 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:

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

  • Enum: Um valor enumerado estático e legível por humanos. Usar enums na lógica de negócios é 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 do usuário.

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

• Tabela de parâmetros: Todo aplicativo 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 do aplicativo. Isso evita a codificação rígida de valores e permite que os administradores os alterem por meio da interface do usuário.

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 outro aplicativo no mesmo servidor, use um Conector do App Builder. Isso reduz as dependências de implantação, pois você não precisa enviar os modelos lógicos e físicos de ambos os bancos de dados simultaneamente.

Lógica de negócios

Design de regras

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

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

• Lógica orientada a dados:

  • Configure mais, codifique menos: Armazene valores que podem ser alterados em tabelas de configuração, não diretamente nas regras. Isso permite atualizações fáceis via a interface do usuário sem a necessidade de um desenvolvedor.

  • Imponha lógica através do modelo de dados: Construa 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 de forma eficiente: Utilize as funções mvSQL integradas do App Builder para tarefas comuns.

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

Uma convenção de nomenclatura consistente para regras de negócios 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 que você precisa em suas regras.

• Junte por chaves: Junte tabelas usando suas chaves UUID para o 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.

• União no nível mais alto: Ao combinar conjuntos de dados, use UNION no nível mais alto possível em 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ócios herdem essa lógica, proporcionando um único lugar para gerenciá-la.

• Encadeie ações: Use ações de sucesso e falha para vincular várias regras e validações para fluxos de trabalho complexos de "se isso, então aquilo".

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

Validações

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

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

UI/UX

Um bom design de UI/UX é crítico para o sucesso de um aplicativo. 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 um aplicativo funcional antes de refinar o design visual. A lógica de negócios 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 todo o aplicativo. Isso cria uma experiência confortável e previsível para os usuários.

• Mantenha limpo:

  • Seja generoso com espaço: Não comprima elementos na interface do usuário. O espaçamento adequado reduz a desordem e a carga cognitiva, tornando as informações mais fáceis de digerir.

  • Use um estilo sutil: Utilize um estilo limpo e moderno. Por exemplo, sombras devem ser leves e sutis, não escuras e opressivas (a menos que essa seja a escolha de estilo da sua empresa).

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

Layout e navegação

• Escolha a navegação certa:

  • A navegação lateral é geralmente a melhor escolha, 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 na 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 na página. Títulos de painéis, subtítulos e conteúdo devem ser distintos.

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

• Organize o conteúdo:

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

  • Vincule painéis: Conecte painéis da interface do usuário para que selecionar um item em um atualize automaticamente as informações relacionadas em outro.

  • Use pop-ups corretamente: Utilize 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

• Desenhe botões claros:

  • Texto orientado à 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 clara distinção visual entre ações primárias (cores sólidas e ousadas) e ações secundárias (contornadas ou menos proeminentes).

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

• Use ícones de forma eficaz:

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

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

• Melhore a entrada de dados:

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

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

• Use o designer ao vivo: Faça ajustes de UI em tempo real diretamente no aplicativo para refinar rapidamente a experiência do usuário.

Tipografia e cor

• Use fontes legíveis e consistentes:

  • Limite famílias de fontes: Use no máximo duas famílias de fontes. Uma geralmente é suficiente.

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

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

• Use uma paleta de cores clara:

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

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

Projetando para acessibilidade

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

• Projete para navegação por teclado: Certifique-se de que todos os formulários e elementos interativos funcionem para usuários de aplicativos que só podem navegar pelo teclado.

• Garanta que os 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 facilmente utilizados. Um tamanho mínimo de 32x32 pixels é um bom ponto de partida.

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

Ambientes e implantações

A abordagem em 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 ao vivo para os usuários do aplicativo.

Gerenciamento de lançamentos e mudanças

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

• Use o gerenciamento de lançamentos do App Builder: Isso garante que quaisquer alterações feitas em DEV sejam replicadas em QA e PROD na mesma ordem, prevenindo 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 uma atualização de versão do App Builder.

• Registros de mudanças descritivos: Feche os registros de gerenciamento de mudanças com frequência e seja descritivo sobre o que mudou. Isso facilita a revisão de alterações históricas caso você precise 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 após o horário comercial para minimizar o impacto.

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 às páginas e ações. Elementos da interface do usuário podem ser configurados para se adaptar de acordo com a função de um usuário do aplicativo.

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

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

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

Sistemas de notificação

• Notificações bidirecionais: Projete notificações para que os usuários do aplicativo possam responder com opções que atualizam os dados do aplicativo.

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

• Link para páginas públicas: Garanta que quaisquer páginas do aplicativo vinculadas a partir de uma notificação sejam acessíveis publicamente.

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

• Mensagens configuráveis pelo usuário: Permita que os usuários do aplicativo modifiquem o texto da notificação através da interface do usuário. Isso reduz a necessidade de envolvimento do desenvolvedor para mudanças simples de texto.